test: full test-suite refactor sweep (#61)

* chore(test): start test-suite refactor sweep

* test(ltl): pin exact multi-obligation residual AST

* test(ltl): table-test finalize Kleene connective combinations

* test(ltl): pin reduce over pending inner for bound, Or, Not

* test(ltl): marshal bounded Always steps/duration/deadline

* test(verifier): cover LTL combinator verdict transitions and within unit panic

* test(verifier): table-test DecodeAction kinds and lastAction field exposure

* test(verifier): assert WithPlatform(ios) reaches the picker host and key pool

* test(verifier): widen weighted-selection assertion to a 5x skew margin

* test(verifier): un-skip ax-find round trip with a committed tree fixture

* test(runner): pin isWDADrop to sidecar reconnect-failed message origin

* test(runner): assert PressKey/Wait trace encoding records kind-specific fields

* test(runner): cover RenderSummary unsupported-verbs surfacing branch

* test(trace): set Hierarchy in round-trip and lock lossy Tree contract

Also add a -race concurrent WriteStep test that asserts N well-formed JSONL lines, catching torn lines if the writer mutex is dropped.

* test(trace): round-trip witnesses/changes/metrics/exceptions, pin step-0 witness

* test(trace): document ViolationsAreGreppable grep contract and lock-free WriteScreenshot

* test(hierarchy): cover invalid-JSON and malformed-bounds parser paths

* test(trace): guard writer mutex via WriteStep/Close race on w.file

* test(replay): drop unfailable assets and devproxy assertions

* test(replay): cache reuses on equal mtime, reparses after append

* test(replay): violation marker falls back to detection step when attributed missing

* test(replay): corrupt meta/trace dirs return 500 with error body

* test(replay): SSE client receives runs.changed after a broadcast

* test(replay): Run coalesces creates, ignores write/chmod, closes subs on cancel

* fix(sidecar): synchronize health fixture writes and exercise healthError

* test(sidecar): cover swipe/longpress/doubletap/erase/presskey/metrics/logs translations

* test(sidecar): cover DoubleTapSelector composition and mid-gesture cancel

* test(sidecar): assert gRPC error status surfaces from action RPC

* fix(chrome): route action methods through runCtx so caller cancellation aborts CDP

* fix(chrome): route hierarchy/screenshot/waitidle/metrics through runCtx

* refactor(ios): extract pure simctl JSON parsers

* refactor(ios): add command-runner seams for EnsureSimulator

* test(ios): table-test simctl parsers and EnsureSimulator seams

* test(sidecarassets): cover placeholder build path

* test(sidecarassets): assert reuse via sentinel bytes not mtime

* test(bundler): cover properties-only spec registration

* refactor(testrun): extract prepareBundleInputs from Execute

* test(testrun): cover prepareBundleInputs aliases and missing-runtime error

* test(testrun): table-test resolveRuntimeSibling search edges

* test(testrun): exact-output tests for progressHandler line format

* fix(cmd): point bundle-check aliases at pkg/spec/src

* test(cmd): smoke-test bundle-check resolves spec aliases

* test(cmd): table-test hier-check parse and FindAll on fixture

* test(cmd): unit-test buildBrowseURL deep-link vs root

* test(cmd): drop flaky TestRun_Doctor that launched real Chromium

* test(cmd): pin pipeline error to bundle resolution on web platform

* test(replay-ui): add bun test script

* ci(replay-ui): run bun test via make web-test target

* ci(replay-ui): point bun cache key at replay-ui/bun.lock

* test(replay-ui): exercise real URL encoding and non-ok throw in getJson

* refactor(replay-ui): extract snapshot flatten/getAtPath into lib module

* test(replay-ui): pin snapshot flatten/getAtPath path round-trip

* refactor(replay-ui): extract action selector/format into lib module

* test(replay-ui): pin action selector parse and row formatting

* refactor(replay-ui): share one statusFor between panels

* refactor(replay-ui): extract run-history derivation into lib module

* test(replay-ui): pin shared statusFor precedence and ordering

* test(replay-ui): pin run-history derivation alignment

* refactor(replay-ui): export clampIndex for testing

* refactor(replay-ui): extract keyboard-nav dispatch into pure module

* refactor(replay-ui): extract metrics formatters into lib module

* test(replay-ui): pin clampIndex step boundaries

* test(replay-ui): pin keyboard-nav ownership and key routing

* test(replay-ui): pin metrics formatters and path gap handling

* refactor(sidecar): expose device-output parsers as internal for testing

* test(sidecar): table-test device-output parsers against malformed input

* test(sidecar): cover logcat parsing year inference and line skipping

* test(sidecar): pin pressKey keycode mapping and unknown-key rejection

* test(sidecar): metrics bundleId falls back to launched app and honors override

* test(sidecar): loosen deadline upper bound to tolerate slow CI scheduling

* test(web-runtime): export selector builders for unit tests

* test(web-runtime): guard sanitize cycle, function, and depth limits

* test(web-runtime): table-test selector builder quoting and escaping

* test(sidecar): collapse scalar-forwarding RPC tests into a table

* test(replay-ui): dedup step/summary fixtures into shared module

* test(ios): collapse pickSimulator point-tests into a table

internal/runner/runner_test.go

@@ -160,6 +160,35 @@ func TestRunner_MaxStepsStopsAfterExactlyNSteps(t *testing.T) {
 	}
 }
 
