simframe 0.7.2 → 0.9.0

package/src/index.js

@@ -19,6 +19,7 @@ import * as graph from './graph.js';
 import * as matching from './matching.js';
 import * as refs from './refs.js';
 import * as screenmap from './screenmap.js';
+import * as metrics from './metrics.js';
 import { capabilitiesFor, resolveDevice, resize, screenshot } from './platform/index.js';
 import * as store from './store.js';
 
@@ -314,10 +315,24 @@ function stallNote(health) {
   const parts = [`capture: stalled — the display surface has been unreadable for ${Math.round(forMs / 1000)}s`];
   if (health.reattaches) parts.push(`${health.reattaches} re-attach${health.reattaches === 1 ? '' : 'es'} did not help`);
   if (health.reason) parts.push(String(health.reason).slice(0, 120));
-  // The cure is the user's to apply. Saying so is the difference between an
-  // agent that reports "the simulator is wedged" and one that retries a tap
-  // twenty times because nothing appeared to change.
-  parts.push('only restarting the device is known to cure it');
+  // What to do about it, and this line has been wrong until now.
+  //
+  // It said "only restarting the device is known to cure it". Then the same
+  // daemon's log turned out to contain nine "capture recovered on its own"
+  // lines, and a wedge that had survived 223 port re-resolves and 6 device
+  // rebinds cleared by itself while nobody touched it. Meanwhile Apple's own
+  // `simctl io screenshot` on a wedged device returns a valid PNG whose every
+  // pixel is black, in 16 s — so the display pipeline has stopped rendering
+  // and simframe's read is an accurate report of that, not a bug in it.
+  //
+  // So: it is the simulator, it often comes back, and restarting the device
+  // also cures it. `simframe doctor` runs a screenshot probe when this is
+  // published and says which of the two faults it is.
+  parts.push(
+    "this is the simulator's display, not simframe's read of it: Apple's own screenshot path "
+    + 'returns an all-black image on a wedged device. It frequently recovers on its own; '
+    + 'restarting the device also cures it, and `simframe doctor` will confirm which fault this is',
+  );
   return parts.join('; ');
 }
 
@@ -473,7 +488,7 @@ function pngSize(png) {
   return { width: png.readUInt32BE(16), height: png.readUInt32BE(20) };
 }
 
