agent-device 0.21.14 → 0.21.16

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

@@ -3,6 +3,7 @@ import XCTest
 
 
 extension RunnerTests {
+  @MainActor
   func typeTextReliably(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -135,6 +136,39 @@ extension RunnerTests {
       }
     }
 
+
+
+
+
+
+    let synthesizedTypePlan = Self.synthesizedTextPlan(
+      characterCount: text.count,
+      delaySeconds: delaySeconds,
+      selectsExistingText: false,
+      peelsWarmupCharacter: repairMode != .none
+    )
+
+
+
+
+    let synthesizedTypeCarriesTheCommand = !SynthesizedDeliveryBudget.exceeds(synthesizedTypePlan)
+
+
+
+
+
+    func typeApplicationWide(_ value: String, reason: String) -> (element: XCUIElement?, failure: TextEntryFailure?) {
+      NSLog(
+        "AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=xctest-application-fallback reason=%@ chars=%d commandChars=%d",
+        reason,
+        value.count,
+        text.count
+      )
+      textEntryRoute = "xctest-application-fallback"
+      app.typeText(value)
+      return (resolveTextEntryElement(app: app, target: activeTarget), nil)
+    }
+
     func typeIntoCurrentTarget(_ value: String) -> (element: XCUIElement?, failure: TextEntryFailure?) {
 #if os(iOS)
       if shouldUseSynthesizedFirstResponderType {
@@ -162,17 +196,18 @@ extension RunnerTests {
         return (currentTarget, nil)
       } else if activeTarget.prefersFocusedElement && isKeyboardVisible(app: app) {
 #if os(iOS)
+
+
+
+
+        guard synthesizedTypeCarriesTheCommand else {
+          return typeApplicationWide(value, reason: "delivery-budget")
+        }
         textEntryRoute = "synthesized-first-responder"
         NSLog("AGENT_DEVICE_RUNNER_TEXT_ENTRY_ROUTE route=synthesized-first-responder")
-        let action = synthesizer.enterText(
-          app: app,
-          text: value,
-          replacingExistingText: false
-        )
-        switch action {
+        switch synthesizer.enterText(app: app, text: value, replacingExistingText: false) {
         case .fallback:
-          textEntryRoute = "xctest-application-fallback"
-          app.typeText(value)
+          return typeApplicationWide(value, reason: "synthesis-unavailable")
         case .raise(let message):
           NSException(
             name: NSExceptionName.internalInconsistencyException,
@@ -200,131 +235,100 @@ extension RunnerTests {
       )
     }
 
-    func waitForWarmupValue(_ expectedValue: String?, target: TextEntryTarget) {
-      guard let expectedValue else {
+    func readBackWarmupCharacter(_ peeledCharacter: String) {
+
+
+
+      let warmupExpectedText = expectedTextEntryValue(
+        typedText: peeledCharacter,
+        mode: repairMode,
+        initialText: initialText
+      )
+      guard let warmupExpectedText else {
         sleepFor(TextEntryTiming.pollInterval)
         return
       }
       let deadline = Date().addingTimeInterval(TextEntryTiming.warmupValueTimeout)
       while Date() < deadline {
-        if editableTextValue(for: resolveTextEntryElement(app: app, target: target)) == expectedValue {
+        if editableTextValue(for: resolveTextEntryElement(app: app, target: activeTarget)) == warmupExpectedText {
           return
         }
         sleepFor(TextEntryTiming.pollInterval)
       }
     }
 
-    let characters = Array(text)
-    if delaySeconds > 0 && characters.count > 1 {
-      var typedTarget: XCUIElement?
-      let delayedTypeStartedAt = Date()
-      for (index, character) in characters.enumerated() {
-        let dispatch = typeIntoCurrentTarget(String(character))
+
+
+    var typedTarget: XCUIElement?
+    var sawWarmupPost = false
+    var planFailure: TextEntryResult?
+    var stepStartedAt = Date()
+    let pacedStartedAt = Date()
+    runSynthesizedTextPlan(
+      synthesizedTypePlan,
+      text: text,
+      post: { slice, step in
+        stepStartedAt = Date()
+        let dispatch = typeIntoCurrentTarget(slice)
         if let failure = dispatch.failure {
-          return dispatchFailureResult(failure)
+          planFailure = dispatchFailureResult(failure)
+          return .stop
         }
         typedTarget = dispatch.element ?? typedTarget
-        if index + 1 < characters.count {
-          sleepFor(delaySeconds)
+        if step.warmsUpField {
+
+          activeTarget = activeTarget.withElement(typedTarget)
         }
-      }
-      logTextEntryPhase(
-        commandId: commandId,
-        phase: "type-delayed",
-        startedAt: delayedTypeStartedAt,
-        chars: characters.count,
-        mode: repairMode
-      )
-      if repairMode == .none {
-        logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: text.count, mode: repairMode)
-        return TextEntryResult(
-          verified: nil,
-          repaired: false,
-          expectedText: nil,
-          observedText: nil,
-          textEntryRoute: textEntryRoute
+        return .posted
+      },
+      waitAfterWarmupCharacter: { peeledCharacter in
+        let warmupStartedAt = Date()
+        readBackWarmupCharacter(peeledCharacter)
+        logTextEntryPhase(
+          commandId: commandId,
+          phase: "warmup",
+          startedAt: warmupStartedAt,
+          chars: 1,
+          mode: repairMode
+        )
+      },
+      didPostStep: { step in
+        guard !synthesizedTypePlan.pacesEveryCharacter else {
+          return
+        }
+        let phase: String
+        if step.warmsUpField {
+          phase = "type-first"
+          sawWarmupPost = true
+        } else {
+          phase = sawWarmupPost ? "type-remaining" : "type-all"
+        }
+        logTextEntryPhase(
+          commandId: commandId,
+          phase: phase,
+          startedAt: stepStartedAt,
+          chars: step.characterCount,
+          mode: repairMode
         )
       }
-      let verifyStartedAt = Date()
-      var result = verifyTextEntryWithRepairIfNeeded(
-        app: app,
-        target: activeTarget.withElement(typedTarget),
-        expectedText: expectedText,
-        repairMode: repairMode
-      )
+    )
+    if synthesizedTypePlan.pacesEveryCharacter {
+
+
       logTextEntryPhase(
         commandId: commandId,
-        phase: "verify",
-        startedAt: verifyStartedAt,
-        chars: characters.count,
+        phase: "type-delayed",
+        startedAt: pacedStartedAt,
+        chars: text.count,
         mode: repairMode
       )
-      logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: text.count, mode: repairMode)
-      result.textEntryRoute = textEntryRoute
-      return result
     }
 
-    let typedTarget: XCUIElement?
-    if repairMode != .none && characters.count > 1 {
-      let firstCharacter = String(characters[0])
-      let firstStartedAt = Date()
-      let firstDispatch = typeIntoCurrentTarget(firstCharacter)
-      if let failure = firstDispatch.failure {
-        return dispatchFailureResult(failure)
-      }
-      var firstTypedTarget = firstDispatch.element
-      logTextEntryPhase(
-        commandId: commandId,
-        phase: "type-first",
-        startedAt: firstStartedAt,
-        chars: 1,
-        mode: repairMode
-      )
-      activeTarget = activeTarget.withElement(firstTypedTarget)
-      let warmupExpectedText = expectedTextEntryValue(
-        typedText: firstCharacter,
-        mode: repairMode,
-        initialText: initialText
-      )
-      let warmupStartedAt = Date()
-      waitForWarmupValue(warmupExpectedText, target: activeTarget)
-      logTextEntryPhase(
-        commandId: commandId,
-        phase: "warmup",
-        startedAt: warmupStartedAt,
-        chars: 1,
-        mode: repairMode
-      )
-      let remainingText = String(characters.dropFirst())
-      let remainingStartedAt = Date()
-      let remainingDispatch = typeIntoCurrentTarget(remainingText)
-      if let failure = remainingDispatch.failure {
-        return dispatchFailureResult(failure)
-      }
-      firstTypedTarget = remainingDispatch.element ?? firstTypedTarget
-      logTextEntryPhase(
-        commandId: commandId,
-        phase: "type-remaining",
-        startedAt: remainingStartedAt,
-        chars: characters.count - 1,
-        mode: repairMode
-      )
-      typedTarget = firstTypedTarget
-    } else {
-      let typeStartedAt = Date()
-      let dispatch = typeIntoCurrentTarget(text)
-      if let failure = dispatch.failure {
-        return dispatchFailureResult(failure)
-      }
-      typedTarget = dispatch.element
-      logTextEntryPhase(
-        commandId: commandId,
-        phase: "type-all",
-        startedAt: typeStartedAt,
-        chars: characters.count,
-        mode: repairMode
-      )
+
+    if let failure = planFailure {
+      return failure
     }
+    activeTarget = activeTarget.withElement(typedTarget)
     if repairMode == .none {
       logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: text.count, mode: repairMode)
       return TextEntryResult(
@@ -338,7 +342,7 @@ extension RunnerTests {
     let verifyStartedAt = Date()
     var result = verifyTextEntryWithRepairIfNeeded(
       app: app,
-      target: activeTarget.withElement(typedTarget),
+      target: activeTarget,
       expectedText: expectedText,
       repairMode: repairMode
     )
@@ -346,7 +350,7 @@ extension RunnerTests {
       commandId: commandId,
       phase: "verify",
       startedAt: verifyStartedAt,
-      chars: characters.count,
+      chars: text.count,
       mode: repairMode
     )
     logTextEntryPhase(commandId: commandId, phase: "total", startedAt: totalStartedAt, chars: text.count, mode: repairMode)

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

@@ -33,11 +33,7 @@ extension RunnerTests {
       let combined = buffer + data
       if let body = self.parseRequest(data: combined) {
         self.handleRequestBody(body) { [weak self] result in
-          self?.sendResponse(result.data, over: connection) { [weak self] in
-            if result.shouldFinish {
-              self?.finish()
-            }
-          }
+          self?.sendResult(result, over: connection)
         }
       } else {
         self.receiveRequest(connection: connection, buffer: combined)
@@ -45,10 +41,21 @@ extension RunnerTests {
     }
   }
 
+  private func sendResult(
+    _ result: (data: Data, shouldFinish: Bool),
+    over connection: NWConnection
+  ) {
+    sendResponse(result.data, over: connection) { [weak self] in
+      if result.shouldFinish {
+        self?.finish()
+      }
+    }
+  }
+
   private func sendResponse(
     _ response: Data,
     over connection: NWConnection,
-    afterSend: @escaping () -> Void = {}
+    afterSend: @escaping @Sendable () -> Void = {}
   ) {
     connection.send(content: response, isComplete: true, completion: .contentProcessed { error in
       if let error {
@@ -89,7 +96,7 @@ extension RunnerTests {
 
   private func handleRequestBody(
     _ body: Data,
-    completion: @escaping ((data: Data, shouldFinish: Bool)) -> Void
+    completion: @escaping @Sendable ((data: Data, shouldFinish: Bool)) -> Void
   ) {
     guard String(data: body, encoding: .utf8) != nil else {
       completion((
@@ -187,7 +194,7 @@ extension RunnerTests {
 
   func enqueueAccepted(
     command: Command,
-    completion: @escaping (Result<Response, Error>) -> Void
+    completion: @escaping @Sendable (Result<Response, Error>) -> Void
   ) {
     commandJournal.accept(command: command)
     commandExecutionQueue.async {
@@ -202,7 +209,7 @@ extension RunnerTests {
 
   func attachToInFlightCommandIfNeeded(
     command: Command,
-    completion: @escaping ((data: Data, shouldFinish: Bool)) -> Void
+    completion: @escaping @Sendable ((data: Data, shouldFinish: Bool)) -> Void
   ) -> Bool {
     guard let commandId = command.commandId?.trimmedNonEmpty else { return false }
     inFlightCommandLock.lock()
@@ -226,7 +233,7 @@ extension RunnerTests {
     result: (data: Data, shouldFinish: Bool),
     completion: ((data: Data, shouldFinish: Bool)) -> Void
   ) {
-    var waiters: [((data: Data, shouldFinish: Bool)) -> Void] = []
+    var waiters: [@Sendable ((data: Data, shouldFinish: Bool)) -> Void] = []
     if let commandId = command.commandId?.trimmedNonEmpty {
       inFlightCommandLock.lock()
       inFlightCommandIds.remove(commandId)

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

@@ -52,23 +52,22 @@ extension RunnerTests {
   }
 
   func elementHasFocus(_ element: XCUIElement) -> Bool {
-    var focused = false
-    _ = RunnerObjCExceptionCatcher.catchException({
-      if let value = (element as NSObject).value(forKey: "hasFocus") as? Bool {
-        focused = value
-      }
-    })
-    return focused
+    return focusBool(element as NSObject)
   }
 
-  func activateElement(app: XCUIApplication, element: XCUIElement, action: String) -> RunnerInteractionOutcome {
+  func activateElement(
+    app: XCUIApplication,
+    element: XCUIElement,
+    action: String,
+    resolvedFrame: CGRect? = nil
+  ) -> RunnerInteractionOutcome {
     if let outcome = selectFocusedTvElement(app: app, element: element, action: action) {
       return outcome
     }
 #if os(tvOS)
     return performElementTap(element)
 #else
-    let frame = element.frame
+    let frame = resolvedFrame ?? element.frame
     if !frame.isEmpty {
 
 

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

@@ -2,6 +2,7 @@ import XCTest
 import AgentDeviceSnapshotPresentation
 
 extension RunnerTests {
+  @MainActor
   func executeTypeCommand(activeApp: XCUIApplication, command: Command) -> Response {
     guard let text = command.text else {
       return Response(ok: false, error: ErrorPayload(message: "type requires text"))
@@ -18,7 +19,7 @@ extension RunnerTests {
       : nil
     let focusStartedAt = Date()
 #if os(iOS)
-    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: currentBundleId)
+    let xCTestChannelPenalized = isSnapshotXCTestChannelPenalized(bundleId: mainOwned.bundleId)
     var resolvedCoordinateTarget: TextEntryTarget?
     if Self.shouldUseResolvedCoordinateTextEntryRoute(
       repairMode: textEntryMode,

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

@@ -54,11 +54,7 @@ final class RunnerTests: XCTestCase {
   let commandExecutionQueue = DispatchQueue(label: "agent-device.runner.commands")
   let app = XCUIApplication()
   lazy var springboard = XCUIApplication(bundleIdentifier: Self.springboardBundleId)
-
-
-  var currentApp: XCUIApplication?
-  var currentBundleId: String?
-  var currentAppProcessIdentifier: Int?
+  let mainOwned = RunnerMainOwnedState()
 
 
   var pendingTargetActivation: TargetActivationFactPayload?
@@ -68,7 +64,7 @@ final class RunnerTests: XCTestCase {
 
   var textEntryTapWitness: TextEntryTapWitness?
   let maxRequestBytes = 2 * 1024 * 1024
-  let mainThreadExecutionTimeout: TimeInterval = 30
+  static let mainThreadExecutionTimeout: TimeInterval = 30
   let appExistenceTimeout: TimeInterval = 30
   let retryCooldown: TimeInterval = 0.2
   let postSnapshotInteractionDelay: TimeInterval = 0.2
@@ -83,27 +79,25 @@ final class RunnerTests: XCTestCase {
 
 
   let recordingFrameCaptureTimeout: TimeInterval = 1
-  var needsPostSnapshotInteractionDelay = false
 
 
 
 
   var lastLoggedFastAppGuardLine: String?
   var lastLoggedGesturePolicyLines: [SynthesizedGesturePolicyKind: String] = [:]
-  var runnerMarkerWriter: (String) -> Void = { NSLog("%@", $0) }
+  var runnerMarkerWriter: @MainActor (String) -> Void = { NSLog("%@", $0) }
 
 
 
 
   var firstInteractionReadyUptime: TimeInterval?
-  var runnerAccessibilityHealth: RunnerAccessibilityHealth = .unknown
   var activeRecording: ScreenRecorder?
   let commandJournal = RunnerCommandJournal()
 
 
   let inFlightCommandLock = NSLock()
   var inFlightCommandIds: Set<String> = []
-  var inFlightCommandWaiters: [String: [((data: Data, shouldFinish: Bool)) -> Void]] = [:]
+  var inFlightCommandWaiters: [String: [@Sendable ((data: Data, shouldFinish: Bool)) -> Void]] = [:]
 
 
 
@@ -206,6 +200,13 @@ final class RunnerTests: XCTestCase {
 
 
 
+
+
+
+
+
+
+
 
 
 
@@ -316,7 +317,7 @@ final class RunnerTests: XCTestCase {
       deadline: .now() + xctestIdleKeepaliveInterval,
       repeating: xctestIdleKeepaliveInterval
     )
-    idleKeepaliveTimer.setEventHandler {
+    idleKeepaliveTimer.setEventHandler { @Sendable in
       NSLog("AGENT_DEVICE_RUNNER_IDLE_KEEPALIVE")
     }
     idleKeepaliveTimer.resume()

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

@@ -2,12 +2,15 @@ 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.
+  /// Twin of `isPositiveFiniteRect` in `packages/kernel/src/rect.ts`, and the one place the
+  /// `hittable` rule asks whether a box may be plotted or measured (#2891). Three refusals, each
+  /// reachable by a different input: a non-finite component, a finite box wide enough to overflow
+  /// its own right or bottom edge, and `CGRect.infinite`, which is built of finite components and
+  /// finite extents and so is refused by identity alone.
   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.minX.isFinite && rect.minY.isFinite
+      && rect.maxX.isFinite && rect.maxY.isFinite
       && rect.size.width > 0 && rect.size.height > 0
   }
 

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

@@ -34,6 +34,8 @@ public struct RawAXNode: Equatable {
   public let label: String?
   public let identifier: String?
   public let value: String?
+  /// The text a text field shows while empty (`placeholderValue`); `nil` for every other node.
+  public let placeholder: String?
   public var rect: SnapshotRect
   public let enabled: Bool
   public let focused: Bool?
@@ -52,6 +54,7 @@ public struct RawAXNode: Equatable {
     label: String?,
     identifier: String?,
     value: String?,
+    placeholder: String? = nil,
     rect: SnapshotRect,
     enabled: Bool,
     focused: Bool?,
@@ -68,6 +71,7 @@ public struct RawAXNode: Equatable {
     self.label = label
     self.identifier = identifier
     self.value = value
+    self.placeholder = placeholder
     self.rect = rect
     self.enabled = enabled
     self.focused = focused
@@ -157,11 +161,14 @@ 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.
+  /// A box that was checked on the way in. The initializer is the only gate: no caller, inside this
+  /// package or outside it, holds a `Box` whose rectangle `SnapshotGeometry.isPositiveFinite`
+  /// refuses, so a `.reported` case never needs re-checking what it was handed.
   public struct Box: Equatable {
     public let rect: CGRect
 
-    init(positiveFinite rect: CGRect) {
+    init?(checked rect: CGRect) {
+      guard SnapshotGeometry.isPositiveFinite(rect) else { return nil }
       self.rect = rect
     }
   }
@@ -194,15 +201,13 @@ public enum SnapshotViewport: Equatable {
     box: CGRect,
     interfaceOrientation: Int = RunnerInterfaceOrientation.unknown
   ) -> SnapshotViewport {
-    SnapshotGeometry.isPositiveFinite(box)
-      ? .reported(Box(positiveFinite: box), interfaceOrientation: interfaceOrientation)
-      : .missing(reason: .invalid)
+    guard let checked = Box(checked: box) else { return .missing(reason: .invalid) }
+    return .reported(checked, interfaceOrientation: interfaceOrientation)
   }
 
   public static func derived(box: CGRect) -> SnapshotViewport {
-    SnapshotGeometry.isPositiveFinite(box)
-      ? .derived(Box(positiveFinite: box))
-      : .missing(reason: .invalid)
+    guard let checked = Box(checked: box) else { return .missing(reason: .invalid) }
+    return .derived(checked)
   }
 }
 
@@ -271,6 +276,7 @@ public struct PresentedNode: Codable, Equatable {
   public let label: String?
   public let identifier: String?
   public let value: String?
+  public let placeholder: String?
   public let rect: SnapshotRect
   public let enabled: Bool
   public let focused: Bool?
@@ -294,6 +300,7 @@ public struct PresentedNode: Codable, Equatable {
     self.label = raw.label
     self.identifier = raw.identifier
     self.value = raw.value
+    self.placeholder = raw.placeholder
     self.rect = rect ?? raw.rect
     self.enabled = raw.enabled
     self.focused = raw.focused

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

@@ -140,6 +140,7 @@ extension SnapshotPresentation {
           label: raw.label,
           identifier: raw.identifier,
           value: raw.value,
+          placeholder: raw.placeholder,
           rect: raw.rect,
           enabled: raw.enabled,
           focused: raw.focused,

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

@@ -199,21 +199,19 @@ public enum SnapshotVisibilityFold {
               label: node.label,
               identifier: node.identifier,
               value: node.value,
+              placeholder: node.placeholder,
               rect: node.rect,
               enabled: node.enabled,
               focused: node.focused,
               selected: node.selected,
               hittable: node.parentIndex == nil
                 ? false
-                : node.hittable.flatMap { sourceHittable in
-                  sourceHittable
-                    ? SnapshotGeometry.isGeometricallyActionable(
-                      enabled: node.enabled,
-                      frame: decision.effectiveFrame,
-                      viewport: viewport
-                    )
-                    : false
-                },
+                : clippedHittability(
+                  source: node.hittable,
+                  enabled: node.enabled,
+                  clippedFrame: decision.effectiveFrame,
+                  viewport: viewport
+                ),
               depth: outDepth,
               parentIndex: keptIndex,
               hiddenContentAbove: node.hiddenContentAbove,
@@ -244,4 +242,23 @@ public enum SnapshotVisibilityFold {
     return applyHiddenContentHints(hints, to: kept)
   }
 
+  /// The fold's share of the `hittable` policy (#2891). A declared `false` is kept; anything the
+  /// source left undecided is re-decided on the clipped frame: a disabled or degenerate frame —
+  /// including a `visibilityExempt` carrier a scroll anchor clipped to nothing — answers `false`,
+  /// and `nil` stays reserved for the one question the clipped frame cannot answer, containment
+  /// while the capture has no viewport box.
+  private static func clippedHittability(
+    source: Bool?,
+    enabled: Bool,
+    clippedFrame: CGRect,
+    viewport: SnapshotViewport
+  ) -> Bool? {
+    if source == false { return false }
+    return SnapshotGeometry.isGeometricallyActionable(
+      enabled: enabled,
+      frame: clippedFrame,
+      viewport: viewport
+    )
+  }
+
 }

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

@@ -79,6 +79,7 @@ extension SnapshotVisibilityFold {
           label: node.label,
           identifier: node.identifier,
           value: node.value,
+          placeholder: node.placeholder,
           rect: node.rect,
           enabled: node.enabled,
           focused: node.focused,