+// TestRenderSummary_SurfacesUnsupportedVerbs exercises the real path that takes
+// verbs the picker requested but the platform cannot dispatch and puts them in
+// front of the operator. TestRunner_HappyPath only ever asserts the field stays
+// empty (every builtin is supported, so its non-empty arm can never fire), so
+// without this the "unsupported on %s: ..." branch could be deleted and every
+// unsupported-verb regression would pass silently.
+func TestRenderSummary_SurfacesUnsupportedVerbs(t *testing.T) {
+	summary := Summary{Steps: 3, UnsupportedVerbs: []string{"longPresses", "scrolls"}}
+
+	var out bytes.Buffer
+	RenderSummary(&out, summary, "ios")
+
+	if !strings.Contains(out.String(), "unsupported on ios: longPresses, scrolls") {
+		t.Errorf("expected unsupported verbs line for ios, got:\n%s", out.String())
+	}
+}
+
+// TestRenderSummary_OmitsUnsupportedLineWhenNone guards the inverse: a clean run
+// must not print a stray "unsupported on" line, so a future refactor cannot
+// start emitting an empty list and alarm the operator on every run.
+func TestRenderSummary_OmitsUnsupportedLineWhenNone(t *testing.T) {
+	var out bytes.Buffer
+	RenderSummary(&out, Summary{Steps: 2}, "android")
+
+	if strings.Contains(out.String(), "unsupported on") {
+		t.Errorf("did not expect an unsupported-verbs line, got:\n%s", out.String())
+	}
+}
+
 func TestRunner_ViolationSurfacesInSummary(t *testing.T) {
 	state := newHarnessWithSpec(t, violationSpec)
 
@@ -552,6 +581,48 @@ func TestTraceActionFor_StaleCoordinatesDoNotOverrideTreeCenter(t *testing.T) {
 	}
 }
 
+// TestTraceActionFor_RecordsKindSpecificFields locks each action kind's trace
+// encoding. PressKey must carry its Key and Wait its DurationMillis; if either
+// branch of traceActionFor drops the field (or a field rename desyncs from the
+// trace.Action struct) the replay UI silently renders a key-less PressKey or a
+// zero-duration Wait. Swipe's endpoint encoding is covered separately via
+// applyAction (TestApplyAction_ScrollWithPrecomputedEndpointsSwipes).
+func TestTraceActionFor_RecordsKindSpecificFields(t *testing.T) {
+	cases := []struct {
+		name   string
+		action verifier.Action
+		check  func(*testing.T, *trace.Action)
+	}{
+		{
+			"PressKey records key",
+			verifier.Action{Kind: verifier.ActionKindPressKey, Key: "back"},
+			func(t *testing.T, a *trace.Action) {
+				if a.Key != "back" {
+					t.Errorf("Key = %q, want %q", a.Key, "back")
+				}
+			},
+		},
+		{
+			"Wait records duration",
+			verifier.Action{Kind: verifier.ActionKindWait, DurationMillis: 250},
+			func(t *testing.T, a *trace.Action) {
+				if a.DurationMillis != 250 {
+					t.Errorf("DurationMillis = %d, want 250", a.DurationMillis)
+				}
+			},
+		},
+	}
+	for _, testCase := range cases {
+		t.Run(testCase.name, func(t *testing.T) {
+			traceAction := traceActionFor(testCase.action, nil)
+			if traceAction.Kind != string(testCase.action.Kind) {
+				t.Errorf("Kind = %q, want %q", traceAction.Kind, testCase.action.Kind)
+			}
+			testCase.check(t, traceAction)
+		})
+	}
+}
+
 func TestRunner_LogsWaitForIdleDriverErrors(t *testing.T) {
 	state := newHarness(t)
 	state.mock.Failures[mockdriver.ActionWaitForIdle] = errors.New("sidecar lost gRPC stream")
@@ -1399,7 +1470,18 @@ func TestRunner_InternalApplyErrorMarksTransitional(t *testing.T) {
 // UNAVAILABLE that happens to embed raw exception text (e.g. ConnectException
 // from the original failure) means the sidecar already recovered and the run
 // must continue.
+// TestIsWDADrop_Classification pins isWDADrop to the exact phrase the sidecar
+// throws at its reconnect site (sidecar DriverBackend.kt):
+//
+//	throw IllegalStateException("WDA reconnect failed: $restartErr", cause)
+//
+// If that message is reworded on the Kotlin side without updating the Go
+// matcher, a fatal, unrecoverable WDA drop is misclassified as transient and
+// the run burns its budget retrying a dead channel instead of aborting.
 func TestIsWDADrop_Classification(t *testing.T) {
+	// sidecarReconnectFailedMessage mirrors the literal the sidecar emits; the
+	// matcher's contract is keyed on this exact prefix.
+	const sidecarReconnectFailedMessage = "WDA reconnect failed"
 	cases := []struct {
 		name string
 		err  error
@@ -1411,8 +1493,8 @@ func TestIsWDADrop_Classification(t *testing.T) {
 			false,
 		},
 		{
-			"reconnect failure is a drop",
-			status.Error(codes.Internal, "java.lang.IllegalStateException: WDA reconnect failed: IOSDriverTimeoutException"),
+			"sidecar reconnect-failed message is a drop",
+			status.Error(codes.Internal, "java.lang.IllegalStateException: "+sidecarReconnectFailedMessage+": IOSDriverTimeoutException"),
 			true,
 		},
 		{"generic internal is not a drop", status.Error(codes.Internal, "boom"), false},