You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
Commit eabe119
Browse filesBrowse the repository at this point in the historyBrowse files
fix(ios-runner): keep snapshot-plan target state on main and bound the query sweep by its slice (callstack#2836)
* fix(ios): take snapshot target identity on main and hop plan state writes
The capture plan runs on the command queue but read currentBundleId,
currentAppProcessIdentifier and the penalty warm-up exemption, and wrote
runnerAccessibilityHealth and invalidated the cached target directly.
Snapshot preparation now takes a SnapshotCaptureTarget on main (app,
bundle id, pid, consumed warm-up exemption) and the plan, the modal
probe penalty, the XCTest penalty recorder and the private AX tier read
only that copy. Health writes and the fail-closed invalidation go through
applyMainOwnedSnapshotState, the abandoned-work-guarded main hop that
invalidateCachedTargetAfterSnapshotFailure now also uses.
Fixescallstack#2781
* fix(ios): bound the query sweep by its tier slice deadline
A non-interactive query sweep used Date.distantFuture as its own
deadline, so only the up-to-20 s plan deadline bounded it while the
caller abandoned the tier after its 1 s slice. XCTest queries cannot be
cancelled, so the sweep kept the main thread busy and later commands got
RUNNER_BUSY.
The caller now derives one slice deadline (querySweepSliceDeadline) for
both its wait and the sweep, for interactive and non-interactive
requests alike. Neither the element queries nor the per-element reads
start with less than flatInteractiveQueryBudget left before that
deadline (querySweepCanStartQuery).
Fixescallstack#2783
* fix(ios): spend the penalty warm-up exemption only in a capture plan that runs
Taking the snapshot target on main consumed the exemption during command
preparation, so a snapshot answered by the blocking system-modal probe, or
an abandoned preparation that ran late, spent it without running a plan.
The exemption now lives in a lock-owned type that lifecycle code arms on
main and runSnapshotCapturePlan consumes at its start.
* test(ios): pin the non-interactive query sweep to its tier slice through the plan
Swizzles XCUIElementQuery.allElementsBoundByIndex with a slow query and runs
a non-interactive [.querySweep] plan with a 20 s plan deadline. The sweep
must not be abandoned, and no query may start after the plan answers, so
passing the plan deadline to the sweep in either loop turns it red.
* test(ios): pin the query-sweep tier timeout and the tap routing identity to main
Two regressions callstack#2781 still leaves open, both red on this head:
A query sweep that stops at its own slice deadline is a tier timeout, but
the plan classified its payload by node count, so a partial sweep that beat
the sparse threshold armed no XCTest-channel penalty and no later capture
of the same screen was deferred.
The coordinate tap's system-modal routing probe armed its penalty with
currentBundleId read on the command queue, while main owned that state and
could still be clearing or rebinding it.
* fix(ios): count a query sweep that ends on its slice deadline as a tier timeout
The sweep tier stopped starting queries at its slice deadline, but the plan
classified only what it collected. sparsePayloadReason accepts anything above
the sparse node threshold, so a partial flat sweep became a `recovered`
capture: no XCTest-channel penalty was armed, private AX never ran, and every
later capture of that screen paid for the full sweep again.
`runFlatInteractiveQueries` now returns a typed `SnapshotTierOutcome`, the
sweep tier carries it into the attempt, and the plan rejects a
`.deadlineExhausted` tier through `snapshotTierRejectionReason` — keeping its
payload only as the fallback, arming the penalty through the existing tier
timeout reason, and letting the next backend answer.
* fix(ios): take the system-modal probe's target identity on main
The coordinate tap resolved its system-modal routing on the command queue and
armed an abandoned probe's penalty with `currentBundleId` read there, while
`applyMainOwnedSnapshotState` and the lifecycle code write that identity
through `DispatchQueue.main.async`. A tap could penalize a target main was
still clearing or rebinding.
The probe now takes a `SnapshotProbePenaltyTarget`: a capture hands over the
identity it already took on main, and the tap route hands over nothing and lets
the probe's own main-side block capture the identity main holds once its work
starts. No off-main path reads target identity any more.
* test(ios): place this PR's runner tests in main's split UnitTests files
main (callstack#2854, callstack#2855) moved the runner's inline unit tests into UnitTests/ and
split RunnerTests+CommandExecution.swift along command families. Rebase conflicts
dropped this PR's edits from the inline blocks the rebase kept on main; relocate
them into the file main now owns for each family:
- RunnerTests+SnapshotTests.swift: the query-sweep slice-deadline and
fail-closed-invalidation tests, and the bounded-modal-probe helper now takes a
SnapshotCaptureTarget.
- RunnerTests+SnapshotCapturePlanTests.swift: the tier-timeout rejection pair and
the private-AX depth helper now builds a SnapshotCaptureTarget.
- RunnerTests+SnapshotTimingTests.swift: the deadline-exhausted tier penalty test.
-only-testing:AgentDeviceRunnerUITests/RunnerTests/testPrivateAXPinnedRegularDepthReachesAcquisitionAndPresentation 2>&1 | tee /tmp/agent-device-runner-regressions.log
0 commit comments