Skip to content

Commit 903b0f4

Browse files
authored
fix(apple-runner): serve a macOS read of a background app without raising it (#3339)
* fix(apple-runner): serve a macOS read of a background app without raising it On a desktop, the XCTest foreground repair is not a no-op for the user: a read that names a session app sitting behind other windows took their frontmost app away for a command that only asked to look (#3254). The activation axis already routes by `launchPolicy`, so the fix goes on the existing `.existingApp` arm of `prepareActiveCommandContext`: on macOS, a read whose app answers `.runningBackground` is served in place through `resolveAppWithoutActivation`, and no activation fact is booked for it. Scoping is exact: - a stopped app keeps the launch the activating route performs for it today: `state` answers `.notRunning` and the arm declines, so `open`-then-read still works and no macOS refusal is invented (`notRunningRefusal` stays iOS-only); - interactions keep activating: the macOS XCTest path drives events through the foreground window, and a background click would land on whatever window is on top; - a window-level screenshot keeps its raise (measured: a backgrounded `screenshotRoot(app:).screenshot()` returns the occluding window's content inside the session window's rect), but a `--fullscreen` capture of a running app no longer raises — `XCUIScreen.main` answers from any foreground, and the 0.5 s settle waits belong to the raise and are skipped with it. A stopped app keeps launching either way. The two conditions are functions the call sites read (`macReadMayBeServedInBackground`, `macAppCaptureNeedsRaise`) so the host lane pins every state they branch on. Four host-lane tests: the background read served without a raise or a fact across its three shapes, the interaction on the same app still activating, a stopped read still launching, and the raise-condition table. The canary is the arm's removal: the read test goes red with the app left foreground and a `bundle_changed` fact booked. A live run on the default backend confirms it: with Finder frontmost, `snapshot` and `get` answered from the background app, Finder stayed frontmost, and runner.log booked zero activation facts; the click after them activated with priorState=3 as it must. `help macos` states the new read behavior. Also records at the `.presentedSurface` arm why its macOS route is unreachable from the host (`alert` answers through the helper; `action-button` is refused by its owner fact before dispatch), so no second activation axis is proposed against it. Partial #3254 * test(apple-runner): own the background-serve state split and its silence Turns two accidents into rules, both asked for in coordinator review of #3339: - `macReadMayBeServedInBackground` splits its state probe from the `state` call so the host lane can pin every state the answer branches on. The pin records why only `.runningBackground` is served in place: on the macOS SDK the suspended case does not exist (the split is pinned by RunnerTests+ApplicationStateRawValueTests), and every other state keeps the activating route so an app that cannot promise an answerable tree pays the repair rather than trading a focus steal for an empty read — the same set `targetNeedsActivation` uses on macOS, so read and capture cannot disagree. - The disclosure decision is made with the reviewer rather than by omission, and pinned: a background-served read books no activation fact and no substitute marker. The existing channels cannot say it honestly — the activation fact records only a repair performed, and the observation payload belongs to the iOS observe-only contract, which refuses exactly this situation. A background tree is live, not degraded (measured rect drift is time, not foreground state), and interactions still activate, so no action path consumes a background tree. `XCTAssertNil(prepared.observation)` makes the absence owned: a future disclosure must edit the assertion on purpose. No behavior change; both live-state tests and the new table pass on the host lane. * test(apple-runner): pin the capture raise condition on .unknown too The raise table claimed to pin every state `macAppCaptureNeedsRaise` branches on but omitted `.unknown`, while the read table in the same test pinned it — the state worth pinning on one side could not be unpinnable on the other. The rows convert the silent drift path into a red row: `.unknown` raises for a window-level capture, where the activation is the standing route's attempt to settle an app whose state the SDK cannot report, and stays false for `--fullscreen`, whose pixels answer from any foreground. Expectations verified against the implemented condition, not pasted. No behavior change. Partial #3254 * fix(apple-runner): refresh a served macOS read against a relaunched pid A read served in place resolved through `resolveAppWithoutActivation`, which returns the cached handle when the cache names the app — and a cached handle can record a pid an outside relaunch replaced. The activating route never answers from that residue because it runs `refreshCachedTargetIfProcessChanged` before its `targetNeedsActivation` read; the new arm bypassed the shared identity rule, so between an outside relaunch and the next read, a served read could address the dead process while claiming to observe the live one. Reachability: an `open`-bound session whose app is quit and reopened by the user leaves exactly this residue, and macOS `notRunningRefusal` never intercepts it. The fix runs the shared rule on the arm before resolution, so identity is settled once and both routes read the same live pid. Pinned by a host-lane test that plants the residue (live app, bogus cached pid) and asserts the served preparation refreshes without activating; canary: deleting the refresh call fails the test with the bogus pid still in place. Also drops the probe wrapper the arm no longer needs: a served read is one `state` query, and the activating route's second read cannot reuse the first because the refresh between them may have replaced the process the first answered for. The arm's and the predicate's comments are cut to the invariant they protect, per AGENTS.md; the decision record lives in #3338. Partial #3254 * docs(apple-runner): cut review history from the background-serve comments AGENTS.md keeps decision and review narration out of implementation comments: the screenshot raise site, `macAppCaptureNeedsRaise`, and the `.existingApp` policy case each keep the one constraint they encode (region-grab pixels, the state rule, the served-read scope) and point at #3338 for the measured record. No behavior change; host-lane evidence for the pinned conditions is unchanged. Partial #3254
1 parent 8c966f3 commit 903b0f4

7 files changed

Lines changed: 286 additions & 8 deletions

File tree

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandDispatch.swift‎

Lines changed: 28 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -536,12 +536,27 @@ extension RunnerTests {
536536
#else
537537
// The platform exception, written once: `SystemSurfaceHostRegistry` registers no hosts off iOS,
538538
// so nothing is ever served in place there and such a command keeps the activation route this
539-
// axis found it on.
539+
// axis found it on. The host never sends either command here on macOS — `alert` answers through
540+
// the helper and `action-button` is refused by its owner fact before dispatch — so off iOS this
541+
// route is reached only by the tvOS and visionOS runners.
540542
return prepareActivatedTarget(command: command)
541543
#endif
542544
case .existingApp:
543545
// No request-dependent bypass here: it decides by querying the cached target's state, and a
544546
// command that may bring nothing forward has nothing for it to settle.
547+
#if os(macOS)
548+
if let bundleId = command.appBundleId?.trimmedNonEmpty,
549+
macReadMayBeServedInBackground(
550+
command: command,
551+
targetState: XCUIApplication(bundleIdentifier: bundleId).state
552+
)
553+
{
554+
// Identity first, through the shared rule: a served read must answer the process a bound
555+
// read would have read, not a pid an outside relaunch replaced.
556+
refreshCachedTargetIfProcessChanged(bundleId: bundleId)
557+
return .context(ActiveCommandContext(app: resolveAppWithoutActivation(command: command)))
558+
}
559+
#endif
545560
return prepareActivatedTarget(command: command)
546561
case .mayLaunch:
547562
if shouldSkipAppActivationPreflight(command) {
@@ -775,4 +790,16 @@ extension RunnerTests {
775790
}
776791
return XCUIApplication(bundleIdentifier: bundleId)
777792
}
793+
794+
/// A macOS `.existingApp` read is served in place only for `.runningBackground`: the one state
795+
/// whose tree answers while the app sits behind other windows. Every other state keeps the
796+
/// activating route, matching `targetNeedsActivation`'s macOS set, and serving in place books no
797+
/// activation fact or marker — the fact channel records only a repair performed, so a served
798+
/// read answers as an ordinary read (#3254; decision record in #3338).
799+
///
800+
/// The probe handle must be fresh, not cached: a cached handle can address a pid an outside
801+
/// relaunch replaced, whose `.state` would answer for the dead process.
802+
func macReadMayBeServedInBackground(command: Command, targetState: XCUIApplication.State) -> Bool {
803+
command.appBundleId?.trimmedNonEmpty != nil && targetState == .runningBackground
804+
}
778805
}

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+CommandExecution.swift‎

Lines changed: 15 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -428,18 +428,27 @@ extension RunnerTests {
428428
return Response(ok: true, data: DataPayload(text: text))
429429
case .screenshot:
430430
#if os(macOS)
431-
// macOS keeps the app-targeted capture behavior for window-level screenshots.
432-
if let bundleId = command.appBundleId, !bundleId.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
431+
// An app-targeted window-level capture is a screen-region grab: from the background the
432+
// occluding app's pixels land in the image, so the raise is what makes the pixels correct
433+
// (measured; record in #3338). `--fullscreen` reads the whole display and needs no raise.
434+
// The wait belongs to the raise: only a raised app has an activation animation to settle.
435+
let screenshotBundleId = command.appBundleId?.trimmedNonEmpty
436+
if let bundleId = screenshotBundleId {
433437
let targetApp = XCUIApplication(bundleIdentifier: bundleId)
434-
targetApp.activate()
438+
if macAppCaptureNeedsRaise(
439+
fullscreen: command.fullscreen,
440+
targetState: targetApp.state
441+
) {
442+
targetApp.activate()
443+
// Brief wait for the app transition animation to complete
444+
sleepFor(0.5)
445+
}
435446
activeApp = targetApp
436-
// Brief wait for the app transition animation to complete
437-
sleepFor(0.5)
438447
}
439448
let screenshot: XCUIScreenshot
440449
if command.fullscreen == true {
441450
screenshot = XCUIScreen.main.screenshot()
442-
} else if let bundleId = command.appBundleId, !bundleId.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
451+
} else if screenshotBundleId != nil {
443452
screenshot = screenshotRoot(app: activeApp).screenshot()
444453
} else {
445454
screenshot = XCUIScreen.main.screenshot()

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Lifecycle.swift‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -284,6 +284,14 @@ extension RunnerTests {
284284
return false
285285
}
286286

287+
/// The state rule for the macOS app-targeted capture raise: only a window-level grab of an app
288+
/// that is not already foreground raises, and a stopped app raises in both shapes because there
289+
/// the activation is the launch the capture has always performed (#3254; record in #3338).
290+
func macAppCaptureNeedsRaise(fullscreen: Bool?, targetState: XCUIApplication.State) -> Bool {
291+
guard targetState != .runningForeground else { return false }
292+
return fullscreen != true || targetState == .notRunning
293+
}
294+
287295
@MainActor
288296
func canUseFastForegroundAppGuard(
289297
activeApp: XCUIApplication,

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Models.swift‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,9 @@ enum CommandLaunchPolicy: Equatable {
6666
/// enforced on iOS only: `notRunningRefusal` is `#if os(iOS)`, the platform that can read an app's
6767
/// state without launching it. Off iOS these commands keep the activation route they had before
6868
/// this axis existed, and no refusal can occur there.
69+
/// On macOS the policy also decides the foreground question: a read of an app that is running
70+
/// behind other windows is served in place without raising it, while a stopped app keeps the
71+
/// activating route's launch (#3254; record in #3338).
6972
case existingApp
7073
/// Brings the app forward, which bare-launches it when it is not running.
7174
case mayLaunch

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/UnitTests/RunnerTests+CommandDispatchTests.swift‎

Lines changed: 169 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -690,3 +690,172 @@ extension RunnerTests {
690690
}
691691
}
692692
#endif
693+
694+
#if AGENT_DEVICE_RUNNER_UNIT_TESTS && os(macOS)
695+
extension RunnerTests {
696+
/// Part of every macOS install, never the runner or the test host, and cheap to leave terminated.
697+
/// Its windows sit over or behind the test host's own, which is exactly the desktop shape #3254
698+
/// describes: the user's frontmost app is a different app from the session app.
699+
private static let macBackgroundTargetBundleId = "com.apple.systempreferences"
700+
private static let macForegroundStealBundleId = "com.apple.finder"
701+
702+
/// Brings Settings up, then hands the foreground to Finder, and waits until Settings reports
703+
/// itself background. `activate()` on another app is how a desktop backgrounds an app without
704+
/// quitting it, so this leaves the state a read must answer — not a launchable absence.
705+
@MainActor
706+
private func startMacTargetAndLoseTheForeground() throws -> XCUIApplication {
707+
let target = XCUIApplication(bundleIdentifier: Self.macBackgroundTargetBundleId)
708+
target.launch()
709+
XCTAssertTrue(target.waitForExistence(timeout: appExistenceTimeout))
710+
_ = XCUIApplication(bundleIdentifier: Self.macForegroundStealBundleId).activate()
711+
XCTAssertTrue(
712+
target.wait(for: .runningBackground, timeout: 10),
713+
"Finder must take the foreground and the target must settle background before the read answers from it"
714+
)
715+
return target
716+
}
717+
718+
/// The #3254 fix on the policy axis: on macOS a `.existingApp` read of a session app that is
719+
/// running behind other windows is served from where it sits. Three things must be true at once:
720+
/// the command is prepared against the app it names, no activation fact is booked (the response
721+
/// therefore discloses no repair because none happened), and the app is still background when the
722+
/// read is done — the user's frontmost app never changed. Covers the user-level read and the two
723+
/// leading reads an interaction carries (gesture viewport, selector resolution), the same shapes
724+
/// the iOS surface arm pins. Deleting the macOS arm of `.existingApp` fails every row.
725+
@MainActor
726+
func testMacReadOfABackgroundAppIsServedInBackgroundWithoutActivating() throws {
727+
let target = try startMacTargetAndLoseTheForeground()
728+
let bundleId = Self.macBackgroundTargetBundleId
729+
defer {
730+
invalidateCachedTarget(reason: "unit_test_cleanup")
731+
pendingTargetActivation = nil
732+
target.terminate()
733+
}
734+
for request in [
735+
#"{"command":"snapshot","commandId":"read","appBundleId":"\#(bundleId)"}"#,
736+
#"{"command":"gestureViewport","commandId":"read","appBundleId":"\#(bundleId)"}"#,
737+
#"{"command":"querySelector","selectorKey":"label","selectorValue":"General","commandId":"read","appBundleId":"\#(bundleId)"}"#
738+
] {
739+
invalidateCachedTarget(reason: "unit_test_setup")
740+
pendingTargetActivation = nil
741+
let command = try runnerCommandFixture(request)
742+
743+
guard case .context(let prepared) = prepareActiveCommandContext(command: command) else {
744+
return XCTFail("\(request) must be served, not refused")
745+
}
746+
XCTAssertEqual(
747+
prepared.app.state,
748+
.runningBackground,
749+
"\(request) must be served against the background app it names"
750+
)
751+
XCTAssertNil(pendingTargetActivation, "\(request) may not book an activation fact")
752+
// The disclosure decision, pinned with #3254: a background-served read answers as an ordinary
753+
// read with no substitute marker (no observation payload, no fact). The tree is live, not
754+
// degraded; a future disclosure must edit this line on purpose.
755+
XCTAssertNil(prepared.observation, "\(request) must not invent an observation payload")
756+
XCTAssertEqual(
757+
target.state,
758+
.runningBackground,
759+
"\(request) may not take the user's frontmost app away"
760+
)
761+
}
762+
}
763+
764+
/// The identity rule the served read must go through (#3254 review): with the cache bound to a
765+
/// pid an outside relaunch replaced, a served read answers the process a bound read would have
766+
/// read, not the dead handle the cache holds. The bogus cached pid makes the wiring observable:
767+
/// the served preparation must leave the live pid behind, so deleting the
768+
/// `refreshCachedTargetIfProcessChanged` call from the arm leaves the bogus value and fails here.
769+
@MainActor
770+
func testMacBackgroundReadRefreshesACachedHandleFromADeadPid() throws {
771+
let target = try startMacTargetAndLoseTheForeground()
772+
let bundleId = Self.macBackgroundTargetBundleId
773+
defer {
774+
invalidateCachedTarget(reason: "unit_test_cleanup")
775+
pendingTargetActivation = nil
776+
target.terminate()
777+
}
778+
let command = try runnerCommandFixture(
779+
#"{"command":"snapshot","commandId":"read","appBundleId":"\#(bundleId)"}"#
780+
)
781+
// Plant the residue an outside relaunch leaves between two reads: the cache still names this
782+
// app and still holds a handle, but the pid it recorded is dead.
783+
mainOwned.app = target
784+
mainOwned.bundleId = bundleId
785+
mainOwned.processIdentifier = 999_999
786+
pendingTargetActivation = nil
787+
788+
guard case .context(let prepared) = prepareActiveCommandContext(command: command) else {
789+
return XCTFail("the read must be served")
790+
}
791+
XCTAssertEqual(prepared.app.state, .runningBackground, "still served in place")
792+
XCTAssertNil(pendingTargetActivation, "the refresh must not activate")
793+
XCTAssertNotEqual(
794+
mainOwned.processIdentifier,
795+
999_999,
796+
"a served read must run the shared identity refresh, not answer from a dead pid"
797+
)
798+
}
799+
800+
/// The scope limit that keeps this from being a blanket no-activate rule: an interaction against
801+
/// the same background app still comes forward through the same preparation, because on macOS the
802+
/// XCTest path drives events into the foreground window and a background click would land on
803+
/// whatever window sits on top. This is the same call with `.mayLaunch`; the two tests above and
804+
/// this one together pin the boundary the policy axis draws.
805+
@MainActor
806+
func testMacInteractionOnABackgroundAppStillActivates() throws {
807+
let target = try startMacTargetAndLoseTheForeground()
808+
defer {
809+
invalidateCachedTarget(reason: "unit_test_cleanup")
810+
pendingTargetActivation = nil
811+
target.terminate()
812+
}
813+
invalidateCachedTarget(reason: "unit_test_setup")
814+
pendingTargetActivation = nil
815+
let command = try runnerCommandFixture(
816+
#"{"command":"tap","x":10,"y":10,"commandId":"tap-bg","appBundleId":"\#(Self.macBackgroundTargetBundleId)"}"#
817+
)
818+
819+
guard case .context = prepareActiveCommandContext(command: command) else {
820+
return XCTFail("the tap must be prepared")
821+
}
822+
XCTAssertNotNil(
823+
pendingTargetActivation,
824+
"an interaction on a background app must still book its activation"
825+
)
826+
XCTAssertEqual(target.state, .runningForeground, "the tap must run against the foreground app")
827+
}
828+
829+
/// Stopped apps behave exactly as they did before this axis read macOS (#3254 correction): a read
830+
/// of a not-running session app still goes through the activating route and the launch it performs,
831+
/// because macOS has no refusal there and callers rely on `open`-then-read working. `snapshot` is
832+
/// the read whose policy the background change touched, so it is the read that proves the change is
833+
/// scoped to the running app only: the app comes up, the activation fact is booked, and nothing is
834+
/// refused. Making `macReadMayBeServedInBackground` answer `.notRunning` too would turn this
835+
/// context into a refusal and fail on the first assertion.
836+
@MainActor
837+
func testMacReadOfANotRunningAppStillLaunchesIt() throws {
838+
let target = XCUIApplication(bundleIdentifier: Self.macBackgroundTargetBundleId)
839+
target.terminate()
840+
invalidateCachedTarget(reason: "unit_test_setup")
841+
pendingTargetActivation = nil
842+
defer {
843+
invalidateCachedTarget(reason: "unit_test_cleanup")
844+
pendingTargetActivation = nil
845+
target.terminate()
846+
}
847+
let command = try runnerCommandFixture(
848+
#"{"command":"snapshot","commandId":"read","appBundleId":"\#(Self.macBackgroundTargetBundleId)"}"#
849+
)
850+
851+
guard case .context = prepareActiveCommandContext(command: command) else {
852+
return XCTFail("a read of a stopped app must keep the launch route it has always had")
853+
}
854+
XCTAssertNotEqual(target.state, .notRunning, "the stopped app must come up as it did before")
855+
XCTAssertNotNil(
856+
pendingTargetActivation,
857+
"the command that launched the app discloses the activation it paid for"
858+
)
859+
}
860+
}
861+
#endif

‎apple/runner/AgentDeviceRunner/AgentDeviceRunnerUITests/UnitTests/RunnerTests+LifecycleTests.swift‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -117,6 +117,67 @@ extension RunnerTests {
117117
}
118118
#endif
119119

120+
#if AGENT_DEVICE_RUNNER_UNIT_TESTS && os(macOS)
121+
extension RunnerTests {
122+
/// Pins every state the macOS screenshot raise condition reads (#3254), together with the read
123+
/// arm's answer for the same state, so one table owns the pair. Both predicates run their real
124+
/// bodies: a drifted condition on either side lands as a red row rather than a silent behavior
125+
/// change. The rows encode the two platform facts the split rests on: the macOS SDK declares no
126+
/// suspended state (see `RunnerTests+ApplicationStateRawValueTests`), so these two predicates
127+
/// cannot disagree on it here, and every state that is not `.runningBackground` keeps its
128+
/// activating route for reads — which for a capture is also where the raise lives. The one
129+
/// deliberate divergence is background itself: a read is served in place because the tree answers
130+
/// from anywhere, while a window-level capture raises because its pixels are a region grab that
131+
/// the occluding app spoils (#3254's measurement). Full-screen captures raise only a stopped app,
132+
/// where the activation is the launch it has always performed.
133+
func testMacBackgroundServingAndCaptureRaiseConditionsArePinnedPerState() throws {
134+
let read = try runnerCommandFixture(#"{"command":"snapshot","commandId":"table","appBundleId":"com.example.any"}"#)
135+
let noBundle = try runnerCommandFixture(#"{"command":"snapshot","commandId":"table"}"#)
136+
let states: [(state: XCUIApplication.State, expected: Bool)] = [
137+
(.unknown, false),
138+
(.notRunning, false),
139+
(.runningBackground, true),
140+
(.runningForeground, false),
141+
]
142+
let foreground = XCUIApplication.State.runningForeground
143+
let unknown = XCUIApplication.State.unknown
144+
let notRunning = XCUIApplication.State.notRunning
145+
let raiseRows: [(fullscreen: Bool?, state: XCUIApplication.State, expected: Bool)] = [
146+
(nil, foreground, false),
147+
(nil, .runningBackground, true),
148+
(nil, unknown, true),
149+
(nil, notRunning, true),
150+
(false, foreground, false),
151+
(false, .runningBackground, true),
152+
(false, unknown, true),
153+
(false, notRunning, true),
154+
(true, foreground, false),
155+
(true, .runningBackground, false),
156+
(true, unknown, false),
157+
(true, notRunning, true),
158+
]
159+
for row in states {
160+
XCTAssertEqual(
161+
macReadMayBeServedInBackground(command: read, targetState: row.state),
162+
row.expected,
163+
"read state=\(row.state.rawValue)"
164+
)
165+
}
166+
XCTAssertFalse(
167+
macReadMayBeServedInBackground(command: noBundle, targetState: .runningBackground),
168+
"a read naming no app has no session app to serve in place"
169+
)
170+
for row in raiseRows {
171+
XCTAssertEqual(
172+
macAppCaptureNeedsRaise(fullscreen: row.fullscreen, targetState: row.state),
173+
row.expected,
174+
"capture fullscreen=\(String(describing: row.fullscreen)) state=\(row.state.rawValue)"
175+
)
176+
}
177+
}
178+
}
179+
#endif
180+
120181
#if AGENT_DEVICE_RUNNER_UNIT_TESTS
121182
extension RunnerTests {
122183
@MainActor

‎src/commands/schema/cli-help.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -739,7 +739,8 @@ Rules:
739739
Context menus are not ambient UI: secondary-click a visible target, then re-snapshot and use the new menu-item refs.
740740
Do not let iOS simulator-set scoping hide macOS desktop targets.
741741
Prefer refs/selectors over raw coordinates.
742-
macOS snapshot rects are window-space; use current refs or overlay refs instead of guessing coordinates.`,
742+
macOS snapshot rects are window-space; use current refs or overlay refs instead of guessing coordinates.
743+
On the default XCTest backend a read (snapshot, get, find) of a session app that sits behind other windows is answered from where it sits, without raising the app; interactions and a window-level screenshot of that app still bring it forward.`,
743744
},
744745
web: {
745746
summary: 'Minimal browser workflow with the managed web backend',

0 commit comments

Comments
 (0)