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

replay-ui/src/panels/ActionList.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useRef } from "react";
 import type { KeyboardEvent } from "react";
 import type { Step, StepSummary } from "../types";
+import { formatActionRow, formatElapsed } from "../lib/action-format";
 import "./ActionList.css";
 
 export interface ActionListProps {
@@ -11,95 +12,6 @@ export interface ActionListProps {
   selectedStep?: Step;
 }
 
-interface FormattedRow {
-  verb: string;
-  target: string;
-  targetIsTag: boolean;
-}
-
-const SELECTOR_PREFIXES = [
-  "id",
-  "text",
-  "textPrefix",
-  "desc",
-  "descPrefix",
-  "class",
-  "classPrefix",
-  "package",
-];
-
-function parseSelector(selector: string): { kind: string; value: string } | null {
-  const colonIndex = selector.indexOf(":");
-  if (colonIndex <= 0) {
-    return null;
-  }
-  const kind = selector.slice(0, colonIndex);
-  const value = selector.slice(colonIndex + 1);
-  if (!SELECTOR_PREFIXES.includes(kind)) {
-    return null;
-  }
-  return { kind, value };
-}
-
-function tagFromSelector(selector: string): string {
-  const parsed = parseSelector(selector);
-  if (!parsed) {
-    return selector;
-  }
-  if (parsed.kind.endsWith("Prefix")) {
-    return `${parsed.value}...`;
-  }
-  return parsed.value;
-}
-
-export function formatActionRow(step: StepSummary): FormattedRow {
-  const kind = step.action_kind;
-  const label = step.action_label ?? "";
-
-  if (!kind) {
-    if (step.screen) {
-      return { verb: "Observe", target: `@ ${step.screen}`, targetIsTag: false };
-    }
-    return { verb: "Observe", target: "", targetIsTag: false };
-  }
-
-  switch (kind) {
-    case "Tap": {
-      if (!label) {
-        return { verb: "Click", target: "", targetIsTag: false };
-      }
-      if (label.startsWith("(") && label.endsWith(")")) {
-        return { verb: "Click", target: label, targetIsTag: false };
-      }
-      if (parseSelector(label)) {
-        return { verb: "Click", target: tagFromSelector(label), targetIsTag: true };
-      }
-      return { verb: "Click", target: label, targetIsTag: false };
-    }
-    case "InputText":
-      return { verb: "Type", target: label, targetIsTag: false };
-    case "Swipe":
-      return { verb: "Swipe", target: label, targetIsTag: true };
-    case "PressKey":
-      return { verb: "Press", target: label, targetIsTag: true };
-    case "Wait":
-      return { verb: "Wait", target: label, targetIsTag: true };
-    default:
-      return { verb: kind, target: label, targetIsTag: false };
-  }
-}
-
-export function formatElapsed(millis: number): string {
-  const safe = Math.max(0, Math.floor(millis));
-  const totalSeconds = Math.floor(safe / 1000);
-  const mm = Math.floor(totalSeconds / 60);
-  const ss = totalSeconds % 60;
-  const ms = safe % 1000;
-  const pad2 = (n: number) => String(n).padStart(2, "0");
-  const pad3 = (n: number) => String(n).padStart(3, "0");
-  return `${pad2(mm)}:${pad2(ss)}.${pad3(ms)}`;
-}
-
 function renderTarget(target: string, isTag: boolean) {
   if (!target) {
     return null;

replay-ui/src/panels/MetricsChart.tsx

@@ -1,5 +1,11 @@
 import { useState } from "react";
 import type { Metrics } from "../types";
+import {
+  buildPath,
+  formatHeap,
+  formatTime,
+  fractionFor,
+} from "../lib/metrics-format";
 import "./MetricsChart.css";
 
 export interface MetricsSample {
@@ -15,50 +21,6 @@ export interface MetricsChartProps {
   runStartMillis?: number;
 }
 
-const MB = 1024 * 1024;
-
-function formatHeap(bytes: number): string {
-  if (bytes <= 0) return "0B";
-  if (bytes < MB) return `${Math.round(bytes / 1024)}K`;
-  if (bytes < 1024 * MB) return `${Math.round(bytes / MB)}M`;
-  return `${(bytes / (1024 * MB)).toFixed(1)}G`;
-}
-
-function formatTime(millis: number): string {
-  const safe = Math.max(0, Math.floor(millis));
-  const seconds = Math.floor(safe / 1000);
-  const mm = String(Math.floor(seconds / 60)).padStart(2, "0");
-  const ss = String(seconds % 60).padStart(2, "0");
-  return `${mm}:${ss}`;
-}
-
-function fractionFor(index: number, count: number): number {
-  if (count <= 1) return 0.5;
-  return index / (count - 1);
-}
-
-function buildPath(
-  samples: MetricsSample[],
-  getValue: (sample: MetricsSample) => number | undefined,
-  ceiling: number,
-): string {
-  const segments: string[] = [];
-  let pendingCommand = "M";
-  samples.forEach((sample, index) => {
-    const value = getValue(sample);
-    if (value === undefined) {
-      pendingCommand = "M";
-      return;
-    }
-    const x = fractionFor(index, samples.length);
-    const ratio = ceiling === 0 ? 0 : Math.min(value / ceiling, 1);
-    const y = 1 - ratio;
-    segments.push(`${pendingCommand}${x.toFixed(4)},${y.toFixed(4)}`);
-    pendingCommand = "L";
-  });
-  return segments.join(" ");
-}
-
 interface LaneDot {
   key: number | string;
   x: number;

replay-ui/src/panels/SnapshotTable.tsx

@@ -1,3 +1,4 @@
+import { flatten, getAtPath, stableStringify } from "../lib/snapshot-diff";
 import "./SnapshotTable.css";
 
 export interface SnapshotTableProps {
@@ -5,103 +6,6 @@ export interface SnapshotTableProps {
   previousSnapshots?: Record<string, unknown>;
 }
 
-interface Row {
-  path: string;
-  value: unknown;
-}
-
-const INLINE_ARRAY_LIMIT = 2;
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    Object.getPrototypeOf(value) === Object.prototype
-  );
-}
-
-function flatten(input: Record<string, unknown>): Row[] {
-  const rows: Row[] = [];
-  const walk = (value: unknown, path: string) => {
-    if (isPlainObject(value)) {
-      const keys = Object.keys(value).sort();
-      if (keys.length === 0) {
-        rows.push({ path, value: {} });
-        return;
-      }
-      for (const key of keys) {
-        const nextPath = path === "" ? key : `${path}.${key}`;
-        walk(value[key], nextPath);
-      }
-      return;
-    }
-    if (Array.isArray(value)) {
-      if (value.length <= INLINE_ARRAY_LIMIT) {
-        rows.push({ path, value });
-        return;
-      }
-      for (let i = 0; i < value.length; i++) {
-        walk(value[i], `${path}[${i}]`);
-      }
-      return;
-    }
-    rows.push({ path, value });
-  };
-  for (const key of Object.keys(input).sort()) {
-    walk(input[key], key);
-  }
-  return rows.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-}
-
-function getAtPath(source: Record<string, unknown> | undefined, path: string): unknown {
-  if (!source) {
-    return undefined;
-  }
-  if (Object.prototype.hasOwnProperty.call(source, path)) {
-    return source[path];
-  }
-  const segments = path.split(/\.|\[(\d+)\]/).filter((segment) => segment !== undefined && segment !== "");
-  let current: unknown = source;
-  for (const segment of segments) {
-    if (current === null || current === undefined) {
-      return undefined;
-    }
-    if (Array.isArray(current)) {
-      const index = Number(segment);
-      if (Number.isNaN(index)) {
-        return undefined;
-      }
-      current = current[index];
-      continue;
-    }
-    if (typeof current === "object") {
-      current = (current as Record<string, unknown>)[segment];
-      continue;
-    }
-    return undefined;
-  }
-  return current;
-}
-
-function canonicalize(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map(canonicalize);
-  }
-  if (isPlainObject(value)) {
-    const out: Record<string, unknown> = {};
-    for (const key of Object.keys(value).sort()) {
-      out[key] = canonicalize(value[key]);
-    }
-    return out;
-  }
-  return value;
-}
-
-function stableStringify(value: unknown): string {
-  return JSON.stringify(canonicalize(value));
-}
-
 function formatValue(value: unknown): string {
   if (value === null) {
     return "null";

replay-ui/src/panels/ViolationsPanel.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import type { ResidualNode, Witness } from "../types";
+import { STATUS_ORDER, statusFor } from "../lib/property-status";
 import ResidualNodeView from "../components/ResidualNode";
 import "./ViolationsPanel.css";
 
@@ -15,29 +16,6 @@ export interface ViolationsPanelProps {
   violationsOnly?: boolean;
 }
 
-type Status = "violated" | "pending" | "holds";
-
-const STATUS_ORDER: Record<Status, number> = {
-  violated: 0,
-  pending: 1,
-  holds: 2,
-};
-
-function statusFor(
-  name: string,
-  violations: Set<string>,
-  residuals?: Record<string, ResidualNode>,
-): Status {
-  if (violations.has(name)) {
-    return "violated";
-  }
-  const residual = residuals?.[name];
-  if (residual && residual.op === "true") {
-    return "holds";
-  }
-  return "pending";
-}
-
 function formatValue(value: unknown): string {
   const encoded = JSON.stringify(value);
   return encoded === undefined ? String(value) : encoded;