iris: iris::input/iris::frame diagnostics, and gating the four debug! lines that already drowned the ring

Iris asked for a button to copy raw input events and per-frame timings
through the same report Copy report already produces. sense::log_input_event
(one line per platform pointer sample, historical samples inline on
Android) and diagnostics::log_frame (one line per frame: frame number,
frame clock, time since last input, layout/draw durations, redraw kind,
primitives on screen, animating) both land under iris::diagnostics's
trace_enabled() gate, off by default since the ring is 2000 lines/256KiB
and either target at 120Hz fills it in seconds. report_to_touch.py turns
a report's iris::input lines back into a .touch file for harness/desktop
replay, round-tripped in transcript-fixture's input_log_roundtrip test.

Folds in docs/REVIEW-2026-09-07.md's D1: four older per-frame debug!
lines (android::view's two render() lines, list.rs's fling tick,
text/mod.rs's text render) were unconditional at Debug and, with the
ring's RingLogger recording everything the app's Debug install lets
through regardless of target, filled it before Copy report ever saw
anything else. All four (and sense.rs's drag-release-samples line) are
now behind the same gate. The same test proves both directions: tracing
off leaves zero Debug lines from a replayed flick, tracing on produces
the expected iris::input/iris::frame lines with real durations.

Not wired to a Diagnostics-pane button: bench_client.rs is open under
another agent. set_trace(bool) is the whole surface a control needs.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

iris/core/src/orientation/axis.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum Axis {
     X,
     Y,

iris/core/src/ui/render_state.rs

@@ -1,3 +1,6 @@
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
 use crate::{
     ActiveData, IdLike, MaskIdx, MoveIdx, Painter, PixelRegion, PrimitiveLayers, RegionAlign,
     StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
@@ -5,6 +8,21 @@ use crate::{
     util::{HashMap, HashSet, Id, Vec2},
 };
 
+/// What [`UiRenderState::update`] did on its last call -- read back by the
+/// `iris::frame` diagnostic (`iris::diagnostics::log_frame` in the `iris`
+/// crate) so a report can tell a full relayout from a frame that only
+/// redrew a handful of dirty widgets from one that drew nothing at all.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RedrawKind {
+    /// Neither the root nor any widget changed -- `update` did nothing.
+    None,
+    /// [`UiRenderState::redraw_all`]: a new root, or a resize.
+    All,
+    /// [`UiRenderState::redraw_updates`]: only the widgets `needs_redraw`
+    /// named.
+    Updates,
+}
+
 pub struct UiRenderState {
     pub active: HashMap<WidgetId, ActiveData>,
     pub layers: PrimitiveLayers,
@@ -58,6 +76,31 @@ pub struct UiRenderState {
     /// Text layouts actually computed -- bumped by `Painter::render_text`,
     /// which `TextView::render` only reaches on a cache miss.
     pub(super) shape_count: u64,
+
+    /// `Instant::now()` at construction -- the zero every `iris::frame` line
+    /// dates itself from, so a report's `now=` is comparable to a harness's
+    /// own `t_ms` (`Harness::new` builds its `base` the same way, in the
+    /// same constructor call) without either side needing the wall clock.
+    epoch: Instant,
+    /// How many times [`Self::update`] has run -- the `iris::frame` line's
+    /// frame number. Counts every call, including one that found nothing to
+    /// redraw, so a gap in the sequence in a report is a frame this state
+    /// was never asked to run at all (a stalled event loop), not one that
+    /// ran and did nothing.
+    frame_no: u64,
+    /// How long the redraw phase of the last [`Self::update`] took --
+    /// [`Self::redraw_all`] or [`Self::redraw_updates`], whichever ran, or
+    /// zero if neither did. Read back by `iris::diagnostics::log_frame`.
+    last_layout: Duration,
+    last_redraw_kind: RedrawKind,
+    /// When the sensor dispatch (`SensorUi::run_sensors`, in the `iris`
+    /// crate) last saw an input sample, dated by the sample's own clock
+    /// (`CursorState::time`) rather than when the dispatch ran -- same
+    /// reasoning as that field's own doc. A `Mutex` rather than a
+    /// `Cell` for the same reason `captured` is: `run_sensors` takes `&self`
+    /// and this is the one render state both backends already share across
+    /// frames.
+    last_input_at: Mutex<Option<Instant>>,
 }
 
 /// The bound on the parent walk -- see `resolve_move` in shader.wgsl,
@@ -87,6 +130,11 @@ impl UiRenderState {
             region_mut_count: 0,
             mov_count: 0,
             shape_count: 0,
+            epoch: Instant::now(),
+            frame_no: 0,
+            last_layout: Duration::ZERO,
+            last_redraw_kind: RedrawKind::None,
+            last_input_at: Mutex::new(None),
         }
     }
 
@@ -150,17 +198,82 @@ impl UiRenderState {
             "a previous frame left {} widget(s) marked as mid-draw",
             self.draw_started.len(),
         );
-        if self.needs_redraw_all(root) {
+        // Timed unconditionally -- an `Instant::now()` pair is cheap enough
+        // not to move the `--phone` bench's frame time (checked when this
+        // was added), and gating it behind the trace toggle would leave
+        // `iris::frame` with nothing to report the one frame somebody just
+        // turned tracing on to look at.
+        let layout_start = Instant::now();
+        let kind = if self.needs_redraw_all(root) {
             self.redraw_all(root, rsc);
             self.old_root = root.map(|r| r.id());
             self.resized = false;
+            RedrawKind::All
         } else if rsc.widgets().has_updates() {
             self.redraw_updates(rsc);
-        }
+            RedrawKind::Updates
+        } else {
+            RedrawKind::None
+        };
+        self.last_layout = layout_start.elapsed();
+        self.last_redraw_kind = kind;
+        self.frame_no += 1;
         #[cfg(debug_assertions)]
         debug_assert!(self.primitive_counts_agree(), "{}", self.orphan_report(rsc),);
     }
 
+    /// `Instant::now()` at construction -- see the field's own doc.
+    pub fn epoch(&self) -> Instant {
+        self.epoch
+    }
+
+    /// How many times [`Self::update`] has run, counting from 1.
+    pub fn frame_number(&self) -> u64 {
+        self.frame_no
+    }
+
+    /// How long the last [`Self::update`]'s redraw phase took.
+    pub fn last_layout_duration(&self) -> Duration {
+        self.last_layout
+    }
+
+    /// What the last [`Self::update`] did -- see [`RedrawKind`].
+    pub fn last_redraw_kind(&self) -> RedrawKind {
+        self.last_redraw_kind
+    }
+
+    /// Records that a real input sample was just dispatched, dated by the
+    /// sample's own clock -- called once per sensor pass, so `iris::frame`'s
+    /// `since_input` can answer "how stale was the input
+    /// this frame drew" instead of a caller guessing from the frame
+    /// interval. `&self` because `run_sensors` only ever has that -- see
+    /// `last_input_at`'s field doc.
+    pub fn note_input(&self, at: Instant) {
+        if let Ok(mut guard) = self.last_input_at.lock() {
+            *guard = Some(at);
+        }
+    }
+
+    /// `now - ` the last input sample's own timestamp, or `None` if no
+    /// input has ever reached this render state (a cold start, or a screen
+    /// that only ever animates on its own). Saturates to zero rather than
+    /// panicking if `now` is earlier than the input sample somehow was --
+    /// a diagnostic reading wrong is not worth a crash over.
+    pub fn time_since_input(&self, now: Instant) -> Option<Duration> {
+        let at = *self.last_input_at.lock().ok()?;
+        at.map(|at| now.saturating_duration_since(at))
+    }
+
+    /// Primitive instances every currently-active widget owns, summed --
+    /// what `iris::frame`'s `primitives=` reports. Not a per-frame delta:
+    /// `redraw_updates` only rewrites what changed, so this is "how much is
+    /// on screen", which is what a report reads as "did this frame have
+    /// more to draw than the last one", not "how much work did this frame
+    /// do" (`take_counters` answers that).
+    pub fn active_primitive_count(&self) -> usize {
+        self.active.values().map(|a| a.primitives.len()).sum()
+    }
+
     fn redraw_all(&mut self, root: Option<&StrongWidget>, rsc: &mut dyn UiRsc) {
         self.clear(rsc);
         // free all resources & cache