agent-device 0.21.0 → 0.21.2

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

@@ -65,14 +65,14 @@ extension RunnerTests {
       case failed(SnapshotCaptureFailure, phase: SnapshotCapturePhase)
     }
 
-    /// The failure phase is part of the result, so penalty policy cannot infer it from duration
-    /// or error text.
+
+
     let outcome: Outcome
     let timing: SnapshotCaptureTiming
   }
 
-  /// The penalty breaker observes only acquisition facts. Presentation is a separate phase and
-  /// cannot arm the breaker, even when it is slower than the acquisition that produced the tree.
+
+
   private static func snapshotXCTestPenaltyReason(
     kind: SnapshotBackendKind,
     attempt: SnapshotBackendAttempt,
@@ -108,3 +108,78 @@ extension RunnerTests {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -1,36 +1,36 @@
 import XCTest
 
-// The synthesized text-entry commit wait, end to end: the deadline that bounds it, the two waits
-// that run it, the observation/pacing they poll through, and the value-free cadence line that path
-// is allowed to log. Split from RunnerTests+SynthesizedTextEntry.swift, which keeps the
-// private-XCTest synthesis boundary and the route policies; the pure outcome functions these wrap
-// stay there next to the rules they encode. Everything that touches the polled field value now
-// lives in this one file, which is the surface apple-runner-log-redaction.test.ts guards.
+
+
+
+
+
+
 extension RunnerTests {
-  /// One commit wait's running deadline.
-  ///
-  /// A synthesized burst can be *throttled* rather than dropped: on a loaded simulator the
-  /// characters keep landing, just slowly, and everything touching the input system slows with
-  /// them (#1874). A flat wall-clock budget cannot tell that apart from a wedged pipeline, so it
-  /// condemned both at the same instant — and the throttled case is a working command reported as
-  /// `TEXT_INPUT_COMMIT_NOT_OBSERVED`, which is what turned an environment episode into a red
-  /// lane on branches touching no iOS code.
-  ///
-  /// So time is granted against *progress* — the observed value's expected-prefix growing, the
-  /// same length-only evidence `logCommitCadence` already emits — with an absolute `ceiling`, so a
-  /// pipeline delivering one character per stall window cannot hold a command open forever. A
-  /// pipeline making no progress at all still expires at exactly the `stallBudget` the flat
-  /// deadline used, so nothing that fails today starts passing merely by waiting longer.
-  ///
-  /// Started by the poll loop from its own first `now()`, and held as a local `var` there. The
-  /// wait's setup reads the field's placeholder first, an AX round-trip that takes seconds on
-  /// exactly the loaded host this exists for; charging that to the deadline made the wait give up
-  /// sooner than the flat budget it replaced.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   struct SynthesizedCommitDeadline {
     private let startedAt: Date
     private let stallBudget: TimeInterval
     private let ceiling: TimeInterval
-    // Nothing has landed yet, and an observation of "still nothing" must not read as progress.
+
     private var bestPrefixLength = 0
     private var lastProgressAt: Date
 
@@ -41,10 +41,10 @@ extension RunnerTests {
       self.lastProgressAt = startedAt
     }
 
-    /// Records one observation's expected-prefix length. Only forward movement counts: a shorter
-    /// read — the app clearing the field mid-flight, or a value that could not be read at all,
-    /// which measures as 0 — is not evidence the burst is still landing, so it neither buys time
-    /// nor takes any back.
+
+
+
+
     mutating func record(expectedPrefixLength: Int, at now: Date) {
       guard expectedPrefixLength > bestPrefixLength else { return }
       bestPrefixLength = expectedPrefixLength
@@ -57,16 +57,16 @@ extension RunnerTests {
     }
   }
 
-  /// Blocks until the synthesized bare-type text is observable in the target field, so `type`
-  /// cannot report ok while trailing characters are still uncommitted on a slow simulator.
-  ///
-  /// Observation only. A stalled prefix cannot be told apart from a suffix still queued in the
-  /// event stream, so re-synthesizing the difference risks committing it twice after the command
-  /// already reported success (#1676 rejected exactly that repair). Reporting `.notObserved` is
-  /// what the caller does instead: the partial value is the agent's to resolve, and a named
-  /// failure beats a success that misdescribes the field. Text carrying a submit key is skipped
-  /// outright: the app may clear or rewrite the field on submit, so `textBefore + typedText` is
-  /// not the value to wait for.
+
+
+
+
+
+
+
+
+
+
   func awaitSynthesizedFirstResponderCommit(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -95,16 +95,16 @@ extension RunnerTests {
     return outcome
   }
 
-  /// Blocks until the synthesized replacement text (`fill`) is observable in the target field, so
-  /// `fill` cannot report ok while the select-all-and-retype it posted is still uncommitted — or
-  /// silently wrong — on a slow or channel-penalized simulator (this route runs only when the
-  /// XCTest channel is already penalized, and never resolves an `XCUIElement`, so it previously had
-  /// no verification at all).
-  ///
-  /// Unlike the append route, the expected value is the final text itself — replacement mode
-  /// clears the field first, so there is no `textBefore` prefix to account for — and unlike the
-  /// append route, a settled mismatch is always reported rather than trusted: see
-  /// `awaitSynthesizedReplacementCommitOutcome`'s doc comment.
+
+
+
+
+
+
+
+
+
+
   func awaitSynthesizedReplacementCommit(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -131,9 +131,9 @@ extension RunnerTests {
     return outcome
   }
 
-  /// The emitted cadence line, as a pure function so its output is assertable. Only lengths and
-  /// a timestamp are representable here; there is no String parameter, so observed field
-  /// contents cannot reach runner.log through this boundary whatever they contain.
+
+
+
   static func commitCadenceLogLine(
     elapsedMs: Int,
     observedLen: Int,
@@ -142,9 +142,9 @@ extension RunnerTests {
     "[DEBUG-1874] poll t=\(elapsedMs)ms observedLen=\(observedLen) expectedPrefixLen=\(expectedPrefixLen)"
   }
 
-  /// The typed boundary for commit-wait cadence evidence. The poll path must log through this
-  /// function and never through a raw NSLog: every parameter is an Int, so the polled value's
-  /// contents are unrepresentable at the call site.
+
+
+
   static func logCommitCadence(
     elapsedMs: Int,
     observedLen: Int,
@@ -160,16 +160,16 @@ extension RunnerTests {
     )
   }
 
-  /// The placeholder/observe/pacing ingredients shared by the append route
-  /// (`awaitSynthesizedFirstResponderCommit`) and the replacement route
-  /// (`awaitSynthesizedReplacementCommit`). What must NOT be shared is which outcome function
-  /// consumes them: see `awaitSynthesizedReplacementCommitOutcome`'s doc comment for why append
-  /// mode's "trust a diverged value" rule is wrong for replacement mode. Each caller therefore
-  /// calls its own named outcome function directly, with real argument labels — deliberately not
-  /// a stored closure/function-value parameter here, which would erase those labels at the call
-  /// site and make the observe closure unrecognizable to the static content-redaction check in
-  /// `apple-runner-log-redaction.test.ts` (`extractObserveClosure` locates the labeled closure
-  /// literal by its text; a closure passed as a plain function value carries no such label).
+
+
+
+
+
+
+
+
+
+
   private func synthesizedCommitPollingIngredients(
     app: XCUIApplication,
     target: TextEntryTarget,
@@ -188,9 +188,9 @@ extension RunnerTests {
           for: self.resolveTextEntryElement(app: app, target: target),
           treatingPlaceholderAsEmpty: true
         )
-        // Cadence evidence stays value-free: the polled value is user content typed through
-        // `type`/`fill` and must never reach runner.log. Lengths and the expected-prefix walk
-        // are enough to distinguish throttling (prefix grows slowly) from a wedge (it freezes).
+
+
+
         Self.logCommitCadence(
           elapsedMs: Int(waitStartedAt.timeIntervalSinceNow * -1000),
           observedLen: observedText?.count ?? -1,
@@ -198,8 +198,8 @@ extension RunnerTests {
         )
         return observedText
       },
-      // XCUI resolution shares the automation channel with the in-flight synthesized event.
-      // Sparse reads let the target consume that event instead of continuously interrupting it.
+
+
       waitForNextObservation: { self.sleepFor(TextEntryTiming.synthesizedCommitPollInterval) }
     )
   }

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

@@ -1,10 +1,10 @@
 import XCTest
 
-// Runner-local policy for AX-free/private synthesized iOS gestures.
-//
-// This policy is intentionally separate from the TS interaction guarantee matrix:
-// ADR 0011 models element-targeting guarantees, while this module models command
-// paths that must keep scroll/drag/sequence usable when XCTest AX is unhealthy.
+
+
+
+
+
 
 enum RunnerAccessibilityHealth: String, Equatable {
   case unknown
@@ -89,8 +89,14 @@ func synthesizedGesturePolicy(_ kind: SynthesizedGesturePolicyKind) -> Synthesiz
       fallbackPolicy: .xctestCoordinateAllowed
     )
   case .scroll:
+
+
+
+
+
+
     return SynthesizedGesturePolicy(
-      keyboardPolicy: .whenAccessibilityHealthy,
+      keyboardPolicy: .requiredWhenAvailable,
       fallbackPolicy: .privateSynthesisRequired
     )
   case .synthesizedDrag:
@@ -150,3 +156,83 @@ extension RunnerTests {
   }
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -1,7 +1,7 @@
 import XCTest
 
-// AX-independent text synthesis: private-XCTest boundary, pacing plan, and route policy.
-// The verified XCUIElement path remains in TextEntry/TextTyping.
+
+
 extension RunnerTests {
   enum SynthesizedReplacementRouteOutcome {
     case notApplicable
@@ -127,12 +127,12 @@ extension RunnerTests {
         sleepFor(request.delaySeconds)
       }
     }
-    // The private synthesize call returns at post time, not commit time (same as bare `type`,
-    // see awaitSynthesizedFirstResponderCommit) — but this route never resolves an XCUIElement,
-    // so without this wait it had no way to notice a dropped or still-in-flight character at all
-    // and reported ok purely because the event posted. Wait here, on the same request.target
-    // (element nil, refreshPoint set) that gated this route, so each poll re-resolves via the
-    // refresh point rather than trusting a stale element handle.
+
+
+
+
+
+
     let commit = awaitSynthesizedReplacementCommit(
       app: request.app,
       target: request.target,
@@ -182,12 +182,12 @@ extension RunnerTests {
     case diverged
   }
 
-  // The private synthesize call returns once the event record is posted, not once the target
-  // app has committed the characters, so intermediate reads walk prefix-by-prefix toward the
-  // expected value. Anything off that prefix path means the app transformed the input
-  // (formatter, mid-text caret, autocomplete) and the runner must not second-guess it. An
-  // unreadable value — secure field, or the element stopped resolving — ends the wait the
-  // same way.
+
+
+
+
+
+
   static func synthesizedTextCommitProgress(
     observedText: String?,
     expectedText: String
@@ -201,9 +201,9 @@ extension RunnerTests {
     return expectedText.hasPrefix(observedText) ? .pending : .diverged
   }
 
-  /// Length of the shared prefix of two strings. Feeds value-free commit-wait logging: the
-  /// expected-prefix walk over time distinguishes throttled delivery (grows slowly) from a
-  /// wedged pipeline (freezes) without ever logging the field's contents.
+
+
+
   static func commonPrefixLength(_ lhs: String, _ rhs: String) -> Int {
     var length = 0
     for (l, r) in zip(lhs, rhs) {
@@ -213,32 +213,32 @@ extension RunnerTests {
     return length
   }
 
-  /// How the commit wait ended. Distinct from `SynthesizedTextCommitProgress`, which classifies a
-  /// single observation: this is the whole wait's verdict, and it exists so the deadline can be
-  /// told apart from success. The wait used to return `Void`, which made an expired deadline
-  /// indistinguishable from a committed one — `type` then reported ok with a partial value in the
-  /// field (#1874, #1844).
+
+
+
+
+
   enum SynthesizedTextCommitOutcome: Equatable {
-    /// The wait's success case, but its meaning is route-specific: for append mode (bare `type`),
-    /// the expected text committed OR the app transformed the input in a way the runner must not
-    /// second-guess; for replacement mode (`fill`), it means only an exact match — see
-    /// `awaitSynthesizedReplacementCommitOutcome`'s doc comment for why replacement mode has no
-    /// "trust it" case.
+
+
+
+
+
     case settled
-    /// There was nothing to wait for — no readable baseline, or the text carries a submit key.
+
     case unobservable
-    /// The deadline expired with the expected text still not observed.
+
     case notObserved
   }
 
-  /// The commit wait's decision, with observation, pacing and the clock injected so both deadline
-  /// branches are exercisable without a simulator (the macOS host lane runs this; the member
-  /// wrapper below binds the real XCUI reads).
-  ///
-  /// The deadline is a local `var`, started from this loop's own first `now()` and advanced from
-  /// the same observation the progress check reads, so "did the burst move" and "is time up" are
-  /// two statements in one loop. The budget defaults to the shipped one, so only a test that is
-  /// asking about time has to name it.
+
+
+
+
+
+
+
+
   static func awaitSynthesizedCommitOutcome(
     expectedText: String,
     placeholder: String?,
@@ -248,24 +248,24 @@ extension RunnerTests {
     observe: () -> String?,
     waitForNextObservation: () -> Void
   ) -> SynthesizedTextCommitOutcome {
-    // A placeholder-equal AX value cannot prove a commit: an input handler may clear even a
-    // previously non-empty field after dispatch, making the empty field render the same value.
-    // Refuse before polling because no later read can distinguish those states.
+
+
+
     if Self.textMatchesPlaceholder(expectedText, placeholder: placeholder) {
       return .notObserved
     }
     var deadline = SynthesizedCommitDeadline(startedAt: now(), stallBudget: stallBudget, ceiling: ceiling)
-    // The deadline is checked AFTER an observation, never before one, so the last thing that
-    // happens before condemning a commit is a read. Checking first would condemn a commit that
-    // landed during the final poll sleep — the exact loaded-host timing this wait exists for.
+
+
+
     while true {
       let observedText = observe()
       switch synthesizedTextCommitProgress(observedText: observedText, expectedText: expectedText) {
       case .committed, .diverged:
         return .settled
       case .pending:
-        // One clock sample, so the instant an observation is recorded at is the instant it is
-        // judged against.
+
+
         let sampledAt = now()
         deadline.record(
           expectedPrefixLength: Self.commonPrefixLength(observedText ?? "", expectedText),
@@ -277,9 +277,9 @@ extension RunnerTests {
     }
   }
 
-  /// The command-level consequence of a commit wait. `.unobservable` is not a failure: there was
-  /// no baseline to compare against, which is the pre-existing contract for submit-key text and
-  /// unreadable fields, not evidence that anything went wrong.
+
+
+
   static func textEntryFailure(
     forCommitOutcome outcome: SynthesizedTextCommitOutcome
   ) -> TextEntryFailure? {
@@ -291,22 +291,22 @@ extension RunnerTests {
     }
   }
 
-  /// The replacement-mode counterpart of `awaitSynthesizedCommitOutcome`. It must NOT reuse that
-  /// function's `synthesizedTextCommitProgress`: prefix-walk's `.diverged` case exists to trust an
-  /// app that transforms bare-`type` input (formatter, autocomplete) rather than second-guess it —
-  /// but that same rule silently accepts a dropped-character corruption too, because a value with a
-  /// hole in the middle ("ada@example" -> "aexample") is neither a matching prefix NOR the full
-  /// string, yet still gets classified `.diverged` -> `.settled` -> reported `ok: true`. This is not
-  /// a hypothetical: it is the exact shape of the corruption this wait exists to catch (`fill`
-  /// reporting success over "Avelace"/"aexample"-style drops), verified against both live examples
-  /// before writing this comment.
-  ///
-  /// `.replacement` mode does not need prefix tolerance for legitimate transforms either:
-  /// `isRepairableTextEntryMismatch` (RunnerTests+TextTyping.swift) already treats every mismatch in
-  /// `.replacement` mode as repairable unconditionally, with no formatter/autocomplete carve-out —
-  /// `fill` fully owns the field via select-all, so there is no legitimate reason for the settled
-  /// value to be anything other than exactly what was requested. A settled non-match is therefore
-  /// always the wait's failure case, never a `.settled` pass-through.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   static func awaitSynthesizedReplacementCommitOutcome(
     expectedText: String,
     placeholder: String?,
@@ -325,9 +325,9 @@ extension RunnerTests {
       if observedText == expectedText {
         return .settled
       }
-      // Prefix growth cannot settle this wait — a value with a hole in the middle is still a
-      // failure, see the doc comment above — but it is the same evidence that the burst is still
-      // landing, so it buys the same time here as it does in append mode.
+
+
+
       let sampledAt = now()
       deadline.record(
         expectedPrefixLength: Self.commonPrefixLength(observedText ?? "", expectedText),

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

@@ -2,7 +2,7 @@ import XCTest
 import AgentDeviceSnapshotPresentation
 
 extension RunnerTests {
-  // MARK: - Blocking System Modal Snapshot
+
 
   func blockingSystemAlertSnapshot(deadline: Date = .distantFuture) -> DataPayload? {
     #if os(macOS)
@@ -42,8 +42,8 @@ extension RunnerTests {
       nodes.append(actionNode)
     }
 
-    // Action controls are the interaction contract. Informative text is useful context, but
-    // must not make a usable modal miss the bounded system-modal probe deadline.
+
+
     let contentDeadline = deadline.addingTimeInterval(-0.5)
     for content in informativeElements(in: modal, deadline: contentDeadline) {
       guard Date() < contentDeadline,
@@ -86,7 +86,7 @@ extension RunnerTests {
       }
     }
 
-    // Don't start the second (sheet) enumeration once the shared probe deadline is spent (#1244).
+
     if Date() >= deadline {
       NSLog("AGENT_DEVICE_RUNNER_SYSTEM_MODAL_PROBE_DEADLINE stage=sheets")
       return nil