@@ -155,7 +155,14 @@ extension RunnerTests {
         )
         let textInput: XCUIElement?
         if !xCTestTextInputProbeSkipped {
-          textInput = coordinateTapTextInputAt(app: activeApp, x: x, y: y)
+          // The lookup compares the point, which is a screen point, with candidate frames; on a
+          // placed window the snapshot frames need the content vector (#3899).
+          textInput = coordinateTapTextInputAt(
+            app: activeApp,
+            x: x,
+            y: y,
+            contentTranslation: liveContentTranslation(app: activeApp)
+          )
         } else {
           textInput = nil
           // Clear before dispatch so a throwing gesture cannot retain the preceding field's witness.
 
@@ -352,7 +352,13 @@ extension RunnerTests {
 
   func readTextAt(app: XCUIApplication, x: Double, y: Double) -> String? {
     let point = CGPoint(x: x, y: y)
-    let textInputCandidates = textInputCandidatesAt(app: app, point: point).map(\.element)
+    // The point is a screen point; candidate snapshot frames of a placed window need the content
+    // vector to be compared with it (#3899).
+    let textInputCandidates = textInputCandidatesAt(
+      app: app,
+      point: point,
+      contentTranslation: liveContentTranslation(app: app)
+    ).map(\.element)
     for element in textInputCandidates where prefersExpandedTextRead(element) {
       if let text = readableText(for: element) {
         return text
@@ -617,12 +623,15 @@ extension RunnerTests {
 #if !os(tvOS)
   private func interactionCoordinate(app: XCUIApplication, x: Double, y: Double) -> XCUICoordinate {
 #if os(iOS)
-    // Coordinate taps, double taps, long presses, and drags anchor at the app origin, not the
-    // resolved window: on iOS the snapshot hands back app-space points, and the first qualifying
-    // window is not always the one under the finger — a SpringBoard `alert accept` can live in an
-    // alert window while the wallpaper or status-bar window qualifies first, so a window-relative
-    // anchor misses the button. Reference frames and the synthesized display ID still resolve
-    // through `resolveRunnerWindow`, so a foldable tap keeps its panel and stays on its display.
+    // A caller's point is a screen point: coordinate taps, double taps, long presses, and drags
+    // anchor at the application's origin, not the resolved window, so the point is dispatched as
+    // given. That holds because `app.coordinate(withNormalizedOffset: .zero)` sits at the origin of
+    // the space `app.frame` names, and for a windowed app the measured `app.frame` starts at the
+    // screen's origin. The first qualifying window is not always the one under the finger — a
+    // SpringBoard `alert accept` can live in an alert window while the wallpaper or status-bar
+    // window qualifies first, so a window-relative anchor misses the button. Reference frames and
+    // the synthesized display ID still resolve through `resolveRunnerWindow`, so a foldable tap
+    // keeps its panel and stays on its display (#3899, ADR 0025).
     let origin = app.coordinate(withNormalizedOffset: CGVector(dx: 0, dy: 0))
     return origin.withOffset(CGVector(dx: x, dy: y))
 #else
 
@@ -149,6 +149,11 @@ extension RunnerTests {
     let element: XCUIElement?
     let refreshPoint: CGPoint?
     let prefersFocusedElement: Bool
+    /// The live snapshot-frame vector for the reading session, read once when this target was built
+    /// (#3899). Every snapshot frame the target's reads produce is compared with screen points, so
+    /// every such read carries this vector (`ResolvedTextEntryInput.frameOnScreen`). Nil on a device
+    /// whose app fills the screen, where a snapshot frame is already a screen frame.
+    let contentTranslation: CGSize?
     let fromTapWitness: Bool
     /// The input the first resolved element was. Once bound, resolution refuses any other input.
     let boundIdentity: TextEntryInputIdentity?
@@ -166,6 +171,7 @@ extension RunnerTests {
       element: XCUIElement?,
       refreshPoint: CGPoint?,
       prefersFocusedElement: Bool,
+      contentTranslation: CGSize? = nil,
       fromTapWitness: Bool = false,
       boundIdentity: TextEntryInputIdentity? = nil,
       inputAtRefreshPoint: TextInputAtPoint? = nil,
@@ -174,30 +180,34 @@ extension RunnerTests {
       self.element = element
       self.refreshPoint = refreshPoint
       self.prefersFocusedElement = prefersFocusedElement
+      self.contentTranslation = contentTranslation
       self.fromTapWitness = fromTapWitness
       self.boundIdentity = boundIdentity ?? inputAtRefreshPoint?.identity
       self.inputAtRefreshPoint = inputAtRefreshPoint
       self.postFocusRead = postFocusRead
     }
 
-    /// The target moved to the input a resolution read: its element, a refresh point at its center,
-    /// and its identity while the target is unbound.
-    ///
-    /// `translation` is the live snapshot-frame vector for the reading session (#3899): the snapshot
-    /// frame of a placed window's input names the window's content space, while a refresh point is
-    /// compared against screen-space probes, so the center enters the target translated.
-    func withResolvedInput(
-      _ input: ResolvedTextEntryInput?,
-      translation: CGSize?
-    ) -> TextEntryTarget {
+    /// The target moved to the input a resolution read: its element and identity, and — when the
+    /// read carries a snapshot — a refresh point at that frame's center on the screen (`frameOnScreen`
+    /// plus this target's content vector, #3899). A read with no snapshot keeps the old refresh
+    /// point: its center would come from the live `element.frame`, the read a post-focus handle
+    /// cannot answer without recording a failure (#3060).
+    func withResolvedInput(_ input: ResolvedTextEntryInput?) -> TextEntryTarget {
       guard let input else {
         return self
       }
-      let frame = snapshotFrameOnScreen(input.snapshot?.frame ?? .zero, translation: translation)
+      let nextRefreshPoint: CGPoint?
+      if let snapshot = input.snapshot {
+        let frame = input.frameOnScreen
+        nextRefreshPoint = frame.isEmpty ? refreshPoint : CGPoint(x: frame.midX, y: frame.midY)
+      } else {
+        nextRefreshPoint = refreshPoint
+      }
       return TextEntryTarget(
         element: input.element,
-        refreshPoint: frame.isEmpty ? refreshPoint : CGPoint(x: frame.midX, y: frame.midY),
+        refreshPoint: nextRefreshPoint,
         prefersFocusedElement: prefersFocusedElement,
+        contentTranslation: contentTranslation,
         fromTapWitness: fromTapWitness,
         boundIdentity: boundIdentity ?? input.identity,
         inputAtRefreshPoint: inputAtRefreshPoint
@@ -211,20 +221,31 @@ extension RunnerTests {
   /// Pro, iOS 27.0). Where a live read of an element that stopped answering its query, such as a
   /// removed input or a focused Flutter password field (#3060), records an XCTest failure that ends
   /// the runner session, the snapshot only throws.
+  ///
+  /// This type owns the probe-side space of #3899 (ADR 0004). `XCUIElementSnapshot.frame` reports a
+  /// placed window's content in the window's own space, while every point this read feeds — a refresh
+  /// point, a focus tap, a probe match, a readiness retap — is a screen point. So the read carries
+  /// the content vector it was taken under, and `frameOnScreen` is the only frame consumers use: a
+  /// snapshot frame plus the vector, or the live frame when there is no snapshot. Raw frames
+  /// (`snapshot.frame`) are compared only with each other.
   struct ResolvedTextEntryInput {
     let element: XCUIElement
     /// Nil when the element exists but could not be snapshotted.
     let snapshot: XCUIElementSnapshot?
+    /// The live snapshot-frame vector read once for the command that made this read (#3899). Nil
+    /// when the app fills the screen, where a snapshot frame is already a screen frame.
+    let contentTranslation: CGSize?
 
-    private init(element: XCUIElement, snapshot: XCUIElementSnapshot?) {
+    private init(element: XCUIElement, snapshot: XCUIElementSnapshot?, contentTranslation: CGSize?) {
       self.element = element
       self.snapshot = snapshot
+      self.contentTranslation = contentTranslation
     }
 
     /// Reads a handle that may name an input the app has removed; nil when it names none or the read
     /// raised. The snapshot of a missing element throws only after XCTest waits about two seconds for
     /// a match, so existence is read first.
-    init?(reading element: XCUIElement) {
+    init?(reading element: XCUIElement, contentTranslation: CGSize? = nil) {
       var exists = false
       var snapshot: XCUIElementSnapshot?
       if let exception = RunnerObjCExceptionCatcher.catchException({
@@ -235,15 +256,15 @@ extension RunnerTests {
         return nil
       }
       guard exists else { return nil }
-      self.init(element: element, snapshot: snapshot)
+      self.init(element: element, snapshot: snapshot, contentTranslation: contentTranslation)
     }
 
     /// Reads a handle its query has just listed, inside the caller's exception containment, so the
     /// snapshot is read first and existence only when the snapshot fails; nil when it names no element.
-    init?(readingListed element: XCUIElement) {
+    init?(readingListed element: XCUIElement, contentTranslation: CGSize? = nil) {
       let snapshot = try? element.snapshot()
       guard snapshot != nil || element.exists else { return nil }
-      self.init(element: element, snapshot: snapshot)
+      self.init(element: element, snapshot: snapshot, contentTranslation: contentTranslation)
     }
 
     var identity: TextEntryInputIdentity? {
@@ -256,25 +277,37 @@ extension RunnerTests {
       }
       return element
     }
+
+    /// The input's box in screen space: the snapshot frame carried by `contentTranslation` to its
+    /// place on the screen, or the live frame when there is no snapshot — the live
+    /// `XCUIElement.frame` already reports a placed window's content in screen space (#3899).
+    var frameOnScreen: CGRect {
+      guard let snapshot else {
+        return element.frame
+      }
+      guard let contentTranslation else {
+        return snapshot.frame
+      }
+      return snapshot.frame.offsetBy(dx: contentTranslation.width, dy: contentTranslation.height)
+    }
   }
 
   /// A text entry target and its input as last read. `input()` hands the last read out again until
   /// `dispatch` runs, and resolves the target again after that, so a bound target refuses an input
   /// that took its place. Each resolution moves the target to the input it read. Every post and every
   /// pause between reads goes through `dispatch`; the pause a typing plan takes itself follows a post.
+  /// The reader hands the target's content vector to every read it resolves, so one vector rules the
+  /// command (#3899).
   struct TextEntryReader {
     private(set) var target: TextEntryTarget
     private var lastRead: ResolvedTextEntryInput?
     private let resolve: (TextEntryTarget) -> ResolvedTextEntryInput?
-    private let translation: CGSize?
 
     init(
       target: TextEntryTarget,
-      translation: CGSize?,
       resolve: @escaping (TextEntryTarget) -> ResolvedTextEntryInput?
     ) {
-      self.translation = translation
-      self.target = target.withResolvedInput(target.postFocusRead, translation: translation)
+      self.target = target.withResolvedInput(target.postFocusRead)
       lastRead = target.postFocusRead
       self.resolve = resolve
     }
@@ -284,7 +317,7 @@ extension RunnerTests {
         return lastRead
       }
       let read = resolve(target)
-      target = target.withResolvedInput(read, translation: translation)
+      target = target.withResolvedInput(read)
       lastRead = read
       return read
     }
@@ -507,7 +540,10 @@ extension RunnerTests {
       return resolveUnboundTextEntryInput(app: app, target: target)
     }
     func boundInput(_ candidate: XCUIElement) -> ResolvedTextEntryInput? {
-      guard let input = ResolvedTextEntryInput(reading: candidate), input.identity == boundIdentity else { return nil }
+      guard let input = ResolvedTextEntryInput(
+        reading: candidate,
+        contentTranslation: target.contentTranslation
+      ), input.identity == boundIdentity else { return nil }
       return input
     }
     if target.prefersFocusedElement, let focused = focusedTextInput(app: app), let input = boundInput(focused) {
@@ -516,12 +552,17 @@ extension RunnerTests {
     if let element = target.element, let input = boundInput(element) {
       return input
     }
-    if let input = target.inputAtRefreshPoint, let read = textInputIfStillResolves(input) {
+    if let input = target.inputAtRefreshPoint,
+       let read = textInputIfStillResolves(input, contentTranslation: target.contentTranslation) {
       return read
     }
     if target.inputAtRefreshPoint == nil,
        let refreshPoint = target.refreshPoint,
-       case .matches(let candidates) = probeTextInputs(app: app, point: refreshPoint),
+       case .matches(let candidates) = probeTextInputs(
+         app: app,
+         point: refreshPoint,
+         contentTranslation: target.contentTranslation
+       ),
        let match = candidates.first(where: { $0.identity == boundIdentity }) {
       return match
     }
@@ -556,7 +597,11 @@ extension RunnerTests {
     guard let refreshPoint = target.refreshPoint else {
       return true
     }
-    switch probeTextInputs(app: app, point: refreshPoint) {
+    switch probeTextInputs(
+      app: app,
+      point: refreshPoint,
+      contentTranslation: target.contentTranslation
+    ) {
     case .absent:
       return true
     case .matches(let candidates):
@@ -590,17 +635,25 @@ extension RunnerTests {
 
   /// Resolution for a target not bound to an input yet: the first element that exists.
   private func resolveUnboundTextEntryInput(app: XCUIApplication, target: TextEntryTarget) -> ResolvedTextEntryInput? {
-    if target.prefersFocusedElement, let focused = focusedTextInput(app: app).flatMap(ResolvedTextEntryInput.init(reading:)) {
+    let translation = target.contentTranslation
+    if target.prefersFocusedElement,
+       let focused = focusedTextInput(app: app).flatMap({ ResolvedTextEntryInput(reading: $0, contentTranslation: translation) }) {
       return focused
     }
-    if let element = target.element, let input = ResolvedTextEntryInput(reading: element) {
+    if let element = target.element,
+       let input = ResolvedTextEntryInput(reading: element, contentTranslation: translation) {
       return input
     }
     if let refreshPoint = target.refreshPoint,
-       let refreshed = textInputAt(app: app, x: refreshPoint.x, y: refreshPoint.y) {
+       let refreshed = textInputAt(
+         app: app,
+         x: refreshPoint.x,
+         y: refreshPoint.y,
+         contentTranslation: translation
+       ) {
       return refreshed
     }
-    return focusedTextInput(app: app).flatMap(ResolvedTextEntryInput.init(reading:))
+    return focusedTextInput(app: app).flatMap { ResolvedTextEntryInput(reading: $0, contentTranslation: translation) }
   }
 
   private func moveCaretToEnd(app: XCUIApplication, input: ResolvedTextEntryInput) {
@@ -619,12 +672,14 @@ extension RunnerTests {
     // zero-size one (how a departed handle reads), there is no point to dispatch — an edge-tap
     // from a frame the field moved after records a failure or navigates away, the shape
     // `clearTextInput`'s comment refuses — so degrade to the caller's point-free delete burst.
-    // The snapshot frame names the window's own content space on a placed window, so it enters
-    // `tapAt` translated (#3899).
-    guard let read = input.snapshot?.frame, !read.isEmpty else {
+    // The read's snapshot frame names the window's own content space on a placed window, so the
+    // point enters `tapAt` through `frameOnScreen`, which carries the read's content vector (#3899).
+    // A read with no snapshot gets no point at all: `frameOnScreen`'s fallback is the live
+    // `element.frame` read this function exists to avoid.
+    guard input.snapshot?.frame.isEmpty == false else {
       return
     }
-    let frame = snapshotFrameOnScreen(read, translation: liveContentTranslation(app: app))
+    let frame = input.frameOnScreen
     _ = tapAt(
       app: app,
       x: frame.minX + max(2, frame.width - 4),