-export async function getState(deviceQuery, { since, options } = {}) {
+export async function getState(deviceQuery, { since, options, inputHealth = false } = {}) {
   const { device, state } = await ensureDaemon(deviceQuery, options);
   return {
     device,
@@ -482,9 +497,54 @@ export async function getState(deviceQuery, { since, options } = {}) {
     map: regionMap(state.regions || [], REGION_COLS),
     since: compareToBaseline(state, resolveBaseline(state, since)),
     live: liveness(device.udid, state),
+    // Off by default and asked for by the state commands only. A flow step
+    // calls getState twice, and the fix for a stale session runs before every
+    // action anyway (input.ensureFreshSession) — this is the report, not the
+    // repair.
+    input: inputHealth ? await input.sessionHealth(device.udid) : undefined,
+    timing: inputHealth ? timingOfNow(device.udid, state) : undefined,
   };
 }
 
+/**
+ * How long this screen has been moving, against how long it usually takes.
+ *
+ * Research §7 asks `sim_state` for this, and the point is a sentence an agent
+ * can act on: a screen 400 ms into a transition that normally takes 350 ms is
+ * fine, and the same screen four seconds in is not. Elapsed comes from the
+ * frame store's own clock; the distribution comes from the edge that was most
+ * recently traversed into this screen.
+ *
+ * Reads no frames and takes no perception pass: the layout hash and the
+ * structural hash screen memory filed under it are both already on disk.
+ */
+function timingOfNow(udid, state) {
+  try {
+    const near = screenmap.recallNearest(udid, state.layoutHash);
+    const edge = graph.timingInto(udid, near?.entry?.structuralHash);
+    const elapsed = Number.isFinite(state.lastChangeAt) ? Date.now() - state.lastChangeAt : null;
+    const settled = state.stableForMs >= STRUCTURAL_SETTLE_MS;
+    const slower = graph.slowerThanUsual({
+      elapsedMs: elapsed,
+      p95: edge?.p95,
+      settled,
+      kind: state.transition?.kind,
+    });
+    return {
+      edge_p50: edge?.p50 ?? null,
+      edge_p95: edge?.p95 ?? null,
+      samples: edge?.samples ?? 0,
+      elapsed_ms: elapsed,
+      stable_for_ms: state.stableForMs ?? null,
+      slower_than_usual: Boolean(slower.slower),
+      note: slower.slower ? slower.note : null,
+    };
+  } catch {
+    // Timing is commentary. A screen with no history still has a state.
+    return null;
+  }
+}
+
 /**
  * Wait for the screen to settle (`mode: 'stable'`) or to move away from what it
  * shows right now (`mode: 'change'`). Removes the screenshot-retry loop.
@@ -516,6 +576,21 @@ export async function waitFor(
   const deadline = startedAt + timeoutMs;
   const startSeq = first.seq;
   let last = first;
+  /**
+   * The longest pause *inside* this transition, in ms.
+   *
+   * This is the statistic a stillness window exists to defeat: a transition
+   * that pauses for 180 ms mid-flight will be mistaken for a finished screen
+   * by any window shorter than that. Nobody was measuring it, so the window
+   * was a constant — 500 ms, chosen once, paid by every step forever.
+   *
+   * Tracked as the highest `stableForMs` observed before the screen moved
+   * again. Reported so a caller can learn it per edge; a settle that ends
+   * without a second change has no gap to report and says 0.
+   */
+  let quietGapMs = 0;
+  let quietRun = 0;
+  let lastHash = first.hash;
   let sawChange = mode === 'stable' || first.hash !== baselineHashValue;
   const changedAtStart = sawChange && mode !== 'stable';
 
@@ -524,6 +599,7 @@ export async function waitFor(
     state: last,
     satisfied,
     mode,
+    quietGapMs,
     sawChange,
     changedBeforeWait: changedAtStart,
     baselineHash: baselineHashValue,
@@ -543,6 +619,17 @@ export async function waitFor(
 
       if (!sawChange && state.hash !== baselineHashValue) sawChange = true;
 
+      // A pause that turned out not to be the end of the transition. Only
+      // pauses followed by more movement count: the quiet at the end of a
+      // settle is the answer, not a gap.
+      if (state.hash !== lastHash) {
+        if (quietRun > quietGapMs) quietGapMs = quietRun;
+        quietRun = 0;
+        lastHash = state.hash;
+      } else if (Number.isFinite(state.stableForMs)) {
+        quietRun = Math.max(quietRun, state.stableForMs);
+      }
+
       // Some controls barely move the screen at all — a radio dot, a checkbox,
       // a button changing state. Waiting the full timeout for a change that
       // will never be visible turns a 100ms action into a 12s one, so give up
@@ -890,8 +977,15 @@ export async function locate(
       const list = outcome.alternatives
         .map((a, i) => `[${i}] "${a.label}" (${a.x},${a.y}) ${a.region ?? 'content'} ${a.score}`)
         .join(', ');
-      throw new Error(
-        `"${query}" matches ${outcome.alternatives.length} things on this screen — say which, or pass index: ${list}`,
+      // Tagged, not just thrown: the reason an escalation happened is known
+      // here and nowhere above here. See metrics.tag — it adds a property and
+      // changes nothing else about the error.
+      throw metrics.tag(
+        new Error(
+          `"${query}" matches ${outcome.alternatives.length} things on this screen — say which, or pass index: ${list}`,
+        ),
+        'ambiguous_intent',
+        { candidates: outcome.alternatives },
       );
     }
     if (outcome.status === 'ok') {
@@ -905,24 +999,28 @@ export async function locate(
     // here undoes every guard above — it has no off-screen filter and no
     // coverage weighting, and it is what returned a scrolled-away list row for
     // "back". "Not found" is the correct answer.
-    const sample = entry.targets
-      .filter((t) => t.label && t.y >= 0 && t.y <= points.height)
-      .slice(0, 12)
-      .map((t) => t.label.slice(0, 24))
-      .join(', ');
-    throw new Error(`"${query}" is not on this screen. Visible: ${sample || '(nothing readable)'}`);
+    const visible = entry.targets.filter((t) => t.label && t.y >= 0 && t.y <= points.height);
+    const sample = visible.slice(0, 12).map((t) => t.label.slice(0, 24)).join(', ');
+    // Which escalation this is depends on whether the screen was recognised.
+    // Screen memory had nothing for it (`from` is one of the built values) and
+    // the target is missing: that is not knowing the screen. On a screen
+    // recalled from memory, the screen is known and the intent did not resolve.
+    throw metrics.tag(
+      new Error(`"${query}" is not on this screen. Visible: ${sample || '(nothing readable)'}`),
+      from === 'memory' ? 'ambiguous_intent' : 'unknown_screen',
+      { candidates: visible.slice(0, 8) },
+    );
   }
 
   const candidates = screenmap.rank(entry, query);
   const target = index != null ? candidates[index] : candidates[0];
   if (!target) {
-    const sample = entry.targets
-      .filter((t) => t.label)
-      .slice(0, 12)
-      .map((t) => t.label)
-      .join(', ');
-    throw new Error(
-      `"${query}" is not on this screen. Visible: ${sample || '(nothing readable)'}`,
+    const visible = entry.targets.filter((t) => t.label);
+    const sample = visible.slice(0, 12).map((t) => t.label).join(', ');
+    throw metrics.tag(
+      new Error(`"${query}" is not on this screen. Visible: ${sample || '(nothing readable)'}`),
+      from === 'memory' ? 'ambiguous_intent' : 'unknown_screen',
+      { candidates: visible.slice(0, 8) },
     );
   }
   return { device, state: current, entry, target, from, distance, settled, screens: screenmap.stats(udid).screens };

package/src/input.js

@@ -2,8 +2,11 @@
 // capability layered on top, so every entry point here has to answer "is this
 // even available?" before it answers anything else.
 import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
 import * as control from './control.js';
-import { capabilitiesFor, geometryFor, inputDriverFor, setPasteboard } from './platform/index.js';
+import * as store from './store.js';
+import { bootedAtFor, capabilitiesFor, geometryFor, inputDriverFor, setPasteboard } from './platform/index.js';
 import { promisify } from 'node:util';
 
 const run = promisify(execFile);
@@ -323,6 +326,7 @@ export function centerOf(node) {
 }
 
 export async function tapPoint(udid, x, y, { durationMs } = {}) {
+  await ensureFreshSession(udid);
   const point = { x: Math.round(x), y: Math.round(y) };
   const own = inputDriverFor(udid);
   if (own) {
@@ -347,6 +351,7 @@ export async function tapLabel(udid, query, { index, durationMs } = {}) {
 }
 
 export async function typeText(udid, value) {
+  await ensureFreshSession(udid);
   const own = inputDriverFor(udid);
   if (own) {
     // No pasteboard on Android (docs/DEFERRED.md), so exact text goes through
@@ -379,6 +384,7 @@ export async function typeText(udid, value) {
  * to say so; `type` still works on every device.
  */
 export async function pasteText(udid, value) {
+  await ensureFreshSession(udid);
   const own = inputDriverFor(udid);
   if (own?.key) {
     // The clipboard goes over gRPC; KEYCODE_PASTE is what puts it in the field.
@@ -413,6 +419,7 @@ export async function typeKeys(udid, value) {
 }
 
 export async function pressKey(udid, keycode) {
+  await ensureFreshSession(udid);
   const own = inputDriverFor(udid);
   if (own) {
     await own.key(udid, keycode);
@@ -433,10 +440,111 @@ export async function pressKey(udid, keycode) {
  *
  * @returns {Promise<boolean>} whether a session was actually reset.
  */
+/**
+ * Is the daemon's HID session older than the device it talks to?
+ *
+ * Pure, so the comparison is testable without a device. `graceMs` covers the
+ * ordinary case where a daemon is started immediately after a boot and the two
+ * timestamps land within milliseconds of each other in either order.
+ */
+export function sessionStaleness({ bootedAt, sessionSince, graceMs = 2000 }) {
+  if (!Number.isFinite(bootedAt)) {
+    return { stale: false, reason: 'cannot tell when the device booted' };
+  }
+  if (!Number.isFinite(sessionSince)) {
+    return { stale: false, reason: 'no capture daemon has recorded a start time, so there is no session to compare against' };
+  }
+  if (bootedAt <= sessionSince + graceMs) return { stale: false, reason: null };
+  return {
+    stale: true,
+    reason: `the device booted ${Math.round((bootedAt - sessionSince) / 1000)}s after the capture daemon started, `
+      + 'so the daemon holds an HID session for a device session that no longer exists',
+    bootedAt,
+    sessionSince,
+  };
+}
+
+/**
+ * What state the input path is in, for doctor and sim_state.
+ *
+ * Reads two timestamps off disk — the device's boot marker and the daemon's
+ * own `startedAt` — and costs a stat each. No input is dispatched to find out,
+ * because the whole failure being detected is input that reports success and
+ * does nothing.
+ */
+const bootCache = new Map();
+/**
+ * Boot time, cached for a moment.
+ *
+ * iOS answers with a stat; Android runs `adb shell cat /proc/uptime`, a
+ * subprocess of 20-40 ms, and `getState` runs twice per flow step. A few
+ * seconds of staleness in the staleness detector costs nothing — a device that
+ * rebooted three seconds ago is still rebooted at the next check.
+ */
+async function bootedAtCached(udid, ttlMs = 3000) {
+  const hit = bootCache.get(udid);
+  if (hit && Date.now() - hit.at < ttlMs) return hit.value;
+  const value = await bootedAtFor(udid);
+  bootCache.set(udid, { at: Date.now(), value });
+  return value;
+}
+
+export async function sessionHealth(udid) {
+  if (!udid || !control.available(udid)) return { stale: false, reason: null };
+  let bootedAt = null;
+  try {
+    bootedAt = await bootedAtCached(udid);
+  } catch (err) {
+    return { stale: false, reason: `cannot tell when the device booted: ${err.message}` };
+  }
+  const meta = store.readJson(store.paths(udid).meta);
+  const rebuilt = store.readJson(sessionFile(udid))?.rebuiltAt;
+  // The newer of the two: the daemon starting creates a session, and rebuilding
+  // it replaces one. Either makes the session current as of that moment.
+  const sessionSince = Math.max(meta?.startedAt ?? 0, rebuilt ?? 0) || undefined;
+  return sessionStaleness({ bootedAt, sessionSince });
+}
+
+/**
+ * Rebuild the session if the device outlived it. Once per process, per device.
+ *
+ * Rebuild, and retry nothing: this runs *before* the action, so the action is
+ * delivered on a session known to be current. Retrying afterwards is how an
+ * action fires twice, which is the hazard the verify barrier exists to
+ * prevent — and it is why the existing recovery covers hardware buttons only.
+ */
+const freshened = new Set();
+export async function ensureFreshSession(udid) {
+  if (!udid || freshened.has(udid)) return null;
+  freshened.add(udid);
+  const health = await sessionHealth(udid);
+  if (!health.stale) return null;
+  const rebuilt = await resetSession(udid);
+  return { ...health, rebuilt };
+}
+
+/**
+ * When the HID session was last rebuilt, if it has been.
+ *
+ * The daemon's `startedAt` is the wrong clock on its own: rebuilding the
+ * session makes it current again without restarting the daemon, so comparing
+ * against the daemon's start left `doctor` reporting `stale` about a session
+ * that had just been rebuilt and was demonstrably working. It is a file rather
+ * than a variable because every CLI command is a new process and the daemon
+ * holding the session outlives all of them.
+ */
+const sessionFile = (udid) => path.join(store.deviceDir(udid), 'input-session.json');
+
 export async function resetSession(udid) {
   if (!control.available(udid)) return false;
   try {
     await control.resetInput(udid);
+    try {
+      fs.mkdirSync(store.deviceDir(udid), { recursive: true });
+      store.writeAtomic(sessionFile(udid), JSON.stringify({ rebuiltAt: Date.now() }));
+    } catch {
+      /* the rebuild happened; failing to write it down only costs a stale report */
+    }
     return true;
   } catch {
     return false;
@@ -444,6 +552,7 @@ export async function resetSession(udid) {
 }
 
 export async function pressButton(udid, name) {
+  await ensureFreshSession(udid);
   const own = inputDriverFor(udid);
   if (own) {
     // Android's whole key vocabulary is safe to offer: `input keyevent` takes
@@ -464,6 +573,7 @@ export async function pressButton(udid, name) {
 }
 
 export async function swipe(udid, from, to, { durationMs = 300 } = {}) {
+  await ensureFreshSession(udid);
   const own = inputDriverFor(udid);
   if (own) {
     await own.swipe(udid, from, to, { durationMs });

package/src/intent.js

@@ -5,6 +5,7 @@
 // instinct removes the expensive part of driving a UI with an agent: the model
 // round trip spent reasoning about controls it has never seen.
 import * as input from './input.js';
+import * as metrics from './metrics.js';
 
 /** Confirming words, most specific first. The first tier with a hit wins. */
 const CONFIRM_TIERS = [
@@ -77,7 +78,11 @@ export function findOptions(nodes, geo) {
 export async function chooseAny(udid, { prefer, geo } = {}) {
   const nodes = await input.describeAll(udid);
   const options = findOptions(nodes, geo);
-  if (!options.length) throw new Error('no selectable options found on screen');
+  if (!options.length) {
+    throw metrics.tag(new Error('no selectable options found on screen'), 'novel_dialog', {
+      candidates: nodes.filter((n) => n.label).slice(0, 8).map((n) => ({ label: n.label })),
+    });
+  }
   const chosen =
     (prefer && options.find((o) => o.label.toLowerCase().includes(String(prefer).toLowerCase()))) ||
     options[0];
@@ -89,7 +94,11 @@ export async function chooseAny(udid, { prefer, geo } = {}) {
 export async function confirm(udid, { geo } = {}) {
   const nodes = await input.describeAll(udid);
   const target = findConfirm(nodes, geo);
-  if (!target) throw new Error('no confirming control on screen');
+  if (!target) {
+    throw metrics.tag(new Error('no confirming control on screen'), 'novel_dialog', {
+      candidates: nodes.filter((n) => n.label).slice(0, 8).map((n) => ({ label: n.label })),
+    });
+  }
   const point = input.centerOf(target);
   await input.tapPoint(udid, point.x, point.y);
   return { label: target.label, point, enabled: target.enabled };

package/src/matching.js

@@ -182,6 +182,77 @@ export const SAME_CONTROL_POINTS = 12;
  */
 const INTERACTIVE_ROLE = /button|field|cell|row|link|switch|slider|tab|menu|segment|checkbox/i;
 
+/**
+ * Is this target the accessibility tree's reading of a control?
+ *
+ * A merged target carries `ax|ocr`, because both sensors saw it. Every
+ * comparison against the string `'ax'` had to become this: an element does not
+ * stop being the tree's element because OCR agreed with it, and treating
+ * `ax|ocr` as "not ax" would have quietly demoted exactly the elements the
+ * merge is most confident about.
+ */
+export const isAxTarget = (t) => /(^|\|)ax(\||$)/.test(t?.source ?? '');
+
+/** How much of `inner` lies inside `outer`, as a fraction of inner's own area. */
+export function containedFraction(inner, outer) {
+  if (!inner || !outer) return 0;
+  const iw = Math.max(0, inner.width ?? 0);
+  const ih = Math.max(0, inner.height ?? 0);
+  const innerArea = iw * ih;
+  if (innerArea <= 0) return 0;
+  const x = Math.max(inner.x, outer.x);
+  const y = Math.max(inner.y, outer.y);
+  const right = Math.min(inner.x + iw, outer.x + (outer.width ?? 0));
+  const bottom = Math.min(inner.y + ih, outer.y + (outer.height ?? 0));
+  const overlap = Math.max(0, right - x) * Math.max(0, bottom - y);
+  // Clamped: float arithmetic on sub-pixel OCR frames put a fully contained
+  // box at 1.0000000000000007, and a fraction of an area cannot exceed 1.
+  return Math.min(1, overlap / innerArea);
+}
+
+/**
+ * How much of the smaller box must sit inside the larger one to be the same
+ * element. OCR boxes sit a pixel or two outside the row they are printed on
+ * often enough that 1.0 would miss them.
+ */
+export const CONTAINMENT = 0.9;
+
+/**
+ * Do these two strings name the same thing?
+ *
+ * The discriminator that makes containment safe. A tab bar contains all five
+ * of its tab labels, and merging a container with its contents is the failure
+ * the old size cap was defending against — but a tab bar's own label is not
+ * "Assets", so the text test refuses that merge while allowing a row labelled
+ * "Kate Bell" to absorb OCR's reading of "Kate Bell".
+ *
+ * Substring counts because iOS labels carry state the printed text does not:
+ * a row reads "Larger Text" on screen and publishes "Larger Text, Off".
+ */
+export function sameText(a, b) {
+  const x = norm(a);
+  const y = norm(b);
+  if (!x || !y) return false;
+  if (x === y) return true;
+  if (x.includes(y) || y.includes(x)) return Math.min(x.length, y.length) >= 3;
+  // Fuzzy, because OCR misreads a letter or two — measured: "Location (AII)"
+  // for "Location (All)", and a Cyrillic К for a K in a monogram.
+  return nameScore(x, y) >= 0.5;
+}
+
+/**
+ * The same element, seen by both sensors.
+ *
+ * `ax` is the tree's element, `ocr` a text box. True when the text sits
+ * (almost) wholly inside the element AND says the same thing as its label or
+ * value.
+ */
+export function sameElementSeenTwice(ax, ocr) {
+  if (!ax?.frame || !ocr?.frame) return false;
+  if (containedFraction(ocr.frame, ax.frame) < CONTAINMENT) return false;
+  return sameText(ax.label, ocr.label ?? ocr.text) || sameText(ax.value, ocr.label ?? ocr.text);
+}
+
 const contains = (frame, target) =>
   Boolean(frame)
   && target.x >= frame.x && target.x <= frame.x + (frame.width ?? 0)
@@ -205,6 +276,14 @@ function sameControl(a, b) {
   // tab bar from absorbing its own tabs.
   if (INTERACTIVE_ROLE.test(a.type ?? '') && contains(a.frame, b)) return true;
   if (INTERACTIVE_ROLE.test(b.type ?? '') && contains(b.frame, a)) return true;
+  // And a labelled accessibility element that is not an interactive role —
+  // a list row published as StaticText — with OCR's reading of its own label
+  // inside it. This is the pair that made `tap "Kate Bell"` refuse on every
+  // Contacts list: 16 escalations in the first instrumented run, all one
+  // screen. Defence in depth: the screen map now merges this pair at fusion,
+  // and a map built before that still resolves.
+  if (isAxTarget(a) && !isAxTarget(b) && sameElementSeenTwice(a, b)) return true;
+  if (isAxTarget(b) && !isAxTarget(a) && sameElementSeenTwice(b, a)) return true;
   return false;
 }
 
@@ -219,8 +298,8 @@ function collapseSamePlace(ranked) {
     // Prefer the real hit target: an accessibility element over OCR's reading of
     // it, and an interactive role over a caption sitting inside it.
     const better = (candidate, incumbent) => {
-      if (candidate.target.source === 'ax' && incumbent.target.source !== 'ax') return true;
-      if (candidate.target.source !== 'ax' && incumbent.target.source === 'ax') return false;
+      if (isAxTarget(candidate.target) && !isAxTarget(incumbent.target)) return true;
+      if (!isAxTarget(candidate.target) && isAxTarget(incumbent.target)) return false;
       return INTERACTIVE_ROLE.test(candidate.target.type ?? '')
         && !INTERACTIVE_ROLE.test(incumbent.target.type ?? '');
     };

package/src/mcp.js

@@ -480,7 +480,7 @@ async function look(target, args, options) {
 async function state(target, args, options) {
   const { device } = await api.ensureDaemon(target, options);
   const requested = baselineFor(device.udid, args.since);
-  const res = await api.getState(target, { since: requested, options });
+  const res = await api.getState(target, { since: requested, options, inputHealth: true });
   const s = res.state;
   const lines = [
     header(res.device, s, res.ageMs),
@@ -500,6 +500,19 @@ async function state(target, args, options) {
   }
   const warn = livenessLine(res.live);
   if (warn) lines.unshift(warn);
+  // An agent that cannot see this spends five turns wondering why a correct
+  // tap on a correct element did nothing. The repair happens before the next
+  // action either way; this is so the cause is visible when it does.
+  if (res.input?.stale) lines.unshift(`input: stale — ${res.input.reason}`);
+  // §7's timing line. Worth a line because "is it still coming or is it done"
+  // is a question an agent otherwise answers by waiting and guessing.
+  if (res.timing?.samples) {
+    lines.push(
+      `timing: usually ${res.timing.edge_p50}ms to arrive here (p95 ${res.timing.edge_p95}ms over `
+      + `${res.timing.samples} samples), ${res.timing.elapsed_ms}ms since the last change`
+      + (res.timing.slower_than_usual ? ` — ${res.timing.note}` : ''),
+    );
+  }
   remember(device.udid, s);
   return { content: [text(lines.filter(Boolean).join('\n'))] };
 }