ci: dispatch workflows for folio and the replay ui (#73)

* feat(runner): stop the step loop at the first violation on request

* feat(testrun): report violations as a typed error under exit-on-violation

* feat(cli): add --exit-on-violation and exit 2 when it fires

* docs(cli): document --exit-on-violation, --max-steps, and exit codes

* fix(web): enumerate and query across shadow roots in both producers

* test(chrome): compare both producers on a shadow-dom parity page

* test(browser): drive a canvas-under-shadow-root fixture end to end

* fix(web): select the focused field inside a shadow root before typing

* fix(web): report the pathname as the screen when there is no hash route

* fix(web): settle on dom quiescence instead of returning at body ready

* feat(replay-ui): add data-testid hooks the dogfood spec drives

* feat(replay-ui): add the dogfood spec sanderling runs against the replay ui

* fix(replay-ui): scope the screenshot property to the named state panel

* chore(make): add per-platform sanderling build targets

* ci: add dispatch workflows for folio and the replay ui

* docs: describe the dispatch workflows and how to read a failure

* ci(folio): give the ios leg its jdk, android sdk, just, and a clean app start

* refactor(web): use max for the settle budget

* ci: pin calibrated seeds, skip the flaky ios reinstall, bound every job

* ci: authenticate and pin the buf setup step

the anonymous release download hit the shared runner ip rate limit and
failed the job with 'socket hang up' after three retries.

* docs: record that canvas apps need a dom proxy to be text-fuzzable

* fix(ios): bound lifecycle rpcs and claim the target device

a launch the simulator rejects sent the xctest session into a recovery
chain that answered minutes late or never, and the rpc had no deadline,
so the run hung with no trace and no error. also take a per-udid flock:
a second run's reinstall lands under the first's live automation session
and wedges it.

* docs(ci): correct the ios hang wording and note the device lock

* refactor(verifier): derive the lastAction shape from one field list

both hosts must show a spec the same lastAction. one ordered list now
feeds the goja object and the json the web host installs, so they
cannot drift.

* fix(web): install lastAction in the page before extractors read it

state.lastAction was hardcoded null on web, so every property reading it
was silently vacuous: a correct property passed without ever firing.

* fix(web): carry element identity on actions and fix findAll on paths

an action's target was coordinates only, so a property matching on which
element was acted upon could never fire. ax.findAll([a,b]) also returned
nothing on web.

* fix(chrome): wait out a route transition before sampling facts

the tree stays byte-identical and quiet across a cross-fade, so both the
quiet timer and the unchanged-tree escape called it settled mid-flight
and extractors read two screens at once.

* fix: bound the pre-run app launch

launch happens before the runner starts, so --duration never covered it
and a wedged driver hung with no trace and no error.

* fix(folio): read balances from merged cards and treat unreadable as unknown

compose for web merges the whole accountcard subtree, so the balance
child never exists there and every card parsed as 0. the property then
compared 0 to 0 and fired on any submit, which is a false positive
generator. unknown is now null and null is vacuously true.

* test(folio): cover merged-card parsing and unknown balances

* ci(folio): make web an expect-the-bug leg

the web runtime can observe the double submit now, so the health gate
understates it. seed 1 finds it at step 109, 3 runs out of 3.

* docs(ci): explain why a submit tap landing on home is the bug

* fix(ios): read a StaticText's label as its text

AXValue was the only source for text, but a StaticText carries its
string in AXLabel, so nothing on screen had .text on ios: a spec reading
it saw everything on android and nothing here.

* docs(ci): correct the calibrated step ranges

* fix(folio): stop convicting on arithmetic float64 cannot hold

past 2^53 cents the gap between representable values is 128, so a real
1600-cent move reads back as something else and the equality is false
for a healthy submit as readily as a double one. also match parseCents:
a sign or an oversized amount is rejected, not read as an amount.

* test(folio): pin the safe-integer guard and its boundary

* docs: stop teaching the zero-default that caused a false alarm

* docs: write down the silent-vacuity failure modes

* feat(folio): tag the home total and the card transaction count

the total was the only untagged node on the screen, so the spec had to
sum cards and a clipped card broke the sum.

* fix(folio): read the app's own total and refuse contaminated windows

summing cards went null when one was clipped, and the null poisoned the
carrier for the rest of the run. the balance window also spanned every
transaction since the last home visit, so the property convicted on
deltas it could not attribute: the old web witness was 3.16x the typed
amount, not 2x.

* test(folio): pin the window rules and the count invariant

* fix(folio): never read a frame that shows two screens

android dumps a cross-fade with both screens in the tree. the route said
add-transaction while an unscoped find said home, so the oracle took a
half-rendered total as fresh and convicted on a tap that committed
nothing. one function now decides the route and returns null when the
frame is ambiguous.

* test(folio): cover transition frames, card readings and creation

* fix(folio): only disambiguate counts that came from merged text

the equal-length digit rule exists because web merges the card and an
account named -1 makes '12' ambiguous. a dedicated count node has
nothing to disambiguate, so applying it there threw away real evidence.

* ci(folio): pin the recalibrated seeds and drop android to a health gate

web 3 and ios 7 convict 3 runs out of 3 with an exactly 2x witness.
android convicts 2 in 5 because the same seed does not walk the same
trajectory there, so it proves the app runs instead.

* docs(ci): describe the two properties and why android cannot convict

* fix(android): wait out a route cross-fade before snapshotting

the dump could hold two screens at once, and the runner refuses to act
on such a tree, so a quarter of android steps applied no action and the
count varied per run: the same seed never walked the same trajectory.
the ios companion and the chrome driver already do this.

* ci(folio): let the android leg run far enough to see its conviction

* docs: only the repo owner merges

* ci(folio): a thrown predicate is not a conviction

exit 2 means the run recorded a violation, and a predicate that throws
is recorded as one too. so was newAccountBalanceIsZero, an unrelated
property in the same spec. the gate read the exit code and went green
with detection dead.

* ci: install idb-companion from its tap and stop interpolating inputs

idb-companion is not in homebrew-core, so the ios leg died before it
built anything. replay-ui expanded dispatch inputs into the shell.

* docs: correct the snippets and numbers that drifted from the code

* test(sidecar): pin that a slow read counts toward the stability streak

* fix(web): read the page's extractors only on steps that count

the page advances the spec's carriers when it evaluates, but the runner
applied the result only on non-transitional steps. a discarded step
moved the window forward anyway, so the next accepted pair bracketed two
transactions while counting one submit, and convicted a healthy app.
extractor errors now fail the run instead of leaving goja's values in
current against v8's in previous.

* fix(chrome): anchor the transition deadline when the dom goes quiet

it was anchored at script start, so a page that churned past the window
reached the check already expired and returned mid cross-fade. the
driver now publishes the idle timeout it needs, since the caller's 1s
could never spend the 800ms window.

* fix(web): fail on a partial extractor override

same mixed-producer hazard as the install error: some extractors hold
the page's value and the rest hold goja's, and a property comparing
across that split fires on a healthy app.

* docs: six of seven, the seventh is the stock property

* fix(folio): drop a name two cards answer to

homeTxnCountsOf keyed on the account name and let the last card win, so
two accounts the fuzzer named the same collapsed into one entry. a
reading that saw one Travel card and a later one that saw both then
subtracted two different accounts' counts, and
submitCommitsOneTransactionPerAction convicted a healthy app of
double-submitting. it is a gated property in folio-run.sh, so that reads
as "found the submit bug" over a card scrolling into view.

same rule createdAccountHasNonZeroBalance already applies: a name
nothing can attribute is no evidence. counted over every card, since an
unreadable twin spoils the identity too.

* perf(folio): read each frame once

every extractor asked routeOf, and routeOf does five ax.find calls. on
web each find walks the document and every shadow root beneath it, so
the spec cost 110 tree walks a step; homeCards was parsed four times
over. now 5 and once.

keyed on the identity of the state object because both hosts build a new
one per step and hand that one object to every getter, so it cannot
outlive its frame. holding the reference is what keeps that true rather
than likely.

* fix(web): keep an undefined reading's index through JSON

json has no undefined, so an extractor whose getter returned one had its
whole index dropped by JSON.stringify. that index then kept goja's
dump-derived value while its neighbours held the page's, and a property
comparing previous to current across the split fires on a healthy app.
folio has nine on(route, tag) extractors, so this was most extractors on
most steps.

each reading is wrapped in a {value} envelope: the drop now happens
inside the entry, and an absent value means the getter returned
undefined, which is what the goja host records for the same getter. a
json null would instead claim it returned null and x.current ===
undefined would answer differently on the two hosts.

* feat(verifier): report the registered extractor count

the web path needs it to check the page sent one reading per extractor.

* fix(runner): fail when the page reports fewer readings than extractors

the comment here already claimed a partial override was fatal. it was
not: the skipped check only catches indices outside the extractor list,
so a page reporting values for some extractors and not others left the
rest holding goja's reading of the dump with nothing said.

* test(browser): drive an undefined reading through the whole web path

four layers carry it: the page's envelope, the driver's unwrap, the
runner's count check and the verifier's decode. each has a unit test and
only a run proves they compose. goes red both ways, decoding an absent
value as null and dropping the envelope.

* fix(web): offer the aria roles a user activates

only role=button was in the tappable set, so link, checkbox, radio,
switch, tab, option, the menuitems and treeitem were invisible to the
enumeration however plain the control looked. the replay ui builds its
step rows as <li role="option">, and the spec dogfooding it had to
hand-write an action to reach them because no default verb could see a
single row.

both producers build the set from the same role list, since the parity
test compares them element by element.

* test(browser): tap a role-based control end to end

every control on the page is an <li role="option">, the shape the
replay ui gives its step rows, and the spec carries no action of its
own: the property firing is the evidence the default enumeration offered
a tap on one.

* fix(web): read aria-disabled as disabled

the enabled fact came off the disabled property, which only real form
controls have. it reads undefined on the role-based controls the
tappable set now covers, so every one of them looked enabled however
plainly it was marked otherwise, and the fuzzer would spend actions on
inert ones.

both producers answer the same two ways, and the parity fixture carries
a disabled row so the comparison covers it: reverting one side alone
names the element and the fact.

* docs(replay-ui): the enumeration reaches step rows now

the comment said role="option" is not in the tappable selector set,
which stopped being true a few commits ago. selectAStep stays, for the
reason the tab weight below it stays: one row among the page's clickable
elements is a thin chance, and both step-facing properties go vacuous on
a run that never selects one.

* test(runner): bound the last-action test by steps, not wall clock

100ms of wall clock against an assertion that two steps ran fatals under
load with "the web path never installed it", which reads as a
regression. every sibling test in the package uses a long duration and
MaxSteps.

* ci: run the kotlin tests in make test

RouteTransitionTest and the stability poll cover the android settle and
nothing in ci ran them. :sidecar:test needs no android sdk, checked by
running it with ANDROID_HOME pointed at nothing.

* fix(sidecar): measure the stability streak as observed quiet

parameterising pollUntilStable also moved the clock to the start of the
read that opened a run of identical snapshots, so a read's own duration
counted as quiet. the pre-existing caller polls a real uiautomator dump:
at 400ms a read, 750ms of required quiet became 250ms of observed quiet
and the poll settled in two reads instead of four.

the parameters stay, the semantics go back.

* test(sidecar): pin the transition cap by driving it

it asserted 1500 >= 700 + 300, two constants, which can only fail if
someone edits a constant. it now drives awaitSettledTree against a fade
that lands after 700ms and asserts it hands back the settled tree before
the cap. cut the cap to 1000 and it goes red.

* ci: pin buf-setup-action to a commit

it takes a token now, so a floating tag is a token handed to whatever
that tag moves to. note v1 there is a branch, not a tag, so the ref
lookup that resolves it is matching-refs/heads/v1.

* ci: declare least-privilege permissions

none of the three declared any, so each got the repository default.
release.yml and docs.yml already do this. all three only check out,
build, test and upload artifacts.

* ci: fail fast when a server never comes up

the readiness loops fell through silently after 30 tries, so a server
that never started surfaced as an opaque driver failure minutes later.
each now says what did not answer and on which port.

* ci(folio): a missing trace is not a verdict

with no trace the android gate ran its grep against ./trace.jsonl and
reported "never reached AddTransactionScreen, so it never got past
login", which is not what happened. the web and ios branches had the
same misdiagnosis on exit 0.

same class, one line up: the classifier's own failure was swallowed, so
with the evidence reader dead the gate printed a healthy run and exited
0.

* ci(replay-ui): skip a run directory with no trace

the summarise step is if: always(), and under github's bash -eo pipefail
an unmatched glob stays literal, the redirect fails, pipefail carries it
into the assignment and -e kills the step. so a failed fuzz run went red
twice, once for the real reason.

docs/development/ci.md

@@ -0,0 +1,161 @@
+---
+title: CI
+---
+
+# CI
+
+`ci.yml` runs on every pull request: it builds, unit-tests, and drives three
+small web fixtures through headless Chrome (`test/browser/testdata`). It never
+runs sanderling against a real app.
+
+Two other workflows do, and both are `workflow_dispatch` only. They boot devices,
+build apps and take minutes, which is not what you want on every push, and
+neither is a merge gate.
+
+## folio
+
+Actions -> folio -> Run workflow. Inputs pick the legs (`all`, `android`, `ios`,
+`web`), and override the seed, the step budget and the wall-clock budget. Seed
+and step budget take `0` to mean "use the calibrated value in the workflow"; the
+wall-clock budget has no such sentinel and is passed through as written, so
+every leg gets whatever you type there.
+
+Each leg builds `examples/folio` for its platform, builds the CLI with only the
+tags that platform needs (`make sanderling-android` and friends), and runs
+`examples/folio/sanderling/spec.ts` through `.github/scripts/folio-run.sh`. That
+script is plain bash so you can reproduce a job locally, with that leg's pinned
+numbers:
+
+```
+SEED=9 MAX_STEPS=200 .github/scripts/folio-run.sh android
+```
+
+**web and ios expect the bug.** Folio double-submits a transaction when the
+submit button is double-tapped, and two properties catch it:
+`submitMovesBalanceByTypedAmount`, which demands the total balance move by
+exactly the amount typed, and `submitCommitsOneTransactionPerAction`, which
+demands no more transactions committed over a window than there were submit
+actions in it. A double tap is one action committing two transactions, so it
+breaks both.
+
+The runs pass `--exit-on-violation`, which exits 2 when the run recorded a
+violation and 1 when something went wrong. Telling those apart is the whole
+point of the exit code: a job that only knew "non-zero" could not tell a working
+fuzzer from a broken emulator.
+
+Exit 2 on its own is not a conviction, though, so the script reads the trace
+before it decides:
+
+| what the trace says | job |
+|---|---|
+| a violation of one of the two properties above, with no `is_error` on its witness | green |
+| a violation whose witness carries `is_error` | red: a predicate threw, and a thrown predicate is recorded as a violation like any other |
+| a violation of any other property (`newAccountBalanceIsZero` fires on one android seed) | red: a real finding, but not the one this leg gates on |
+| no violation and exit 0 | red: the fuzzer stopped finding a bug that is still there |
+| no trace at all, on exit 0 or 2 | red: the run recorded nothing, so there is no verdict to read |
+| exit 1, or any other code | red: the harness broke, and the code propagates |
+
+The first two rows are why the check is worth the code it takes. A `TypeError`
+in `predicates.ts` and a fuzzer that no longer reaches the bug both used to
+print "found the submit bug" and exit 0, and they need opposite responses: one
+is a spec to fix, the other is a seed to recalibrate. A thrown predicate fails
+android as well, where a conviction is otherwise only a bonus, because a spec
+that stopped running is not evidence about the app.
+
+The balance property only judges a window holding exactly one submit action.
+Without that rule the recorded delta covers every transaction since the last Home
+visit, and the property convicts on arithmetic it cannot attribute: an early
+version of this gate went green on a witness whose delta was 3.16x the typed
+amount. Honest windows are rare, so the counting invariant carries most of the
+detection: it needs no amount and survives a wide window.
+
+**android is a health gate**, not a conviction gate, because it convicts in four
+runs out of five rather than five. The leg asserts that the run stayed healthy
+and reached the transaction screen, and reports the conviction it usually gets as
+a bonus. A gate that fails one run in five would be useless here: its failure
+message, "the double-submit bug was NOT found", is indistinguishable from the
+regression the gate exists to catch.
+
+It used to be two runs in five. The android backend now waits out a route
+cross-fade before it snapshots, the way the ios companion and the chrome driver
+do, because a dump holding two screens at once makes the runner refuse to act on
+it and a quarter of android steps therefore applied no action at all. The number
+of those wasted steps varied run to run, so the same seed never walked the same
+trajectory. With the wait, four runs of one seed produced byte-identical decision
+sequences over 179 steps.
+
+The fifth diverged for the remaining reason: a route can settle before its
+content composes, so the tree holds one screen and almost nothing in it, and the
+fuzzer acts on a screen that is still filling in. That happened once in about a
+thousand steps. Catching it needs structural stability polling on every snapshot,
+which costs roughly 2.8s per mutating step and was removed for that reason, so it
+is the open item between android and a real conviction gate.
+
+The wasmJs app is served with `Cross-Origin-Opener-Policy` and
+`Cross-Origin-Embedder-Policy` headers, because its sqlite worker needs
+cross-origin isolation. Served without them the app loads a blank canvas and
+every step observes an empty accessibility tree.
+
+The seeds are calibrated, not guessed. On an M-series mac, web seed 3 convicts at
+step 185-187 and ios seed 7 at step 97-101, each 3 runs out of 3 and each with a
+delta of exactly twice the typed amount. Both run a 240-step budget. Keep them
+pinned: honest evidence is rare, and across 2261 ios steps only one submit tap
+landing on Home had a single-submit window.
+
+Android runs seed 9 over 200 steps: its conviction lands at step 178, so a
+shorter budget would never see the bonus. A full run costs about five minutes.
+
+Repeating the ios leg by hand is not the same as running it in CI: with
+`--clear-data=false` a second local run inherits the first one's accounts, so
+`simctl uninstall` before each repeat or the numbers drift.
+
+The ios leg passes `--clear-data=false`, because the job installs a fresh build
+immediately before the run and a freshly installed app is already clear state.
+The in-run reinstall is worth avoiding: `simctl uninstall` + `install` followed
+straight away by the XCTest runner's own launch fails with `app.folio is unknown
+to FrontBoard` maybe half the time. That used to hang the run outright; the
+launch RPC is bounded now, so it fails in about 90 seconds with a real error
+instead, but a failing leg is still a failing leg. The job timeouts are the
+backstop if it happens anyway.
+
+Only one sanderling run may drive a given simulator at a time. The driver takes
+an advisory lock on the target's UDID and a second run is refused with the lock
+path in the message, because two runs interleaving app lifecycle leave the first
+run's automation session bound to a bundle the simulator no longer knows.
+
+## replay-ui
+
+Actions -> replay-ui -> Run workflow. This one is dogfooding: it records a trace
+from `test/browser/testdata/throwing` (violations and uncaught exceptions, so
+every panel has something to render), serves it with `sanderling replay`, and
+fuzzes that UI with `replay-ui/sanderling/spec.ts`.
+
+Six of the seven properties there are cross-panel agreements - two panels
+deriving the same fact by different paths have to say the same thing - so they
+hold for any trace and need no recalibrating when the fixture changes. The
+seventh is the stock `noUncaughtExceptions`, which asks nothing of the panels
+and only fails if the UI throws. Any violation fails the job.
+
+## Reading a failure
+
+Both workflows upload their run directories as artifacts, and write the step
+count, seed and violations to the job summary. To replay a failure:
+
+```
+gh run download <run-id> -n folio-android
+sanderling replay <the downloaded runs directory>
+```
+
+That is the same UI the replay-ui workflow fuzzes. Open the step the summary
+named, and the Violations tab shows the witness: the property, the reason, and
+the extractor values at the step that caused it.
+
+## When a device leg flakes
+
+Expecting a violation from a single seed is timing-sensitive, most of all on an
+emulator. Calibration reduces that; it does not remove it. If a platform starts
+failing across repeated dispatches with "the double-submit bug was NOT found",
+do not raise the step budget blindly - run a seed sweep with the campaign tool
+(`cmd/internal-tools/campaign`), which exists for exactly this, and pin a seed
+that finds the bug with room to spare. A leg failing with "a predicate threw" is
+a different problem entirely and no seed will fix it.

docs/development/design-principles.md

@@ -51,3 +51,25 @@ There is exactly one authoring surface: the TypeScript spec. There is no separat
 
 This is intentional. A test harness with two authoring languages (YAML plus code, JSON plus code) splits concerns in a way that always drifts. Something works in one surface and not the other, and debugging requires holding both in your head.
 
+
+## 8. A property that cannot fail is worse than one that fails
+
+A spec fails loudly when it is wrong about the app. It fails silently when it is wrong about
+itself, and that is the failure this project has to design against.
+
+Two shapes recur. A property is *vacuously true* when a fact it reads is missing, so it never
+fires and every run is green: `state.lastAction` was hardcoded null on web, `ax.findAll` on a
+selector path returned nothing there, and no element on iOS carried `text` because the mapping
+only ever read `AXValue`. In each case a correct property proved nothing. A property is
+*degenerately false* when a missing fact is read as a value instead: folio's balances parsed as
+`0` on web, so the check became `|0 - 0| === typedAmount` and fired on every healthy submit.
+Both shapes look exactly like a working property from the outside.
+
+So an unreadable fact is unknown, never a default. Extractors return null rather than zero or
+empty string, and a property given an unknown declines to judge instead of convicting. The same
+rule covers arithmetic the representation cannot hold: integer cents in a float64 stop being
+exact past 2^53, and a comparison that cannot pass is not a comparison that failed.
+
+Which means a green run is evidence only if you can point at a step where the property actually
+fired, and a red one only if the witness holds real values. Read the witness, not the exit code.
+Every bug listed above was found that way, and each had already survived a run that looked fine.

docs/development/index.md

@@ -6,6 +6,7 @@ title: Development
 
 - [Design principles](./design-principles/)
 - [Architecture](./architecture/)
+- [CI](./ci/)
 - v0.1.0 scope: [milestone #1](https://github.com/priyanshujain/sanderling/milestone/1)
 
 ## Building the docs site locally