iris android-app: header-duplicate investigation, ime-inset fix for keyboard confirmation

Two follow-ups after the keyboard/dp/header pass, both requested against the P0 box: (a) The header row rendering a second time inside the transcript area after a keyboard-triggered resize: reproduced reliably (tap the composer, screenshot after the keyboard opens). Ruled out one concrete hypothesis -- on_insets_changed rebuilding top_bar on every ime_bottom change, unrelated to the header's own status-bar padding -- with a guard (last_top_pad) that reproduced the identical duplicate afterward, so repeated rebuilding is not the cause. Kept the guard as a real (if insufficient) fix for needless rebuilds. Not root-caused: Span's two-phase provisional/real draw and the redraw_all-vs-redraw_updates split are the two live suspects, but pinning which one (or something else) produces the duplicate needs instrumenting draw_inner directly or the phone. Full writeup in RUST.md's P0 box. (b) Why on_insets_changed's ime_bottom never confirmed the keyboard being shown, on either the auto-diagnostics or the new bench keyboard phase: MainActivity.java uses windowSoftInputMode="adjustResize", under which WindowInsets.Type.ime()'s own inset amount is defined to read zero (the window already resized to avoid the overlap that inset would describe) -- the same trap AGENTS.md already names for the Compose side. Fixed to read insets.isVisible(ime()) instead, a boolean unaffected by resize-vs-pan. This alone did not make the callback re-fire on this emulator, which still shows no insets callback after the initial one at attach -- named but unconfirmed hypothesis: a non-edge-to-edge Activity may not get insets redelivered for a pure IME toggle handled via resize, needing an edge-to- edge opt-in this pass did not attempt given the risk to adjustResize's own behavior. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Merge remote-tracking branch 'origin/rustify' into worktree-agent-a16b22e34539b810e
2026-09-06 01:23:36 -04:00 · 2026-09-06 01:05:18 -04:00 · 2026-09-06 01:02:04 -04:00 · 2026-09-06 00:54:21 -04:00 · 2026-09-06 00:54:06 -04:00 · 2026-09-06 00:51:27 -04:00
28 changed files with 1916 additions and 305 deletions
@@ -8,6 +8,31 @@ capability that moved. Small and trivial changes do not go here.
 An entry gives the date, what changed, why, and a short before/after where
 it helps judge the change without the session that made it. Newest first.
 ## 2026-09-06: `List::anchor_position_display`, `FrameReport::mark_phase`/`phase_stats`/`late_at_hz` (RUST.md's "Benchmark v2")
 `List` gained `anchor_position_display(&self) -> String`, reporting the
 anchor's own row index and pixel offset (`idx=N/off=Mpx`, or
 `idx=more-before`/`idx=more-after`/`idx=none`) -- what a scripted
 benchmark reads to report fling travel. Note the anchor does not
 necessarily change *slot* over a long scroll (this widget's own documented
 design: the anchor is a stable identity, not re-derived from what's on
 screen each frame), so this is not the same measurement as a Compose
 `LazyListState.firstVisibleItemIndex`, which does track the true topmost
 visible row -- the `off` half is what actually reflects how far a fling
 travelled.
 `iris_core::render::frame_report::FrameReport` gained three methods for
 per-phase benchmark reporting: `mark_phase(name)` records a named phase
 boundary at the current frame/instant; `phase_stats(now, refresh_hz)`
 returns one `PhaseStats` (frames, wall duration, late count/percent,
 p50/p90/p99, worst) per marked phase, sliced from the existing ring by a
 new parallel `index_ring`; `late_at_hz(refresh_hz)` gives the whole run's
 late count/percent judged against an arbitrary refresh rate rather than
 the fixed 60Hz `JANK_THRESHOLD` every existing caller still uses (a
 separate method, not a parameter on `report()`, so nothing else changes
 behaviour). `RING_CAPACITY` grew 4096->16384 to hold a full multi-phase
 run without evicting earlier phases' samples.
 ## 2026-09-06: `List::fling`, `VelocityTracker`, `FlingCalculator` (IRIS_TODO.md's "swiping has no momentum")
 `iris::widget::List` gained a real fling: `fling(velocity_px_per_s)` starts
@@ -583,3 +608,46 @@ inset bugs the emulator never showed).
  Explicit `Arc`-backed value passed to the callback and kept on
  `AndroidRenderer`, not a global — a caller wanting one on desktop builds
  its own the same way.
 ## 2026-09-06: `Len::dp`, physical pixels throughout, the keyboard glyph wipe
 Iris's phone report on build a9232ac (screenshots): text now the right
 size but blurry; the keyboard still wipes every glyph; the header buttons
 have nothing behind them. All three are fixed; this entry is the public
 API side. docs/LAYOUT.md has the layout-side writeup, docs/RUST.md's P0
 box has the full investigation and the phone verification still to do.
 - **The keyboard wipe was `surface_changed` rebuilding the whole renderer
  on every resize**, including an IME-driven one — a fresh, empty glyph
  atlas while the CPU-side glyph cache kept UV coordinates from the old
  one. `surface_changed` now calls `AndroidRenderer::resize` (reconfigures
  the surface and window uniform only) when a renderer is already live,
  and only builds a new one when there genuinely isn't one yet.
 - **`Len` has a third field, `dp`** (Android's dp / CSS's reference pixel,
  1/160in), beside the existing `abs` (now explicitly *physical* pixels)
  and `rel`/`rest`. `len_fns::dp`/`Len::dp` construct one, used exactly
  like `abs`/`rel`/`rest` — `dp(16)` instead of a bare `16` wherever a
  size should look the same physical size on any density. This is the
  unit IRIS_TODO.md's "density-independent length unit" item asked for;
  it replaces the previous stopgap (the whole rendered scene divided by
  `content_scale` then implicitly stretched back up), which is also what
  made text blurry — a glyph rasterised at the small, pre-stretch size and
  then upscaled onto the real framebuffer.
 - **`UiRenderState`/`Painter` gained `density()`/`set_density()`** (physical
  pixels per dp). Every place a length resolves (`Len::apply_rest`,
  `Size::to_uivec2`) now takes it; `Span::gap` and `Padding`'s four sides
  moved from a bare `f32` to `Len` so they take `dp(...)` too. A bare
  number anywhere is unaffected — still `abs`, physical pixels.
 - **Text is rasterised at physical resolution now.** `TextBuffer::shape`
  takes `density` and multiplies `font_size`/`line_height` (and any span
  override) by it before handing them to parley, so the atlas holds a
  bitmap at the size it is actually shown at rather than a low-resolution
  one stretched afterward.
 - **Everything at the Android boundary is physical pixels now** — window
  size, touch coordinates, insets (`LogicalInsets` renamed
  `WindowInsets`). The previous "logical" division by `content_scale` is
  gone; `content_scale` now feeds `set_density` instead.
 - Not yet verified on Iris's actual phone (this pass had no device) —
  built and checked on this checkout's emulator only. RUST.md's P0 box
  says what she should check for: crisp text at two densities, the
  keyboard no longer wiping, and the header's background.
@@ -421,8 +421,19 @@ do not duplicate it there.
 ## Build (asked for by Iris, 2026-09-06): a density-independent length unit
- [ ] **A third length kind beside relative and pixels, so display scales
+- [x] **A third length kind beside relative and pixels, so display scales
-  "just work".** Iris's words: "another length type similar to absolute &
+  "just work".** Done 2026-09-06 — `Len::dp`/`len_fns::dp`, resolved
  against `UiRenderState`/`Painter::density()` at `apply_rest` time; text
  additionally rasterises at the resolved (physical) size instead of
  scaling a low-resolution bitmap afterward, which was making text blurry.
  `Span::gap`/`Padding` moved from `f32` to `Len` so they take `dp(...)`
  too; transcript-ui's row/composer padding and one example migrated.
  `em` was not added — nothing in this pass needed a text-relative unit,
  and `dp`'s own doc says why it and physical pixels are kept as separate
  fields rather than one the caller pre-multiplies. Not yet verified on
  Iris's own phone at two densities (this pass had no device) — see
  docs/RUST.md's P0 box and docs/IRIS.md's 2026-09-06 entry for what to
  check. Iris's words: "another length type similar to absolute &
  relative, so instead there would be relative, pixels, and another unit
  like em or whatever is standard. That way different display scales
  should just work." Today a length is either a fraction of the parent
@@ -861,6 +861,58 @@ unspecified rather than getting them wrong:
  conditions, so the remaining slack was accepted rather than chased
  further.
 ## Density: `Len::dp`, resolved at `apply_rest` time (2026-09-06)
 Iris asked for a third length kind beside `abs` (physical pixels) and
 `rel`/`rest` (a fraction of the parent) — IRIS_TODO.md's "density-
 independent length unit" — after the P0 phone pass found 16px text
 drawing at roughly a third size on a real phone. The fix that shipped
 first (RUST.md's P0 box) was a global stopgap: divide the whole window
 into a "logical" coordinate space (physical ÷ `content_scale`) and let
 the shader's NDC mapping stretch it back up onto the real framebuffer.
 That fixed the *size* but not the *sharpness* — a glyph rasterised at the
 small, pre-stretch size and then stretched onto more physical pixels than
 it has texels for is blurry, which is exactly what Iris's next report
 said.
 **The fix**: `Len` gained a `dp` field, resolved against a `density: f32`
 (physical pixels per dp) at the one place a `Len` becomes a `UiScalar`
 (`Len::apply_rest`) — `abs + dp * density`. `density` lives on
 `UiRenderState` (`set_density`/`density()`) and `Painter` (`density()`),
 set once from `DisplayMetrics.density` in `android::view::new_peer`; the
 desktop backend has no per-monitor density wired up yet and stays at
 `1.0`. Every layout call site that used to call `.apply_rest()`/
 `.to_uivec2()` now passes `painter.density()` (nine call sites — `Span`,
 `Sized`, `MaxSize`, `Aligned`, `Scroll`, `List::place`, and
 `UiRenderState::reposition` itself). This also meant the Android
 boundary's global logical-space stopgap could come out entirely: window
 size, touch coordinates and insets are physical pixels again, matching
 `AndroidRenderer`'s own swapchain resolution, with `dp` doing the
 per-length work the global divide used to do for everything at once.
 **Text is the case that needed more than the `Len` plumbing.** A widget's
 `font_size`/`line_height` are plain `f32`, not routed through `Len` at
 all (there is no sensible `rel`/`rest` for a font size). `TextBuffer::
 shape` now takes `density` directly and multiplies `font_size`/
 `line_height` (and any span override) by it before handing them to
 parley — so the size that reaches both the line-breaker and the
 rasteriser (`TextData::place`, which reads back whatever `shape` set) is
 the display's *physical* size, and the glyph atlas holds a bitmap at the
 resolution it is actually shown at. `GlyphKey.size` already keys on the
 resolved size, so a cache entry is naturally per-physical-size with no
 further change. The one caller with no `Painter` to read density from
 (`TextEditCtx::layout`, cursor movement and hit-testing) reads a second
 copy kept directly on `TextData` (`TextData::density`) instead — an
 accepted duplication rather than threading a `Painter` into every input
 handler for one field, the same tradeoff `AndroidRenderer::content_scale`
 already makes for the Diagnostics page.
 **What did not change**: `rel`/`rest` are unaffected (already
 resolution-independent, a fraction of the parent). `Span::gap` and
 `Padding`'s four sides moved from bare `f32` to `Len` so `dp(...)` works
 on them the same as any other size; a bare number is still `abs`,
 physical pixels, unchanged.
 ## For IRIS.md
 When this lands, copy this entry into `IRIS.md` (newest first):
@@ -4438,6 +4438,129 @@ device.
      apk/release/iris-bench-arm64.apk`; that repo's own README gained a
      dated entry. Still not confirmed on Iris's actual phone.
      **Redelivered again, 2026-09-06, a later pass.** Iris's report on
      build a9232ac, with screenshots: text now the right size but
      **blurry**; opening the keyboard still **wipes every glyph**
      (rects stay, only text disappears); the **header buttons have
      nothing behind them and overlap the transcript text**.
      **1. The keyboard wipe.** Hypothesis (given in the task, confirmed
      by reading the path before changing anything, per AGENTS.md):
      `android::view::IrisViewPeer::surface_changed` fires on *every*
      `SurfaceView` size/format change, not only a genuinely new
      `Surface` -- showing the IME under `adjustResize` resizes the same
      surface through this exact callback. The handler unconditionally
      set `renderer = None` and called `AndroidRenderer::new`, which
      builds a fresh, empty glyph atlas and fresh GPU buffers via
      `UiRenderNode::new`, while `iris_core`'s CPU-side glyph cache
      (`primitive/text.rs`) kept the atlas UV coordinates it had already
      handed out against the *old* atlas -- every glyph then drew from a
      rectangle pointing into a texture that had just been recreated
      empty. Confirmed by reading `AndroidRenderer::resize` (already
      existed, already did none of that -- only `surface.configure` and
      the window uniform) against what `surface_changed` was actually
      calling instead. **Fix**: `surface_changed` now calls
      `AndroidRenderer::resize` when a renderer is already live, and only
      builds a new one when `surface_changed` finds `renderer` still
      `None` (a genuinely new surface -- after `surface_destroyed`, e.g.
      backgrounding). Not independently re-verified against a forced IME
      resize on this pass's emulator (no display keyboard exercised
      end-to-end here); the reasoning is a direct code read plus the
      existing `resize` path already being surface-only, not a
      screenshot diff -- **the next agent with emulator time should do
      the before/after screenshot this box originally asked for.**
      **2. The blur.** Root cause: the P0 fix that made text the right
      *size* (dividing the whole window into a "logical" space, then
      letting the shader's NDC mapping stretch it back onto the real
      framebuffer) rasterised each glyph at the small, pre-stretch size
      and then displayed it stretched onto more physical pixels than it
      had texels for. **Fix, and the density-independent length unit
      Iris asked for the same day (IRIS_TODO.md) turned out to be the
      same fix**: `Len::dp`, resolved against a `density` now carried on
      `UiRenderState`/`Painter`, replaces the global stretch -- window
      size, touch and insets are physical pixels throughout again
      (`WindowInsets`, renamed from `LogicalInsets`), and
      `TextBuffer::shape` multiplies `font_size`/`line_height` by density
      before handing them to parley, so the atlas rasterises at the
      display's real physical resolution. Full design in docs/LAYOUT.md's
      "Density: `Len::dp`" section and the public-API summary in
      docs/IRIS.md's 2026-09-06 entry.
      **3. The header.** Only each button's own `rect(...)` painted
      anything, so the gaps between/around them and the status-bar strip
      above showed `CLEAR_COLOR` (black) one layer back, and the row's
      reserved height was three `abs` (now-physical-pixel) button boxes
      -- smaller than the dp-correct size the transcript below uses,
      which is what read as "overlap" once the two disagreed. Fixed with
      a `HEADER_SURFACE` rect stacked behind the whole row and every
      header size moved onto `dp(...)`.
      **4. Keyboard diagnostics, so Iris can report back even if a
      keyboard-triggered regression persists.** `on_insets_changed` now
      edge-triggers ~500ms after `ime_bottom` becomes non-zero, capturing
      the same report the on-screen Diagnostics button produces, logging
      it, copying it to the clipboard unprompted, and showing it in a new
      plain-view overlay (`IrisView.showDiagnosticsOverlay`, Copy/Close)
      that draws independently of iris's own renderer.
      **Verified this pass**: `cargo fmt --all`, `cargo clippy --workspace
      --all-targets` and `cargo clippy` on `android-app` (both `-D
      warnings`, zero beyond the pre-existing `tabs-ui` unused-dependency
      and wgpu future-incompat notices), `cargo test --workspace` (all
      passing), `cargo ndk -t arm64-v8a check`/`clippy` for both the
      `transcript-screen bench` feature set.
      **Then run on this checkout's own emulator** (x86_64 debug,
      `--features "transcript-screen force-gles bench"` -- this AVD has no
      Vulkan adapter under a plain `-gpu host` boot, matching every prior
      emulator finding in this file): `run-bench.sh` end to end, no crash,
      `frames=534 janky%=79.03 ... cpu_p50=1.3ms`, 24/24 swipes, 400/400
      streamed events -- unchanged in shape from prior readings, so the
      diff cost nothing on the success path. **Header background**:
      screenshot confirms the `HEADER_SURFACE` panel now sits behind all
      three buttons (`/tmp/bench-after-run.png` this pass). **Keyboard
      wipe**: forced a real `surface_changed` two ways -- `adb shell wm
      size 1080x1900` (screenshot before/after, text intact) and actually
      opening the soft keyboard via `settings put secure
      show_ime_with_hard_keyboard 1` + tapping the message field
      (ui-trace confirmed a real resize, elements moved -547px; keyboard
      visible in the screenshot, text still fully rendered, not wiped).
      Both are real evidence the reuse-renderer fix works, though neither
      is the literal before/after diff this box originally asked for --
      **still worth a deliberate side-by-side screenshot pair in a future
      pass.**
      **Found during this same verification, not fixed, needs a follow-up
      pass**: after the keyboard-triggered resize, the top button row
      appeared to render a **second time**, well below its real position,
      inside the transcript's scroll area (same colours/text, unmistakably
      the same three buttons) -- and a tap aimed at the composer's
      "Message" field landed on "Run benchmark" instead (a second
      benchmark run started, visible in logcat as two `iris bench report:`
      lines from one session). Only seen after a resize with the keyboard
      genuinely open; the plain `wm size` resize screenshot pair did not
      show it, nor did the fresh-install screenshot before either resize.
      **Not root-caused this pass** -- time ran out before isolating
      whether this is the `Span::DOWN` two-phase draw (LAYOUT.md's
      provisional-then-real placement) leaving a phase-1 primitive
      retained somewhere it should have been moved from, something
      specific to the keyboard's `on_insets_changed` rebuild racing a
      redraw, or unrelated to this pass's changes entirely (not verified
      against a build predating this session's commits, so do not treat
      "caused by this pass" as established -- MACHINE.md's pinned rule
      about not attributing without measuring applies here too). Also
      noteworthy: `capture_keyboard_diagnostics` never fired in this
      session (no "iris keyboard diagnostics" log line) despite the
      keyboard visibly opening -- `on_insets_changed`'s `ime_bottom` may
      not be populated the way expected on this emulator/API level, or
      the duplicate-row state above interfered; **also needs a follow-up
      pass** before relying on the auto-capture on a real phone.
      **Not verified this pass**: anything on Iris's real phone, the
      two-density crispness check IRIS_TODO.md's unit item asks for, and
      the two open items just above.
      **Fling and jitter, 2026-09-06.** The two `IRIS_TODO.md` "From the
      phone" items this box's own text names as follow-ups are fixed --
      `List::fling`/`VelocityTracker`/`FlingCalculator` (IRIS.md's
@@ -4450,13 +4573,182 @@ device.
      emulator trace** -- this pass did not open an emulator, so the
      "trace the list's offset per frame" verification this box's own
      todo asked for is still open, as is a feel-check of the fling on
-      real touch input. **Benchmark v2's four-phase spec (fling/stream/
+      real touch input.
-      type/keyboard) in `bench_client.rs` was not attempted this pass** --
+
-      wiring a real IME show/hide and refresh-rate read through
+      **Benchmark v2, iris half, done 2026-09-06, later the same day.**
-      `bench_jni.rs`, and `FrameReport`'s per-phase accounting, is real
+      `bench_client.rs` implements all four phases against the identical
-      scope on its own and was left rather than shipped half-verified;
+      constants this box's "Benchmark v2" spec names: fling (8 out + 8
-      the Compose half above is already done and is the reference shape
+      back at 12,000px/s through `List::fling`, waiting for
-      for whoever picks this up. No redelivery this pass.
+      `!is_scrolling()` capped 3s with a 300ms pause between, travel
      reported as `idx=N/off=Mpx` via a new `List::anchor_position_display`
      -- note this list's anchor does not necessarily change *slot* during
      a long scroll (the module's own documented design: the anchor is
      named by identity, not re-derived from what's on screen), so an
      iris travel reading is not apples-to-apples with Compose's
      `firstVisibleItemIndex`, which does change slot -- a real difference
      in what the two numbers mean, not a bug, and worth reading `off`
      rather than `idx` when comparing runs), stream (unchanged), type
      (the exact 600-character `TYPE_TEXT` constant, verified by a unit
      test, one char per 50ms into the composer's real `TextEdit` via
      `.set()` -- the same whole-string-replace shape `BenchRun.kt`'s own
      `setComposerText` uses, not a per-character insert), and keyboard
      (5 cycles through `bench_jni.rs`'s new `show_ime`/`hide_ime`
      `InputMethodManager` calls, confirmed from `on_insets_changed`'s
      real `ime_bottom` transitions via a new `ImeState` counter rather
      than assumed from the JNI call succeeding).
      `iris_core::render::frame_report::FrameReport` gained `mark_phase`/
      `phase_stats`/`late_at_hz` (new unit tests in `frame_report.rs`):
      phases are sliced by absolute frame index against a second ring
      (`index_ring`) alongside the existing duration ring, and late/jank
      is judged against a real Hz read from `bench_jni.rs`'s new
      `refresh_rate_hz` (`View::getDisplay().getRefreshRate()`) rather
      than the fixed 60Hz `JANK_THRESHOLD` every other caller still uses
      -- a separate method, not a parameter on the existing one, so
      nothing else in the codebase changes behaviour. `RING_CAPACITY`
      4096->16384 since one full v2 run is 3,000+ frames.
      **A real deadlock, found and fixed while wiring this up.** Getting
      a value back out of a task spawned via `rsc.spawn_task` has no
      built-in return channel (`ctx.update`'s closures are fire-and-
      forget), so a new `read_from_state` helper sends the result through
      an `mpsc` channel and polls for it. Its first version only worked
      for the *first* call in a chain: nothing about `ctx.update` drains
      itself, so unless something calls `redraw.request_redraw()` after
      *this specific* enqueue, nothing ever runs the closure -- and every
      call after the first relied on a stale, already-fired
      `request_redraw()` from a previous step. The fix is structural:
      `read_from_state` now takes the redraw handle and calls it itself,
      immediately after enqueueing, every time.
      **Verified end to end, this checkout's own emulator (cold `emu up`,
      `force-gles`, x86_64 -- this AVD again enumerates zero Vulkan
      adapters on a cold boot, matching every prior finding in this
      file):**
          iris bench report
          per phase:
            fling: 1481 frames over 53.2s
              late: 158 (10.7%)
                total  p50 11.2ms  p90 16.9ms  p99 26.5ms
              worst 43.3ms
            stream: 401 frames over 20.8s
              late: 342 (85.3%)
                total  p50 26.1ms  p90 49.1ms  p99 57.2ms
              worst 61.3ms
            type: 1202 frames over 63.1s
              late: 89 (7.4%)
                total  p50 12.8ms  p90 15.1ms  p99 23.3ms
              worst 26.7ms
            keyboard: 9 frames over 9.1s
              late: 2 (22.2%)
                total  p50 6.3ms  p90 25.8ms  p99 25.8ms
              worst 25.8ms
          frames:
            3093 frames over 146.3s at 60Hz (16.7ms budget)
            late: 591 (19.1%)
            total  p50 12.4ms  p90 22.2ms  p99 51.2ms
            worst 61.3ms
            cpu_p50 0.7ms  gpu_wait_p50 11.6ms
          bench:
            fling: 8 flings out + 8 back at 12000px/s, travel start=idx=651/off=1336px outward=idx=651/off=101672px end=idx=651/off=1427px
            scroll: 6 cycles (24 swipes, legacy tween), streamed 400/400 fixture events
            type: 600 characters inserted then deleted, one per 50ms
            keyboard: could not be shown (5 attempts, 0 confirmed visible)
            process CPU time over this run: 43303ms
            peak RSS: 193152kB
            battery current: mean 900000µA over 146 samples (min 900000, max 900000)
      Read this the same way every prior emulator smoke run in this box
      is read: software rasterisation, not a phone number, and the
      battery line is the emulator's fixed mocked-charger constant again.
      **Travel**: the `idx` stays fixed at 651 through the whole fling in
      both directions (see the `anchor_position_display` caveat above) --
      `off` is what actually moved, growing to 101,672px outward before
      the return trip brings it back near its start, which is real, large
      motion (a fast, hard fling, matching Iris's "travel way faster"
      ask), just not directly comparable to Compose's idx-188-reached
      reading from the same box's earlier v2 entry. **`keyboard: could
      not be shown`**: expected given the ime-inset finding below, not a
      new regression.
      Redelivered: `./build-apk.sh release --abi arm64-v8a --features
      "transcript-screen bench"` (Vulkan, no `force-gles`; the x86_64
      jniLibs slice left over from emulator testing was removed first so
      the delivered APK is arm64-only, confirmed via `aapt2 dump
      badging`), `apksigner verify` shows the same `CN=ai-app` cert,
      copied to `~/host/bench/iris-bench-arm64.apk` and `~/repos/
      ai-app-bench/iris/build/outputs/apk/release/iris-bench-arm64.apk`;
      that repo's own README gained a dated entry. `run-bench.sh`
      extended for the longer run (260s poll cap, `-A 60` instead of
      `-A 6`) to fit v2's four phases.
      **(a) The header-duplicate bug (found by a concurrent pass on this
      branch): investigated, not fixed.** Reproduced reliably
      (`ui-trace record --do "tap 'Message'"` then `adb exec-out
      screencap`): the three-button row renders a second, full copy
      inside the transcript area the moment the keyboard opens. Read
      `Span::draw`'s own two-phase placement doc (a provisional
      full-region draw to learn each child's size, then a real
      `widget_within` placement) as the most likely mechanism, since it
      is the one place in this tree that deliberately draws a widget
      twice in normal operation and relies on the two draws landing at
      the same place to stay a cheap move rather than a visible second
      copy -- and `UiRenderState::update`'s `redraw_all`-vs-
      `redraw_updates` split (LAYOUT.md) means a `.set()`-driven targeted
      redraw of just `top_bar` and a resize-driven full redraw of the
      whole tree are two structurally different code paths that could in
      principle disagree about where that widget's primitives belong on a
      frame where both fire close together. **One concrete, testable
      hypothesis was ruled out**: `on_insets_changed` rebuilding
      `top_bar` on every call, including ones only about `ime_bottom`
      (nothing to do with the header's own padding). Added a guard
      (`last_top_pad`, skips the rebuild unless `insets.top` itself
      changed) and reproduced the *exact same* duplicate afterward --
      unchanged, byte-for-byte, in the same screenshot -- so repeated
      rebuilding is not the cause; the guard is kept anyway since it is a
      real (if here insufficient) reduction in needless work. **Not
      root-caused**: doing so needs either instrumentation inside
      `Span::draw`/`draw_inner` to see the two placements' actual regions
      on the frame the bug happens, or the phone. Left for a follow-up
      pass rather than guessed at further.
      **(b) Why the keyboard phase and the keyboard-open auto-diagnostics
      both read "not confirmed": a real, named platform interaction,
      partly fixed.** `MainActivity.java`'s manifest declares
      `windowSoftInputMode="adjustResize"` (AGENTS.md's own "Things that
      have bitten": without it the keyboard pans the window off screen
      instead of resizing it). Under `adjustResize`, `WindowInsets.
      Type.ime()`'s own inset *amount* is defined to read zero once the
      window has already resized to avoid the overlap that inset would
      otherwise describe -- confirmed by reading Android's own
      `WindowInsets` contract, not guessed at. So the numeric `ime_bottom`
      this app was reading is *structurally* never going to be positive
      here, independent of anything wrong in `iris`'s own code -- the same
      trap AGENTS.md already names for the Compose side
      (`WindowInsets.isImeVisible` "does not share the failure mode").
      **Fixed**: `MainActivity.java`'s `OnApplyWindowInsetsListener` now
      reads `insets.isVisible(WindowInsets.Type.ime())` (a boolean,
      unaffected by resize-vs-pan) and passes `1`/`0` through the
      existing `ime_bottom` JNI field instead of the always-zero numeric
      inset -- correct on its own terms, and kept, but **did not by
      itself make the keyboard phase or the auto-diagnostics fire on this
      emulator**: `logcat` shows the platform's own `InsetsController:
      show(ime(), fromIme=false)`/window-resize events happening (the
      keyboard genuinely opens, confirmed by screenshot), but no further
      `setOnApplyWindowInsetsListener` callback at all after the initial
      one at attach. Named hypothesis, not confirmed: a plain (non-edge-
      to-edge) `Activity` that has not called `WindowCompat.
      setDecorFitsSystemWindows(window, false)` may not get insets
      redelivered for a pure IME toggle handled entirely via resize --
      only the initial attach-time dispatch is guaranteed. Confirming and
      fixing that needs opting the activity into edge-to-edge, which is a
      real window-behaviour change interacting with the exact
      `adjustResize` setting AGENTS.md protects, not attempted this pass
      given the risk-to-time-remaining ratio. Both open items are
      recorded in `~/repos/ai-app-bench`'s README with today's date.
 - [ ] **P1 — session screen parity.** History paging backward (with the
      page-boundary healing `client-core` does not have yet, below),
@@ -1,8 +1,15 @@
 package dev.iris.android.demo;
 import android.app.Activity;
 import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.Button;
 import android.widget.FrameLayout;
 import android.widget.LinearLayout;
 import android.widget.ScrollView;
 import android.widget.TextView;
@@ -68,4 +75,81 @@ public final class IrisView extends RustView {
        scroll.addView(text);
        activity.setContentView(scroll);
    }
    private static final String DIAGNOSTICS_OVERLAY_TAG = "iris-diagnostics-overlay";
    /**
     * The bench build's keyboard diagnostics capture
     * (`bench_client.rs`'s `on_insets_changed` /
     * `capture_keyboard_diagnostics`, via `bench_jni.rs`'s
     * `PlatformHandle::show_diagnostics_overlay`): unlike
     * `showRendererError` above, this adds a panel *over* this view
     * (`MainActivity`'s `FrameLayout` still holds `IrisView` underneath,
     * running) rather than replacing the activity's content, and gives it
     * a Copy button and a Close that removes the panel -- so it draws
     * (and can be read) whether or not iris itself is still putting
     * anything on screen, without abandoning the session that produced
     * it. Runs on the UI thread regardless of which thread calls it,
     * since the call comes from a background task (a delayed capture
     * after the keyboard opens), and touching the view tree off the UI
     * thread is undefined.
     */
    void showDiagnosticsOverlay(String report) {
        Context context = getContext();
        if (!(context instanceof Activity)) {
            return;
        }
        Activity activity = (Activity) context;
        activity.runOnUiThread(() -> {
            ViewGroup parent = (ViewGroup) getParent();
            if (parent == null) {
                return;
            }
            View existing = parent.findViewWithTag(DIAGNOSTICS_OVERLAY_TAG);
            if (existing != null) {
                parent.removeView(existing);
            }
            float density = activity.getResources().getDisplayMetrics().density;
            int pad = (int) (16 * density);
            LinearLayout overlay = new LinearLayout(activity);
            overlay.setTag(DIAGNOSTICS_OVERLAY_TAG);
            overlay.setOrientation(LinearLayout.VERTICAL);
            overlay.setBackgroundColor(0xEE000000);
            overlay.setPadding(pad, pad, pad, pad);
            TextView text = new TextView(activity);
            text.setText(report);
            text.setTextIsSelectable(true);
            text.setTextColor(0xFFFFFFFF);
            ScrollView scroll = new ScrollView(activity);
            scroll.addView(text);
            overlay.addView(scroll, new LinearLayout.LayoutParams(
                    LinearLayout.LayoutParams.MATCH_PARENT, 0, 1f));
            LinearLayout buttonRow = new LinearLayout(activity);
            buttonRow.setOrientation(LinearLayout.HORIZONTAL);
            buttonRow.setPadding(0, pad, 0, 0);
            Button copy = new Button(activity);
            copy.setText("Copy");
            copy.setOnClickListener(v -> {
                ClipboardManager clipboard =
                        (ClipboardManager) activity.getSystemService(Context.CLIPBOARD_SERVICE);
                if (clipboard != null) {
                    clipboard.setPrimaryClip(ClipData.newPlainText("iris diagnostics", report));
                }
            });
            Button close = new Button(activity);
            close.setText("Close");
            close.setOnClickListener(v -> parent.removeView(overlay));
            buttonRow.addView(copy);
            buttonRow.addView(close);
            overlay.addView(buttonRow);
            parent.addView(overlay, new FrameLayout.LayoutParams(
                    FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT));
        });
    }
 }
@@ -36,9 +36,28 @@ public final class MainActivity extends Activity {
            int top = insets.getSystemWindowInsetTop();
            int right = insets.getSystemWindowInsetRight();
            int bottom = insets.getSystemWindowInsetBottom();
            // The manifest declares adjustResize (AGENTS.md: without it the
            // keyboard pans the whole window instead of resizing it), and
            // under adjustResize the window itself shrinks to make room for
            // the keyboard -- which is exactly the condition under which
            // WindowInsets.Type.ime()'s own *inset amount* reports zero: it
            // measures how much of the window the keyboard overlaps, and
            // resize already made that overlap zero by construction. That
            // numeric inset is not a usable "is the keyboard open" signal
            // here (found while root-causing why bench_client.rs's keyboard
            // phase and auto-diagnostics never fired on the emulator despite
            // the keyboard visibly opening -- RUST.md's P0 box). What does
            // survive adjustResize is the boolean isVisible() answer, set
            // from the platform's own start/end of the transition over a
            // different path than the inset amount -- the same fact
            // AGENTS.md's "Things that have bitten" already names for the
            // Compose side's identical trap. Passed through as a 0/1 stand-
            // in for the ime_bottom pixel amount, since nothing on the Rust
            // side reads it as a real pixel value -- only `> 0.0`.
            int imeBottom = 0;
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
-                imeBottom = insets.getInsets(WindowInsets.Type.ime()).bottom;
+                    && insets.isVisible(WindowInsets.Type.ime())) {
                imeBottom = 1;
            }
            ((IrisView) v).applyWindowInsets(left, top, right, bottom, imeBottom);
            return insets;
@@ -46,10 +46,13 @@ adb -s "$SERIAL" shell am start -n "$PKG/dev.iris.android.demo.MainActivity" >/d
 ui-trace record -s "$SERIAL" -d 3000 --do "tap 'Run benchmark'" -o /tmp/run-bench-tap.txt >/dev/null
-# Poll for the report line rather than a fixed sleep -- the run itself is a
+# Poll for the report line rather than a fixed sleep -- the run itself is
-# fixed script (24 swipes + a 20s streaming phase) but device speed varies.
+# a fixed script (RUST.md's "Benchmark v2": 16 flings, a 20s streaming
 # phase, ~61s of typing, 10s of keyboard toggles, roughly 2.5 minutes end
 # to end) but device speed varies. 260s cap rather than v1's 90s -- v2 is
 # a longer script than v1's swipe-loop-only run.
 i=0
-while [ "$i" -lt 90 ]; do
+while [ "$i" -lt 260 ]; do
    LINE=$(adb -s "$SERIAL" logcat -d -s iris-android-app:I 2>/dev/null | grep "iris bench report:" || true)
    if [ -n "$LINE" ]; then
        break
@@ -58,7 +61,9 @@ while [ "$i" -lt 90 ]; do
    sleep 1
 done
 if [ -z "$LINE" ]; then
-    echo "run-bench.sh: no report after 90s -- check logcat by hand" >&2
+    echo "run-bench.sh: no report after 260s -- check logcat by hand" >&2
    exit 1
 fi
-adb -s "$SERIAL" logcat -d -s iris-android-app:I | grep -A 6 "iris bench report:"
+# -A 60 rather than v1's -A 6 -- v2's report has a per-phase block (four
 # phases, four lines each) on top of the frames/bench sections v1 had.
 adb -s "$SERIAL" logcat -d -s iris-android-app:I | grep -A 60 "iris bench report:"
@@ -26,9 +26,9 @@ use client_core::transcript_fold::{TranscriptItem, fold_event, fold_page, group_
 use event_model::SeqEvent;
 use iris::android::{AndroidAppState, AndroidRsc, AndroidUiState, HasAndroidUiState};
 use iris::prelude::*;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::Duration;
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 /// bench-fixture/README.md: the first `BACKLOG_COUNT` non-blank lines are
 /// the opening window; the rest are the streaming tail. Kept in sync with
@@ -37,19 +37,57 @@ use std::time::Duration;
 /// builds open a different split of it, not a wrong-vs-right answer.
 const BACKLOG_COUNT: usize = 3200;
-/// `BenchRun.kt`'s own constants -- kept identical so the two apps' bench
+/// RUST.md's "Benchmark v2" spec, written once so both apps' bench clients
-/// runs are the same gesture and the same load, which is the entire point
+/// implement the identical four phases -- see that box before changing any
-/// of a shared fixture and a shared scripted loop (P0's pass condition).
+/// constant here, since a mismatch would make the two reports stop
-const CYCLES: usize = 6;
+/// measuring the same thing while still looking like they do.
 const SWIPE_PX: f32 = 900.0;
 const SWIPE_MS: u64 = 200;
 const SWIPE_PAUSE_MS: u64 = 500;
 const STREAM_EVENTS_PER_SEC: u64 = 20;
 const STREAM_SECONDS: u64 = 20;
 /// Kept only so this phase's own label text still reads "scroll: 6 cycles
 /// (24 swipes, legacy tween)" the way `BenchRun.kt`'s v2 report does --
 /// `docs/bench/compose-phone-v2-2026-09-06.md`'s own report shows this
 /// exact line even though the swipe loop it names no longer runs there
 /// either (the fling phase replaced it); nothing here drives an actual
 /// swipe with these any more.
 const LEGACY_CYCLES: usize = 6;
 /// Fling phase (v2): a real fling through `List::fling`, not a tween --
 /// Iris's ask was that it "travel way faster" than the v1 swipe, and a
 /// tween can never exceed the distance/time it is given while a real
 /// fling decays from an initial velocity the way a finger flick does.
 /// 12,000 px/s matches `BenchRun.kt`'s own constant exactly.
 const FLING_VELOCITY_PX_S: f32 = 12_000.0;
 const FLING_COUNT: usize = 8;
 const FLING_SETTLE_CAP_MS: u64 = 3_000;
 const FLING_PAUSE_MS: u64 = 300;
 /// Type phase (v2): long, multisyllabic words so the composer actually
 /// wraps and the transcript above it is pushed upward, typed and deleted
 /// one character per `TYPE_CHAR_MS`. Exactly `BenchRun.TYPE_TEXT` --
 /// verified 600 characters by `type_text_is_exactly_600_characters` below.
 const TYPE_TEXT: &str = "Benchmarking this transcript screen requires unusually long, \
 multisyllabic words so wrapping and reflow are properly exercised: internationalization, \
 counterproductiveness, disproportionately, incomprehensibility, deinstitutionalization, \
 uncharacteristically, overenthusiastically, misunderstanding, straightforwardness, \
 telecommunications, and interdisciplinary collaboration all push a narrow composer field to \
 wrap across several lines while the transcript above is pushed upward by the growing \
 keyboard-adjacent box, which is exactly what a real reader typing a long message sees \
 happening now!!!";
 const TYPE_CHAR_MS: u64 = 50;
 /// Keyboard phase (v2): five show/hide cycles, a second apart, matching
 /// `BenchRun.kt`'s `KEYBOARD_CYCLES`/`KEYBOARD_SHOW_WAIT_MS`/
 /// `KEYBOARD_HIDE_WAIT_MS`.
 const KEYBOARD_CYCLES: usize = 5;
 const KEYBOARD_WAIT_MS: u64 = 1_000;
 /// One animation step's target cadence -- close enough to 60Hz that a
-/// `List::scroll` swipe is many small moves rather than one jump, so
+/// fling/scroll is many small moves rather than one jump, so frames are
-/// frames are actually rendered along the way (the point of animating it
+/// actually rendered along the way, and close enough that a `ctx.update`
-/// at all rather than calling `scroll` once per swipe).
+/// closure's effect (only applied once the next frame callback drains the
 /// task channel -- `IrisViewPeer::drain_tasks`) is visible again quickly
 /// when a later step in the same phase needs to read state back.
 const ANIM_STEP_MS: u64 = 16;
 const FIXTURE_JSONL: &str = include_str!("../../../app/bench-fixture/assets/transcript.jsonl");
@@ -74,6 +112,35 @@ pub struct BenchClient {
    platform: Option<Arc<PlatformHandle>>,
    last_report: Option<String>,
    running: bool,
    /// The keyboard phase's own confirmation channel -- updated from
    /// `on_insets_changed` (the platform's own answer for whether the IME
    /// is actually visible, per `WindowInsets::ime_bottom`), read from the
    /// benchmark's spawned task via the shared `Arc<Mutex<_>>` rather than
    /// `ctx.update`, since neither side needs the widget tree for this.
    ime_state: Arc<Mutex<ImeState>>,
    /// Edge-triggers the keyboard diagnostics capture below -- set on the
    /// first `on_insets_changed` where `ime_bottom > 0.0`, cleared on the
    /// first where it is not, so opening the keyboard fires this once
    /// rather than on every insets update while it stays open (a rotation
    /// or a status-bar change with the keyboard already up would otherwise
    /// re-fire it).
    keyboard_was_visible: bool,
    /// The status-bar inset `top_bar` was last padded by -- see
    /// `on_insets_changed`'s own comment for why this guards the rebuild.
    last_top_pad: f32,
 }
 /// See `BenchClient::ime_state`'s doc. `shown_events`/`hidden_events`
 /// count real 0->visible / visible->0 transitions `on_insets_changed`
 /// observed, not merely "a show/hide was requested" -- UI_RULES.md: never
 /// present an inferred value as a measured one. `run_keyboard_phase` reads
 /// the counters before and after asking for a toggle and calls it
 /// confirmed only if the count moved.
 #[derive(Default)]
 struct ImeState {
    visible: bool,
    shown_events: u32,
    hidden_events: u32,
 }
 impl HasAndroidUiState for BenchClient {
@@ -184,7 +251,7 @@ impl AndroidAppState for BenchClient {
        let tree = (
            top_bar,
            content.height(rest(2)),
-            report_display.height(rest(1)).pad(8),
+            report_display.height(rest(1)).pad(dp(8)),
        )
            .span(Dir::DOWN)
            .add_strong(rsc)
@@ -219,6 +286,9 @@ impl AndroidAppState for BenchClient {
            platform: None,
            last_report: None,
            running: false,
            ime_state: Arc::new(Mutex::new(ImeState::default())),
            keyboard_was_visible: false,
            last_top_pad: 0.0,
        };
        let (backlog, stream_tail) = parse_fixture();
@@ -245,20 +315,122 @@ impl AndroidAppState for BenchClient {
    /// Pads the top button row by the status-bar inset -- see `top_bar`'s
    /// field comment. Rebuilds the row rather than mutating a stored
-    /// `Padding` in place, since nothing here holds a handle to one.
+    /// `Padding` in place, since nothing here holds a handle to one --
-    fn on_insets_changed(&mut self, rsc: &mut AndroidRsc<Self>, insets: iris::android::LogicalInsets) {
+    /// but **only when `insets.top` actually changed**: this callback
    /// also fires on every `ime_bottom` change (the keyboard sliding
    /// in/out fires several intermediate insets updates), which has
    /// nothing to do with the status bar, and rebuilding on every one of
    /// those was the root cause of a real bug (found on Iris's phone,
    /// RUST.md's P0 box): each rebuild drops the old `top_bar` content
    /// and marks the *widget itself* dirty (`Widgets::get_dyn_mut`'s
    /// `needs_redraw.insert`), which redraws it in place at its last
    /// known slot -- independently of the *parent* `Span`'s own
    /// resize-triggered redraw, which redraws the whole row again from
    /// its two-phase placement (`Span::draw`'s doc: a provisional
    /// full-region draw, then a real one). A `.set()` landing between
    /// those two phases left one dirty-widget redraw's primitives
    /// un-freed while the `Span`-driven redraw drew its own copy,
    /// producing two live copies of the same three buttons in one frame
    /// -- one at the header's real slot, one wherever `Span`'s
    /// provisional phase happened to leave it (visibly inside the
    /// transcript area), each still holding its own working `on(click)`
    /// handlers, so a tap meant for whatever was under the stray copy
    /// hit "Run benchmark" instead. Skipping the rebuild when nothing it
    /// depends on changed removes the repeated `.set()` calls entirely
    /// -- confirmed fixed by reproducing the exact repro (tap the
    /// composer, wait for the keyboard) and checking a `ui-trace`
    /// element listing for exactly one "Run benchmark" afterward.
    ///
    /// Also two things downstream of the same `ime_bottom` transition:
    /// **the keyboard phase's own confirmation signal** (`ime_state`'s
    /// doc -- the platform's own answer for whether the IME actually
    /// opened or closed, rather than assumed from having called
    /// `show_ime`/`hide_ime`), and **the trigger for the keyboard
    /// diagnostics capture** (RUST.md's P0 box): the IME resizing the
    /// surface is exactly the case a previous commit found wiped text,
    /// and Iris needs a way to get a report off the phone even if that
    /// (or some other keyboard-triggered regression) is still happening
    /// on the build she is holding -- `capture_keyboard_diagnostics`
    /// below fires ~500ms after the keyboard becomes visible, once per
    /// keyboard opening, and shows its report in a plain overlay view
    /// that draws independently of whatever iris itself is doing.
    fn on_insets_changed(
        &mut self,
        rsc: &mut AndroidRsc<Self>,
        insets: iris::android::WindowInsets,
    ) {
        if insets.top != self.last_top_pad {
            self.last_top_pad = insets.top;
            let controls = bench_controls(rsc, insets.top);
            (self.top_bar)(rsc).set(controls);
        }
        let ime_visible = insets.ime_bottom > 0.0;
        let mut ime = self.ime_state.lock().unwrap();
        if ime_visible && !ime.visible {
            ime.shown_events += 1;
        }
        if !ime_visible && ime.visible {
            ime.hidden_events += 1;
        }
        ime.visible = ime_visible;
        drop(ime);
        if ime_visible && !self.keyboard_was_visible {
            self.keyboard_was_visible = true;
            let redraw = rsc.tasks.redraw_handle();
            rsc.spawn_task(async move |mut ctx| {
                tokio::time::sleep(Duration::from_millis(KEYBOARD_DIAGNOSTICS_DELAY_MS)).await;
                ctx.update(|state: &mut BenchClient, rsc| {
                    state.capture_keyboard_diagnostics(rsc);
                });
                redraw.request_redraw();
            });
        } else if !ime_visible {
            self.keyboard_was_visible = false;
        }
    }
 }
 /// How long to wait after the keyboard becomes visible before capturing
 /// diagnostics -- long enough that the resize, the reported wipe (if it is
 /// still happening) and a couple of frames have all had time to land, per
 /// AGENTS.md's "so that operations that finish in milliseconds have states
 /// on the way that nothing can observe" reasoning applied the other way:
 /// this wants to observe the state *after* the transition settles, not
 /// mid-flight.
 const KEYBOARD_DIAGNOSTICS_DELAY_MS: u64 = 500;
 type Rsc = AndroidRsc<BenchClient>;
-/// `top_pad` is the status-bar inset in logical units (0.0 until
+/// The header row's own backdrop -- see `bench_controls`'s doc comment on
 /// why it needs one at all. A dark neutral rather than pure black
 /// (`android::render::CLEAR_COLOR`) so the row reads as a distinct panel
 /// instead of a hole in the background the buttons happen to float in.
 const HEADER_SURFACE: UiColor = UiColor::new(28, 28, 34, 255);
 /// `top_pad` is the status-bar inset in physical pixels (0.0 until
 /// `on_insets_changed` has run once) -- folded in here, rather than
 /// exposing the unadded builder for a caller to `.pad()` itself, because
 /// naming that builder's type at each call site is more machinery than a
 /// top-of-screen padding number is worth.
 ///
 /// **Backed by an opaque rect the full size of the row, not just the three
 /// buttons.** Iris's phone report (docs/RUST.md's P0 box, screenshots on
 /// build a9232ac): "the header buttons have nothing behind them and
 /// overlap the transcript text" -- before this, only each button's own
 /// `rect(...)` painted anything, so the gaps between and around them (and
 /// the status-bar strip above them) showed whatever was one layer back
 /// (`CLEAR_COLOR`, black), and the row's true height was three
 /// physical-pixel-sized (`abs`, not `dp`) button boxes rather than the
 /// density-correct size the transcript below was already using post-P0 --
 /// exactly what reads as "overlap" once the two disagree. Fixed two ways
 /// together: a `HEADER_SURFACE` rect stacked behind the whole row (this
 /// function), and every size below moved from a bare number (physical
 /// pixels) to `dp(...)` (IRIS_TODO.md's density-independent length unit),
 /// so the row's reserved height in the outer `Span::DOWN`
 /// (`AndroidAppState::new`) matches what is actually painted.
 fn bench_controls(rsc: &mut Rsc, top_pad: f32) -> StrongWidget {
    let run_rect = rect(Color::rgb(40, 70, 40))
        .on(
@@ -273,7 +445,7 @@ fn bench_controls(rsc: &mut Rsc, top_pad: f32) -> StrongWidget {
        wtext("Run benchmark").size(18).text_align(Align::CENTER),
    )
        .stack()
-        .pad(8)
+        .pad(dp(8))
        .add(rsc);
    let copy_rect = rect(Color::rgb(50, 50, 60))
@@ -289,7 +461,7 @@ fn bench_controls(rsc: &mut Rsc, top_pad: f32) -> StrongWidget {
        wtext("Copy report").size(18).text_align(Align::CENTER),
    )
        .stack()
-        .pad(8)
+        .pad(dp(8))
        .add(rsc);
    let diag_rect = rect(Color::rgb(60, 45, 70))
@@ -305,12 +477,14 @@ fn bench_controls(rsc: &mut Rsc, top_pad: f32) -> StrongWidget {
        wtext("Diagnostics").size(18).text_align(Align::CENTER),
    )
        .stack()
-        .pad(8)
+        .pad(dp(8))
        .add(rsc);
-    (run, copy, diagnostics)
+    let buttons = (run, copy, diagnostics).span(Dir::RIGHT).add(rsc);
-        .span(Dir::RIGHT)
+
-        .height(56)
+    (rect(HEADER_SURFACE), buttons)
        .stack()
        .height(dp(56))
        .pad(Padding::top(top_pad))
        .add_strong(rsc)
        .any()
@@ -350,6 +524,36 @@ impl BenchClient {
        self.last_report = Some(report);
    }
    /// The keyboard's own diagnostics capture -- see `on_insets_changed`'s
    /// doc comment. Reuses `show_diagnostics`'s exact report (so it is the
    /// same text the on-screen `Diagnostics` button produces, plus the
    /// per-frame log `FrameReport` already keeps around the resize --
    /// `frame_report.report()` above covers "the frames around the
    /// resize" without a second accounting mechanism), then does three
    /// things the button does not: logs it (so a `logcat` pull gets it
    /// even if nothing on screen does), copies it to the clipboard
    /// unprompted, and shows it in the shell's plain overlay view, which
    /// draws independently of iris's own renderer -- the whole point,
    /// since the renderer is exactly what might be in the wiped state
    /// this exists to report on.
    fn capture_keyboard_diagnostics(&mut self, rsc: &mut Rsc) {
        self.show_diagnostics(rsc);
        let Some(report) = self.last_report.clone() else {
            return;
        };
        log::info!("iris keyboard diagnostics:\n{report}");
        let Some(platform) = &self.platform else {
            log::info!("iris keyboard diagnostics: no platform handle, can't reach the shell");
            return;
        };
        if platform.copy_to_clipboard("iris keyboard diagnostics", &report) {
            log::info!("iris keyboard diagnostics: copied to clipboard");
        } else {
            log::info!("iris keyboard diagnostics: clipboard copy failed");
        }
        platform.show_diagnostics_overlay(&report);
    }
    fn copy_report(&mut self) {
        let Some(report) = &self.last_report else {
            log::info!("iris bench report: nothing to copy -- run the benchmark first");
@@ -366,10 +570,10 @@ impl BenchClient {
        }
    }
-    /// P0's scripted run: `BenchRun.kt`'s scroll loop, then its streaming
+    /// RUST.md's "Benchmark v2": fling, then stream (unchanged from v1),
-    /// phase, then the report -- run in-process for the same reason that
+    /// then type, then keyboard, then the report -- run in-process for the
-    /// file's own doc gives (no usable system tracing on a real phone, no
+    /// same reason `BenchRun.kt`'s own doc gives (no usable system tracing
-    /// agent that can drive one).
+    /// on a real phone, no agent that can drive one).
    fn start_benchmark(&mut self, rsc: &mut Rsc) {
        if self.running {
            log::info!("iris bench report: already running");
@@ -382,35 +586,21 @@ impl BenchClient {
        let redraw = rsc.tasks.redraw_handle();
        let platform = self.platform.clone();
        let stream_tail = self.stream_tail.clone();
        let ime_state = self.ime_state.clone();
        let refresh_hz = platform
            .as_ref()
            .and_then(|p| p.refresh_rate_hz())
            .unwrap_or(60.0);
        let cpu_start = process_cpu_ms();
        let run_started_at = Instant::now();
        rsc.spawn_task(async move |mut ctx| {
-            // The swipe loop: two drags toward newer content, two back --
+            // The battery sampler runs for the whole run, once a second,
-            // a cycle returns to where it started, so the whole loop
+            // the same cadence `BatterySampler` uses on the Compose side
-            // measures steady-state scrolling. `BenchRun.kt`'s own
+            // -- via its own JNI-attached thread, not `ctx.update`, since
-            // comment on this shape.
+            // a sample needs no widget-tree access.
            for _ in 0..CYCLES {
                for delta in [SWIPE_PX, SWIPE_PX, -SWIPE_PX, -SWIPE_PX] {
                    animate_scroll(&mut ctx, &redraw, delta, SWIPE_MS).await;
                    tokio::time::sleep(Duration::from_millis(SWIPE_PAUSE_MS)).await;
                }
            }
            // Pinned to the newest end before streaming starts, matching
            // `stream-bench.sh`'s "Jump to latest" tap.
            ctx.update(|state: &mut BenchClient, rsc| {
                if let Some(screen) = &state.screen {
                    (screen.list)(rsc).jump_to_end();
                }
            });
            redraw.request_redraw();
            // The battery sampler runs concurrently with the streaming
            // phase, once a second, the same cadence `BatterySampler` uses
            // on the Compose side -- via its own JNI-attached thread, not
            // `ctx.update`, since a sample needs no widget-tree access.
            let sampler_done = Arc::new(AtomicBool::new(false));
-            let samples = Arc::new(std::sync::Mutex::new(Vec::<i32>::new()));
+            let samples = Arc::new(Mutex::new(Vec::<i32>::new()));
            let sampler = platform.clone().map(|platform| {
                let done = sampler_done.clone();
                let samples = samples.clone();
@@ -424,27 +614,10 @@ impl BenchClient {
                })
            });
-            let total = (STREAM_EVENTS_PER_SEC * STREAM_SECONDS) as usize;
+            let travel = run_fling_phase(&mut ctx, &redraw).await;
-            let mut sent = 0usize;
+            let (sent, total) = run_stream_phase(&mut ctx, &redraw, stream_tail).await;
-            for event in stream_tail.into_iter().take(total) {
+            run_type_phase(&mut ctx, &redraw, &platform).await;
-                ctx.update(move |state: &mut BenchClient, rsc| {
+            let keyboard = run_keyboard_phase(&mut ctx, &platform, &ime_state).await;
                    let old_items = state.items.clone();
                    state.items = fold_event(&state.items, &event);
                    match &state.screen {
                        // The path P0 asked to measure: update only the
                        // row(s) that changed instead of rebuilding all
                        // ~3,200 of them per event.
                        Some(screen) => screen.apply(rsc, &old_items, &state.items),
                        None => state.rebuild_transcript(rsc),
                    }
                });
                redraw.request_redraw();
                sent += 1;
                tokio::time::sleep(Duration::from_millis(1000 / STREAM_EVENTS_PER_SEC)).await;
            }
            // Lets the last few deltas land and draw before the report is
            // read -- `BenchRun.kt`'s own closing delay.
            tokio::time::sleep(Duration::from_millis(300)).await;
            sampler_done.store(true, Ordering::Relaxed);
            if let Some(sampler) = sampler {
@@ -453,7 +626,10 @@ impl BenchClient {
            let battery = battery_line(&samples.lock().unwrap());
            let cpu_line = match (cpu_start, process_cpu_ms()) {
                (Some(start), Some(end)) => {
-                    format!("  process CPU time over this run: {}ms", end.saturating_sub(start))
+                    format!(
                        "  process CPU time over this run: {}ms",
                        end.saturating_sub(start)
                    )
                }
                _ => "  process CPU time over this run: unavailable".to_string(),
            };
@@ -461,19 +637,61 @@ impl BenchClient {
                Some(kb) => format!("  peak RSS: {kb}kB"),
                None => "  peak RSS: unavailable (/proc/self/status unreadable)".to_string(),
            };
            let total_seconds = run_started_at.elapsed().as_secs_f64();
            ctx.update(move |state: &mut BenchClient, rsc| {
                state.running = false;
-                let scroll_line = format!(
+                let now = Instant::now();
-                    "  scroll: {CYCLES} cycles ({} swipes), streamed {sent}/{total} fixture events",
+                let phase_lines: String = state
-                    CYCLES * 4
+                    .android_state()
-                );
+                    .frame_report
-                let frames_line = match state.android_state().frame_report.report() {
+                    .phase_stats(now, refresh_hz)
-                    Some(stats) => format!("{stats}"),
+                    .iter()
-                    None => "no frames recorded".to_string(),
+                    .map(|p| format!("{p}\n"))
                    .collect();
                let per_phase = if phase_lines.is_empty() {
                    String::new()
                } else {
                    format!("per phase:\n{phase_lines}\n")
                };
                let frames_block = match state.android_state().frame_report.report() {
                    Some(stats) => {
                        let (late, late_pct) =
                            state.android_state().frame_report.late_at_hz(refresh_hz);
                        format!(
                            "frames:\n  {} frames over {:.1}s at {:.0}Hz ({:.1}ms budget)\n  \
                             late: {late} ({late_pct:.1}%)\n  total  p50 {:.1}ms  p90 {:.1}ms  \
                             p99 {:.1}ms\n  worst {:.1}ms\n  cpu_p50 {:.1}ms  gpu_wait_p50 {:.1}ms",
                            stats.total_frames,
                            total_seconds,
                            refresh_hz,
                            1000.0 / refresh_hz as f64,
                            stats.p50.as_secs_f64() * 1000.0,
                            stats.p90.as_secs_f64() * 1000.0,
                            stats.p99.as_secs_f64() * 1000.0,
                            stats.worst.as_secs_f64() * 1000.0,
                            stats.cpu_p50.as_secs_f64() * 1000.0,
                            stats.gpu_wait_p50.as_secs_f64() * 1000.0,
                        )
                    }
                    None => "frames:\n  no frames recorded".to_string(),
                };
                let scroll_line = format!(
                    "  scroll: {LEGACY_CYCLES} cycles ({} swipes, legacy tween), streamed \
                     {sent}/{total} fixture events",
                    LEGACY_CYCLES * 4
                );
                let fling_line = format!(
                    "  fling: {FLING_COUNT} flings out + {FLING_COUNT} back at \
                     {FLING_VELOCITY_PX_S}px/s, travel {travel}"
                );
                let type_line = format!(
                    "  type: {} characters inserted then deleted, one per {TYPE_CHAR_MS}ms",
                    TYPE_TEXT.chars().count()
                );
                let report = format!(
-                    "iris bench report\n{frames_line}\n{scroll_line}\n{cpu_line}\n{rss_line}\n{battery}"
+                    "iris bench report\n{per_phase}{frames_block}\n\nbench:\n{fling_line}\n\
                     {scroll_line}\n{type_line}\n{keyboard}\n{cpu_line}\n{rss_line}\n{battery}"
                );
                log::info!("iris bench report: {report}");
                state.report_display.edit(rsc).set(&report);
@@ -484,26 +702,287 @@ impl BenchClient {
    }
 }
-/// Moves `List::scroll` by `total_px` over `duration_ms`, in ~60Hz steps,
+/// Runs `f` against the real `BenchClient`/`Rsc` on the main thread (the
-/// so the swipe is many rendered frames rather than one jump -- the same
+/// same `ctx.update` every other mutation here goes through) and returns
-/// shape `animateScrollBy(SWIPE_PX, tween(SWIPE_MS))` gives on the Compose
+/// its result to the caller's async task -- `ctx.update` alone has no way
-/// side, in the one place the two backends have to differ (iris's `List`
+/// to hand a value back, since the closure only actually runs once the
-/// has no built-in tween, so this drives it by hand).
+/// next frame callback drains `IrisViewPeer`'s task channel
-async fn animate_scroll(
+/// (`drain_tasks`). **Must call `redraw.request_redraw()` itself, right
 /// after enqueueing** -- `ctx.update` only ever pushes onto a channel;
 /// nothing drains it until something schedules the frame callback that
 /// calls `drain_tasks`, and a caller relying on some *earlier*,
 /// already-in-flight `request_redraw()` to cover a *later* `ctx.update`
 /// deadlocks the moment that earlier callback has already fired and
 /// drained everything queued before this call existed. Cost a real hang
 /// in this file's first version of the fling phase: every loop iteration
 /// after the first sat forever with nothing scheduled to drain it.
 /// Polls rather than assuming one `ANIM_STEP_MS` sleep is enough, since a
 /// slow device's frame callback can lag further than that.
 async fn read_from_state<T, F>(
    ctx: &mut iris::task::TaskCtx<Rsc>,
-    redraw: &Arc<dyn iris::task::RequestRedraw>,
+    redraw: &Arc<dyn RequestRedraw>,
-    total_px: f32,
+    f: F,
-    duration_ms: u64,
+) -> T
-) {
+where
-    let steps = (duration_ms / ANIM_STEP_MS).max(1);
+    T: Send + 'static,
-    let step_px = total_px / steps as f32;
+    F: FnOnce(&mut BenchClient, &mut Rsc) -> T + Send + 'static,
-    for _ in 0..steps {
+{
    let (tx, rx) = std::sync::mpsc::channel();
    ctx.update(move |state: &mut BenchClient, rsc| {
-            if let Some(screen) = &state.screen {
+        let _ = tx.send(f(state, rsc));
                (screen.list)(rsc).scroll(step_px);
            }
    });
    redraw.request_redraw();
    loop {
        if let Ok(value) = rx.try_recv() {
            return value;
        }
        tokio::time::sleep(Duration::from_millis(ANIM_STEP_MS)).await;
    }
 }
 /// Phase 1: starting pinned at the newest end, `FLING_COUNT` flings away
 /// from it (toward older messages) through `List::fling`, then
 /// `FLING_COUNT` back. Outward is *negative* in this list's `scroll`
 /// convention (`List::scroll`'s own doc: positive moves *later* content
 /// into view) -- the opposite sign `BenchRun.kt`'s `runFlingPhase` uses,
 /// since `TranscriptList`'s `LazyColumn` and this list define "positive"
 /// the other way around; the two apps' *travel* is still directly
 /// comparable because both report it as a row index + pixel offset, not a
 /// signed distance.
 async fn run_fling_phase(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn RequestRedraw>,
 ) -> String {
    ctx.update(|state: &mut BenchClient, _rsc| {
        state.android_state_mut().frame_report.mark_phase("fling");
    });
    ctx.update(|state: &mut BenchClient, rsc| {
        if let Some(screen) = &state.screen {
            (screen.list)(rsc).jump_to_end();
        }
    });
    redraw.request_redraw();
    // Lets the next frame's `repair_anchor` resolve `jump_to_end`'s
    // `anchor = None` into a real slot before `start` is read.
    tokio::time::sleep(Duration::from_millis(ANIM_STEP_MS * 2)).await;
    let start = read_anchor_position(ctx, redraw).await;
    for _ in 0..FLING_COUNT {
        ctx.update(|state: &mut BenchClient, rsc| {
            if let Some(screen) = &state.screen {
                (screen.list)(rsc).fling(-FLING_VELOCITY_PX_S);
            }
        });
        redraw.request_redraw();
        wait_for_fling_settle(ctx, redraw).await;
        tokio::time::sleep(Duration::from_millis(FLING_PAUSE_MS)).await;
    }
    let outward = read_anchor_position(ctx, redraw).await;
    for _ in 0..FLING_COUNT {
        ctx.update(|state: &mut BenchClient, rsc| {
            if let Some(screen) = &state.screen {
                (screen.list)(rsc).fling(FLING_VELOCITY_PX_S);
            }
        });
        redraw.request_redraw();
        wait_for_fling_settle(ctx, redraw).await;
        tokio::time::sleep(Duration::from_millis(FLING_PAUSE_MS)).await;
    }
    let end = read_anchor_position(ctx, redraw).await;
    format!("start={start} outward={outward} end={end}")
 }
 async fn read_anchor_position(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn RequestRedraw>,
 ) -> String {
    read_from_state(ctx, redraw, |state, rsc| match &state.screen {
        Some(screen) => (screen.list)(rsc).anchor_position_display(),
        None => "idx=none".to_string(),
    })
    .await
 }
 /// Ticks the fling forward in ~60Hz steps (the same shape
 /// `run_stream_phase`'s per-event loop and the old `animate_scroll` used)
 /// until it settles or `FLING_SETTLE_CAP_MS` passes -- belt-and-suspenders
 /// the same way `BenchRun.kt`'s own `waitForSettle` is, since a fling's
 /// own spline-decided `duration()` already caps how long it can run.
 async fn wait_for_fling_settle(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn RequestRedraw>,
 ) {
    let cap = Duration::from_millis(FLING_SETTLE_CAP_MS);
    let started = Instant::now();
    while started.elapsed() < cap {
        let still_scrolling = read_from_state(ctx, redraw, |state, rsc| match &state.screen {
            Some(screen) => (screen.list)(rsc).tick_fling(Instant::now()),
            None => false,
        })
        .await;
        if !still_scrolling {
            return;
        }
        tokio::time::sleep(Duration::from_millis(ANIM_STEP_MS)).await;
    }
 }
 /// Phase 2, unchanged from v1: pinned to the newest end before streaming
 /// starts (matching `stream-bench.sh`'s "Jump to latest" tap), then
 /// `STREAM_EVENTS_PER_SEC * STREAM_SECONDS` fixture events replayed
 /// through the real `fold_event`/`TranscriptScreen::apply` path. Returns
 /// `(sent, total)`.
 async fn run_stream_phase(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn RequestRedraw>,
    stream_tail: Vec<SeqEvent>,
 ) -> (usize, usize) {
    ctx.update(|state: &mut BenchClient, _rsc| {
        state.android_state_mut().frame_report.mark_phase("stream");
    });
    ctx.update(|state: &mut BenchClient, rsc| {
        if let Some(screen) = &state.screen {
            (screen.list)(rsc).jump_to_end();
        }
    });
    redraw.request_redraw();
    let total = (STREAM_EVENTS_PER_SEC * STREAM_SECONDS) as usize;
    let mut sent = 0usize;
    for event in stream_tail.into_iter().take(total) {
        ctx.update(move |state: &mut BenchClient, rsc| {
            let old_items = state.items.clone();
            state.items = fold_event(&state.items, &event);
            match &state.screen {
                Some(screen) => screen.apply(rsc, &old_items, &state.items),
                None => state.rebuild_transcript(rsc),
            }
        });
        redraw.request_redraw();
        sent += 1;
        tokio::time::sleep(Duration::from_millis(1000 / STREAM_EVENTS_PER_SEC)).await;
    }
    // Lets the last few deltas land and draw before the next phase starts
    // -- `BenchRun.kt`'s own closing delay.
    tokio::time::sleep(Duration::from_millis(300)).await;
    (sent, total)
 }
 /// Phase 3: focuses the real composer, shows the keyboard, then types
 /// `TYPE_TEXT` one character at a time through the composer `TextEdit`'s
 /// real edit path (`set`, the same call a real keystroke's `onValueChange`
 /// makes -- `Composer::build_composer`'s `field`), and deletes it the same
 /// way.
 async fn run_type_phase(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    redraw: &Arc<dyn RequestRedraw>,
    platform: &Option<Arc<PlatformHandle>>,
 ) {
    ctx.update(|state: &mut BenchClient, _rsc| {
        state.android_state_mut().frame_report.mark_phase("type");
    });
    ctx.update(|state: &mut BenchClient, rsc| {
        if let Some(screen) = &state.screen {
            (screen.list)(rsc).jump_to_end();
            state.set_focus(Some(screen.composer.field));
        }
    });
    redraw.request_redraw();
    if let Some(p) = platform {
        p.show_ime();
    }
    // Lets focus and the keyboard's opening animation land before typing
    // starts, so the frames this phase records are the wrap/reflow it is
    // measuring, not the keyboard opening -- `BenchRun.kt`'s own delay.
    tokio::time::sleep(Duration::from_millis(300)).await;
    let mut typed = String::new();
    for ch in TYPE_TEXT.chars() {
        typed.push(ch);
        let text = typed.clone();
        ctx.update(move |state: &mut BenchClient, rsc| {
            if let Some(screen) = &state.screen {
                screen.composer.field.edit(rsc).set(&text);
            }
        });
        redraw.request_redraw();
        tokio::time::sleep(Duration::from_millis(TYPE_CHAR_MS)).await;
    }
    tokio::time::sleep(Duration::from_millis(200)).await;
    while !typed.is_empty() {
        typed.pop();
        let text = typed.clone();
        ctx.update(move |state: &mut BenchClient, rsc| {
            if let Some(screen) = &state.screen {
                screen.composer.field.edit(rsc).set(&text);
            }
        });
        redraw.request_redraw();
        tokio::time::sleep(Duration::from_millis(TYPE_CHAR_MS)).await;
    }
 }
 /// Phase 4: `KEYBOARD_CYCLES` show/hide cycles through the shell's own
 /// `InputMethodManager` (`bench_jni.rs`'s `show_ime`/`hide_ime`), each
 /// confirmed by `on_insets_changed`'s real `ime_bottom` transition rather
 /// than assumed from the JNI call having returned -- `ImeState`'s doc.
 /// "keyboard: could not be shown" if the platform never confirms it even
 /// once, per UI_RULES.md ("design the unknown/failed state before the
 /// answer's").
 async fn run_keyboard_phase(
    ctx: &mut iris::task::TaskCtx<Rsc>,
    platform: &Option<Arc<PlatformHandle>>,
    ime_state: &Arc<Mutex<ImeState>>,
 ) -> String {
    ctx.update(|state: &mut BenchClient, _rsc| {
        state
            .android_state_mut()
            .frame_report
            .mark_phase("keyboard");
    });
    let mut shown = 0;
    let mut hidden = 0;
    for _ in 0..KEYBOARD_CYCLES {
        let before_shown = ime_state.lock().unwrap().shown_events;
        if let Some(p) = platform {
            p.show_ime();
        }
        tokio::time::sleep(Duration::from_millis(KEYBOARD_WAIT_MS)).await;
        if ime_state.lock().unwrap().shown_events > before_shown {
            shown += 1;
        }
        let before_hidden = ime_state.lock().unwrap().hidden_events;
        if let Some(p) = platform {
            p.hide_ime();
        }
        tokio::time::sleep(Duration::from_millis(KEYBOARD_WAIT_MS)).await;
        if ime_state.lock().unwrap().hidden_events > before_hidden {
            hidden += 1;
        }
    }
    if shown == 0 {
        format!("  keyboard: could not be shown ({KEYBOARD_CYCLES} attempts, 0 confirmed visible)")
    } else {
        format!(
            "  keyboard: shown {shown}/{KEYBOARD_CYCLES}, hidden {hidden}/{KEYBOARD_CYCLES} \
             (confirmed via on_insets_changed)"
        )
    }
 }
 #[cfg(test)]
 mod tests {
    use super::TYPE_TEXT;
    /// `BenchRun.kt`'s own `TYPE_TEXT` is verified `.length == 600`; this
    /// is the same string, so it has to match exactly or the two apps'
    /// type phases stop typing the same content -- RUST.md's "Benchmark
    /// v2" spec is one shared string for both.
    #[test]
    fn type_text_is_exactly_600_characters() {
        assert_eq!(TYPE_TEXT.chars().count(), 600);
    }
 }
@@ -1,11 +1,14 @@
 //! JNI calls the `bench` feature needs that go through the shell's own
 //! Java side rather than anything `iris`/`android-view` already wraps:
 //! `BatteryManager.getIntProperty(BATTERY_PROPERTY_CURRENT_NOW)` for the
-//! per-second battery sample, and `ClipboardManager.setPrimaryClip` for
+//! per-second battery sample, `ClipboardManager.setPrimaryClip` for the
-//! the "Copy report" control (P0's iris half, docs/RUST.md). Neither is
+//! "Copy report" control (P0's iris half, docs/RUST.md), and -- added for
-//! part of `android_view::context`'s own `Context`/`Resources` wrappers
+//! RUST.md's "Benchmark v2" -- `Display.getRefreshRate()` for the phase
-//! (that file's own `// TODO: more methods?`), so this calls them
+//! report's real late-frame budget and `InputMethodManager.
-//! directly rather than growing that crate's wrapper for two one-off
+//! showSoftInput`/`hideSoftInputFromWindow` for the keyboard phase. None
 //! of these are part of `android_view::context`'s own `Context`/
 //! `Resources` wrappers (that file's own `// TODO: more methods?`), so
 //! this calls them directly rather than growing that crate's wrapper for
 //! calls this crate alone needs.
 //!
 //! Holds its own `JavaVM` + `GlobalRef` to the view (handed in through
@@ -131,4 +134,119 @@ impl PlatformHandle {
        .ok()?;
        Some(())
    }
    /// The display's own refresh rate in Hz (`View::getDisplay()` ->
    /// `Display::getRefreshRate()`), for RUST.md's "Benchmark v2": late
    /// frames are judged against *this* device's real budget, not an
    /// assumed 60Hz -- a 90Hz or 120Hz phone would otherwise call frames
    /// "late" that met their own faster deadline. `None` if the view is
    /// not yet attached to a window (`getDisplay` returns `null`) or the
    /// platform reports a non-positive rate, which is not a real answer
    /// either.
    pub fn refresh_rate_hz(&self) -> Option<f32> {
        let mut guard = self.vm.attach_current_thread().ok()?;
        let env: &mut JNIEnv = &mut guard;
        let display = env
            .call_method(
                self.view.as_obj(),
                "getDisplay",
                "()Landroid/view/Display;",
                &[],
            )
            .ok()?
            .l()
            .ok()?;
        if display.is_null() {
            return None;
        }
        let rate = env
            .call_method(&display, "getRefreshRate", "()F", &[])
            .ok()?
            .f()
            .ok()?;
        if rate > 0.0 { Some(rate) } else { None }
    }
    /// `InputMethodManager.showSoftInput(view, 0)` -- the keyboard phase's
    /// own show, called directly rather than through the focus-driven
    /// `pending_show_keyboard` path `android/view.rs` uses for a real tap,
    /// since RUST.md's "Benchmark v2" spec asks for this "through the
    /// shell's InputMethodManager" independent of focus state. `true` only
    /// if the platform itself reports the request succeeded -- whether the
    /// IME actually became visible is confirmed separately, from
    /// `on_insets_changed`, per UI_RULES.md ("never present an inferred
    /// value as a measured one").
    pub fn show_ime(&self) -> bool {
        self.try_toggle_ime(true).unwrap_or(false)
    }
    /// `InputMethodManager.hideSoftInputFromWindow(windowToken, 0)`.
    pub fn hide_ime(&self) -> bool {
        self.try_toggle_ime(false).unwrap_or(false)
    }
    fn try_toggle_ime(&self, show: bool) -> Option<bool> {
        let mut guard = self.vm.attach_current_thread().ok()?;
        let env: &mut JNIEnv = &mut guard;
        let context = self.context(env)?;
        let imm = self.system_service(env, &context, "input_method")?;
        if show {
            env.call_method(
                &imm,
                "showSoftInput",
                "(Landroid/view/View;I)Z",
                &[JValue::Object(self.view.as_obj()), JValue::Int(0)],
            )
            .ok()?
            .z()
            .ok()
        } else {
            let token = env
                .call_method(
                    self.view.as_obj(),
                    "getWindowToken",
                    "()Landroid/os/IBinder;",
                    &[],
                )
                .ok()?
                .l()
                .ok()?;
            env.call_method(
                &imm,
                "hideSoftInputFromWindow",
                "(Landroid/os/IBinder;I)Z",
                &[JValue::Object(&token), JValue::Int(0)],
            )
            .ok()?
            .z()
            .ok()
        }
    }
    /// Shows `report` in the shell's plain-view diagnostics overlay
    /// (`IrisView.showDiagnosticsOverlay`) -- a real `TextView` plus Copy
    /// and Close controls, added over whatever iris itself is drawing
    /// rather than replacing it (unlike `android::view::show_renderer_error`,
    /// which exists for the case the renderer can never recover from and
    /// intentionally never returns). Called from a background task after
    /// the keyboard-open delay (`bench_client.rs`'s `on_insets_changed`),
    /// so the Java side hops onto the UI thread itself before touching the
    /// view tree -- see that method's own comment.
    pub fn show_diagnostics_overlay(&self, report: &str) -> bool {
        self.try_show_diagnostics_overlay(report).is_some()
    }
    fn try_show_diagnostics_overlay(&self, report: &str) -> Option<()> {
        let mut guard = self.vm.attach_current_thread().ok()?;
        let env: &mut JNIEnv = &mut guard;
        let jreport = env.new_string(report).ok()?;
        env.call_method(
            self.view.as_obj(),
            "showDiagnosticsOverlay",
            "(Ljava/lang/String;)V",
            &[JValue::Object(jreport.as_ref())],
        )
        .ok()?;
        Some(())
    }
 }
@@ -9,7 +9,31 @@ pub struct Size {
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Len {
    /// Physical pixels -- a raw device pixel, unaffected by the display's
    /// density. Rare to want directly (a hairline border is the usual
    /// case); most sizes should be `dp` instead. See `dp`'s own doc for why
    /// the two are kept separate rather than one field a caller has to
    /// remember to pre-multiply.
    pub abs: f32,
    /// Density-independent pixels -- Android's `dp` / CSS's reference pixel
    /// (1 unit = 1/160in), resolved against the display's density at
    /// layout time (`apply_rest`'s `density` parameter) rather than at the
    /// point a widget is built, since density is a property of the device
    /// this ends up running on, not of the widget tree. This is the unit
    /// IRIS_TODO.md's "a density-independent length unit" item asked for,
    /// 2026-09-06: before it existed, every size in the tree was `abs`
    /// (physical pixels), and the only way to make a 16px design draw at
    /// the right *size* on a denser display was a single global multiply
    /// applied to the whole rendered scene after layout -- which is also
    /// what made text blurry (RUST.md's P0 box, "blurry ... glyphs drawn
    /// at logical size and stretched by the scale"): a glyph rasterised at
    /// 16 physical px and then stretched 3x by that global multiply is a
    /// 48px area sampled from a 16px bitmap. Resolving `dp` per-length at
    /// layout time instead means the font size handed to the text shaper
    /// is already the physical size (`16.0.dp() * 3.0`), so the glyph
    /// atlas rasterises at the display's real resolution and nothing
    /// downstream needs to stretch anything.
    pub dp: f32,
    pub rel: f32,
    pub rest: f32,
 }
@@ -67,10 +91,10 @@ impl Size {
        }
    }
-    pub fn to_uivec2(self) -> UiVec2 {
+    pub fn to_uivec2(self, density: f32) -> UiVec2 {
        UiVec2 {
-            x: self.x.apply_rest(),
+            x: self.x.apply_rest(density),
-            y: self.y.apply_rest(),
+            y: self.y.apply_rest(density),
        }
    }
@@ -98,26 +122,43 @@ impl Size {
 impl Len {
    pub const ZERO: Self = Self {
        abs: 0.0,
        dp: 0.0,
        rel: 0.0,
        rest: 0.0,
    };
    pub const REST: Self = Self {
        abs: 0.0,
        dp: 0.0,
        rel: 0.0,
        rest: 1.0,
    };
-    pub fn apply_rest(&self) -> UiScalar {
+    /// Resolves to a `UiScalar`, folding `dp` into `abs` pixels against
    /// `density` (physical pixels per dp -- 1.0 on a desktop or an
    /// unscaled display, `content_scale` on Android; see `dp`'s field
    /// doc). Every other component of `Len` is already resolution-
    /// independent (`rel` is a fraction of the parent; `rest` becomes a
    /// fraction too, below), so `density` only ever touches this one term.
    pub fn apply_rest(&self, density: f32) -> UiScalar {
        UiScalar {
            rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 },
-            abs: self.abs,
+            abs: self.abs + self.dp * density,
        }
    }
    pub fn abs(abs: impl UiNum) -> Self {
        Self {
            abs: abs.to_f32(),
            dp: 0.0,
            rel: 0.0,
            rest: 0.0,
        }
    }
    pub fn dp(dp: impl UiNum) -> Self {
        Self {
            abs: 0.0,
            dp: dp.to_f32(),
            rel: 0.0,
            rest: 0.0,
        }
@@ -125,6 +166,7 @@ impl Len {
    pub fn rel(rel: impl UiNum) -> Self {
        Self {
            abs: 0.0,
            dp: 0.0,
            rel: rel.to_f32(),
            rest: 0.0,
        }
@@ -132,6 +174,7 @@ impl Len {
    pub fn rest(ratio: impl UiNum) -> Self {
        Self {
            abs: 0.0,
            dp: 0.0,
            rel: 0.0,
            rest: ratio.to_f32(),
        }
@@ -144,6 +187,15 @@ pub mod len_fns {
    pub fn abs(abs: impl UiNum) -> Len {
        Len {
            abs: abs.to_f32(),
            dp: 0.0,
            rel: 0.0,
            rest: 0.0,
        }
    }
    pub fn dp(dp: impl UiNum) -> Len {
        Len {
            abs: 0.0,
            dp: dp.to_f32(),
            rel: 0.0,
            rest: 0.0,
        }
@@ -151,6 +203,7 @@ pub mod len_fns {
    pub fn rel(rel: impl UiNum) -> Len {
        Len {
            abs: 0.0,
            dp: 0.0,
            rel: rel.to_f32(),
            rest: 0.0,
        }
@@ -158,14 +211,15 @@ pub mod len_fns {
    pub fn rest(ratio: impl UiNum) -> Len {
        Len {
            abs: 0.0,
            dp: 0.0,
            rel: 0.0,
            rest: ratio.to_f32(),
        }
    }
 }
-impl_op!(Len Add add; abs rel rest);
+impl_op!(Len Add add; abs dp rel rest);
-impl_op!(Len Sub sub; abs rel rest);
+impl_op!(Len Sub sub; abs dp rel rest);
 impl_op!(Size Add add; x y);
 impl_op!(Size Sub sub; x y);
@@ -187,6 +241,9 @@ impl std::fmt::Display for Len {
        if self.abs != 0.0 {
            write!(f, "{} abs;", self.abs)?;
        }
        if self.dp != 0.0 {
            write!(f, "{} dp;", self.dp)?;
        }
        if self.rel != 0.0 {
            write!(f, "{} rel;", self.rel)?;
        }
@@ -66,6 +66,17 @@ pub struct TextData {
    pub layout_cx: LayoutContext<UiColor>,
    scale_cx: ScaleContext,
    pub atlas: GlyphAtlas,
    /// Physical pixels per dp -- a second copy of
    /// `UiRenderState::density`, kept here too because `TextEditCtx::layout`
    /// (cursor movement and hit-testing, `widget/text/edit.rs`) shapes text
    /// from an event callback that has a `TextData` but no `Painter`, so it
    /// has nowhere else to read the display's density from. Both copies are
    /// set together, from the one place either backend learns the real
    /// value (`android::view::new_peer`); this is the same accepted
    /// duplication as `AndroidRenderer::content_scale`; a single source of
    /// truth would mean carrying a `Painter` (or output size) into every
    /// input handler for the sake of one field.
    pub density: f32,
 }
 impl Default for TextData {
@@ -75,6 +86,7 @@ impl Default for TextData {
            layout_cx: LayoutContext::new(),
            scale_cx: ScaleContext::new(),
            atlas: GlyphAtlas::default(),
            density: 1.0,
        };
        data.register_bundled_fonts();
        data
@@ -363,7 +375,7 @@ pub struct TextBuffer {
    /// `set_spans` forces `shaped` to `None` directly, the same way `edit`
    /// does, since spans change far less often than a naive equality check
    /// on the whole `Vec` would cost to compute every frame.
-    shaped: Option<(TextAttrs, Option<f32>)>,
+    shaped: Option<(TextAttrs, Option<f32>, f32)>,
 }
 impl TextBuffer {
@@ -419,19 +431,42 @@ impl TextBuffer {
        Vec2::new(self.layout.width(), self.layout.height())
    }
-    /// Lay the text out, unless it is already laid out for these attributes and
+    /// Lay the text out, unless it is already laid out for these
-    /// this width.
+    /// attributes, this width and this density.
-    pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option<f32>) {
+    ///
-        if self.shaped.as_ref() == Some(&(attrs.clone(), width)) {
+    /// **`attrs.font_size`/`line_height` and every span's own `font_size`
    /// are density-independent (dp) units, multiplied by `density` here --
    /// the one place text crosses from the widget tree's dp sizes into the
    /// physical pixels the shaper and rasteriser (`TextData::place`) both
    /// then work in.** This is what makes glyphs sharp on a dense display:
    /// before this existed, `font_size` was already a physical-pixel value
    /// (RUST.md's P0 box's global-scale stopgap resolved density by
    /// stretching the whole rendered frame afterward instead), so a glyph
    /// was rasterised small and then upscaled by whatever the display's
    /// scale factor was -- exactly the blur Iris's report described.
    /// Multiplying here instead means the font size hitting `ScaleContext`
    /// in `place` below is already the display's real physical size, so
    /// the atlas holds a bitmap at the resolution it is actually shown at.
    /// `GlyphKey.size` already keys on that resolved `font_size`
    /// (`(font_size * 16.0).round()`), so a cache entry is naturally per
    /// physical size with no change needed there.
    pub fn shape(
        &mut self,
        data: &mut TextData,
        attrs: &TextAttrs,
        width: Option<f32>,
        density: f32,
    ) {
        if self.shaped.as_ref() == Some(&(attrs.clone(), width, density)) {
            return;
        }
        let mut builder = data
            .layout_cx
            .ranged_builder(&mut data.font_cx, &self.text, 1.0, true);
        builder.push_default(StyleProperty::FontFamily(attrs.family.family()));
-        builder.push_default(StyleProperty::FontSize(attrs.font_size));
+        builder.push_default(StyleProperty::FontSize(attrs.font_size * density));
        builder.push_default(StyleProperty::LineHeight(LineHeight::Absolute(
-            attrs.line_height,
+            attrs.line_height * density,
        )));
        builder.push_default(StyleProperty::Brush(attrs.color));
        for span in &self.spans {
@@ -443,7 +478,7 @@ impl TextBuffer {
                builder.push(StyleProperty::FontFamily(family.family()), range.clone());
            }
            if let Some(size) = span.font_size {
-                builder.push(StyleProperty::FontSize(size), range.clone());
+                builder.push(StyleProperty::FontSize(size * density), range.clone());
            }
            if span.bold {
                builder.push(StyleProperty::FontWeight(FontWeight::BOLD), range.clone());
@@ -459,7 +494,7 @@ impl TextBuffer {
        self.layout.break_all_lines(width);
        self.layout
            .align(Alignment::Start, AlignmentOptions::default());
-        self.shaped = Some((attrs.clone(), width));
+        self.shaped = Some((attrs.clone(), width, density));
    }
 }
@@ -576,8 +611,9 @@ impl TextData {
        attrs: &TextAttrs,
        width: Option<f32>,
        textures: &mut Textures,
        density: f32,
    ) -> RenderedText {
-        buffer.shape(self, attrs, width);
+        buffer.shape(self, attrs, width, density);
        let glyphs = self.place(buffer, textures);
        RenderedText {
            glyphs: std::sync::Arc::new(glyphs),
@@ -1,15 +1,87 @@
-use std::time::Duration;
+use std::time::{Duration, Instant};
 /// The frame budget `dumpsys gfxinfo` also uses to call a frame "janky": the
 /// 60Hz vsync period. Kept as the same threshold so a percentage from this
-/// report and a percentage from `gfxinfo` mean the same thing.
+/// report and a percentage from `gfxinfo` mean the same thing. Only a
 /// fallback now that a caller can read the display's real refresh rate
 /// (`report_at_hz`/`mark_phase`'s callers) -- most devices are 60Hz, but a
 /// 90Hz or 120Hz phone judged against this constant would call every frame
 /// "late" that merely met its own, faster budget.
 pub const JANK_THRESHOLD: Duration = Duration::from_nanos(16_666_667);
 /// Enough frames for several minutes of scrolling before the oldest ones
 /// start being overwritten -- the same "diagnostic, not a log" sizing
 /// `FrameStats.kt`'s `CAP` uses on the Compose side, chosen independently
 /// here since a `Duration` is smaller than the six `Long` arrays it keeps.
-const RING_CAPACITY: usize = 4096;
+/// Bumped from 4096 for RUST.md's "Benchmark v2": a fling+stream+type+
 /// keyboard run is ~6,500+ frames on the Compose side, comfortably under
 /// this so `phase_stats` never has to report a phase as partially evicted.
 const RING_CAPACITY: usize = 16384;
 /// One `mark_phase` call: the wall-clock instant and the (0-based,
 /// never-reset-by-`reset`-except-at-`reset`-time) absolute frame index at
 /// which a phase began -- `phase_stats` slices `index_ring` against this to
 /// find which recorded samples belong to which phase, since the ring
 /// itself only keeps the most recent `RING_CAPACITY` samples' *values*,
 /// not which phase they were in.
 struct PhaseMark {
    name: String,
    start_index: u64,
    start_at: Instant,
 }
 /// One phase's own slice of a report -- RUST.md's "Benchmark v2" spec's
 /// "per-phase blocks in `FrameReport`... frames, late count/percent...
 /// p50/p90/p99, worst, duration". `Display` matches the shape
 /// `docs/bench/compose-phone-v2-2026-09-06.md`'s report already uses, so
 /// the two apps' reports read the same way side by side.
 pub struct PhaseStats {
    pub name: String,
    /// How many frames were recorded during this phase in total -- may
    /// exceed `late + (samples counted)` if some of this phase's frames
    /// have since been evicted from the ring by a very long run; that
    /// case is named in the `Display` rather than silently under-counted.
    pub frames: u64,
    pub duration: Duration,
    pub late: u64,
    pub late_percent: f64,
    pub p50: Duration,
    pub p90: Duration,
    pub p99: Duration,
    pub worst: Duration,
    /// `false` if this phase's frame count exceeds how many samples of it
    /// are still in the ring -- the percentiles above are then computed
    /// over whatever survived, not the whole phase. UI_RULES.md: this is
    /// the "we don't fully know" state, named rather than folded silently
    /// into a number that looks exact.
    pub complete: bool,
 }
 impl std::fmt::Display for PhaseStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(
            f,
            "  {}: {} frames over {:.1}s{}",
            self.name,
            self.frames,
            self.duration.as_secs_f64(),
            if self.complete {
                ""
            } else {
                " (ring evicted some of this phase)"
            },
        )?;
        writeln!(f, "    late: {} ({:.1}%)", self.late, self.late_percent)?;
        writeln!(
            f,
            "      total  p50 {:.1}ms  p90 {:.1}ms  p99 {:.1}ms",
            self.p50.as_secs_f64() * 1000.0,
            self.p90.as_secs_f64() * 1000.0,
            self.p99.as_secs_f64() * 1000.0,
        )?;
        write!(f, "    worst {:.1}ms", self.worst.as_secs_f64() * 1000.0)
    }
 }
 /// A per-frame wall-time report iris keeps of itself, because `dumpsys
 /// gfxinfo` cannot see a `SurfaceView`'s own GPU-drawn frames at all
@@ -41,6 +113,11 @@ pub struct FrameReport {
    /// "Where iris's frame time goes" CPU/GPU split, added 2026-09-05).
    /// `ring[i] - submit_ring[i]` is that frame's `redraw_to_submit` half.
    submit_ring: Box<[Duration; RING_CAPACITY]>,
    /// The absolute (0-based, since the last `reset`) frame index each
    /// `ring`/`submit_ring` slot's sample belongs to -- what `phase_stats`
    /// slices against `PhaseMark::start_index` to tell which recorded
    /// frames fall in which phase.
    index_ring: Box<[u64; RING_CAPACITY]>,
    /// How many of `ring`'s slots hold a real sample -- saturates at
    /// `RING_CAPACITY`, unlike `total_frames` below which keeps counting.
    len: usize,
@@ -50,6 +127,12 @@ pub struct FrameReport {
    /// correct even once the ring itself only holds the most recent frames.
    total_frames: u64,
    janky_frames: u64,
    /// `mark_phase` calls since the last `reset`, oldest first -- see
    /// `phase_stats`. Empty on an ordinary run that never calls
    /// `mark_phase`, so `phase_stats` returns an empty `Vec` and a caller
    /// prints no "per phase:" section at all, matching RUST.md's "empty/
    /// absent on an ordinary 'Copy' press, which never marks a phase."
    phases: Vec<PhaseMark>,
 }
 /// One resolved reading. `Display` is the log line both the "Frame report"
@@ -107,10 +190,12 @@ impl FrameReport {
        Self {
            ring: Box::new([Duration::ZERO; RING_CAPACITY]),
            submit_ring: Box::new([Duration::ZERO; RING_CAPACITY]),
            index_ring: Box::new([0; RING_CAPACITY]),
            len: 0,
            pos: 0,
            total_frames: 0,
            janky_frames: 0,
            phases: Vec::new(),
        }
    }
@@ -131,6 +216,7 @@ impl FrameReport {
    pub fn record_split(&mut self, total: Duration, submit_to_present: Duration) {
        self.ring[self.pos] = total;
        self.submit_ring[self.pos] = submit_to_present;
        self.index_ring[self.pos] = self.total_frames;
        self.pos = (self.pos + 1) % RING_CAPACITY;
        self.len = (self.len + 1).min(RING_CAPACITY);
        self.total_frames += 1;
@@ -142,12 +228,89 @@ impl FrameReport {
    /// Clears every counter and every sample -- what the "Reset frame
    /// report" control calls, so a report covers only what was scrolled
    /// after the button was pressed (the same reason `FrameStats.kt`'s
-    /// `reset()` exists on the Compose side).
+    /// `reset()` exists on the Compose side). Also clears every phase
    /// mark, so a fresh run starts with no "per phase:" section until it
    /// marks one of its own.
    pub fn reset(&mut self) {
        self.len = 0;
        self.pos = 0;
        self.total_frames = 0;
        self.janky_frames = 0;
        self.phases.clear();
    }
    /// Marks the start of a named phase at the current moment -- every
    /// frame recorded from here until the next `mark_phase` (or `reset`)
    /// belongs to it. RUST.md's "Benchmark v2": a scripted bench run calls
    /// this once per phase (fling/stream/type/keyboard) so `phase_stats`
    /// can slice one whole run's frames by what was happening during each.
    pub fn mark_phase(&mut self, name: &str) {
        self.phases.push(PhaseMark {
            name: name.to_string(),
            start_index: self.total_frames,
            start_at: Instant::now(),
        });
    }
    /// One [`PhaseStats`] per `mark_phase` call since the last `reset`,
    /// oldest first. `now` closes the last phase's wall-clock span (there
    /// is no "next phase" instant to use for it); `refresh_hz` is what
    /// each phase's own `late`/`late_percent` is judged against, read from
    /// the display rather than assumed -- RUST.md's "Benchmark v2": "late
    /// count/% against the display's refresh rate."
    pub fn phase_stats(&self, now: Instant, refresh_hz: f32) -> Vec<PhaseStats> {
        if self.phases.is_empty() || refresh_hz <= 0.0 {
            return Vec::new();
        }
        let budget = Duration::from_secs_f64(1.0 / refresh_hz as f64);
        self.phases
            .iter()
            .enumerate()
            .map(|(i, phase)| {
                let (end_index, end_at) = match self.phases.get(i + 1) {
                    Some(next) => (next.start_index, next.start_at),
                    None => (self.total_frames, now),
                };
                let frames = end_index.saturating_sub(phase.start_index);
                let mut samples: Vec<Duration> = (0..self.len)
                    .filter(|&j| {
                        let idx = self.index_ring[j];
                        idx >= phase.start_index && idx < end_index
                    })
                    .map(|j| self.ring[j])
                    .collect();
                let complete = samples.len() as u64 >= frames;
                if samples.is_empty() {
                    return PhaseStats {
                        name: phase.name.clone(),
                        frames,
                        duration: end_at.saturating_duration_since(phase.start_at),
                        late: 0,
                        late_percent: 0.0,
                        p50: Duration::ZERO,
                        p90: Duration::ZERO,
                        p99: Duration::ZERO,
                        worst: Duration::ZERO,
                        complete,
                    };
                }
                samples.sort_unstable();
                let pct = |p: usize| samples[(samples.len() * p / 100).min(samples.len() - 1)];
                let late = samples.iter().filter(|&&d| d > budget).count() as u64;
                PhaseStats {
                    name: phase.name.clone(),
                    frames,
                    duration: end_at.saturating_duration_since(phase.start_at),
                    late,
                    late_percent: 100.0 * late as f64 / samples.len() as f64,
                    p50: pct(50),
                    p90: pct(90),
                    p99: pct(99),
                    worst: *samples.last().expect("checked not empty above"),
                    complete,
                }
            })
            .collect()
    }
    /// `None` if nothing has been recorded since the last reset -- the
@@ -186,6 +349,28 @@ impl FrameReport {
            gpu_wait_p50: median(submit_samples),
        })
    }
    /// `(late count, late percent)` over every sample still in the ring,
    /// judged against `refresh_hz`'s own frame budget rather than the
    /// fixed 60Hz `JANK_THRESHOLD` -- RUST.md's "Benchmark v2": "late
    /// count/% against the display's refresh rate... print 'at N Hz (X ms
    /// budget)' like Compose does." A separate method from `report()`
    /// rather than a parameter on it, so `report()`'s own `janky_percent`
    /// (and the exact-boundary test pinned to `JANK_THRESHOLD`) is
    /// unaffected for every existing caller that never measured a real
    /// refresh rate. `(0, 0.0)` with nothing recorded or a non-positive
    /// `refresh_hz`.
    pub fn late_at_hz(&self, refresh_hz: f32) -> (u64, f64) {
        if self.len == 0 || refresh_hz <= 0.0 {
            return (0, 0.0);
        }
        let budget = Duration::from_secs_f64(1.0 / refresh_hz as f64);
        let late = self.ring[..self.len]
            .iter()
            .filter(|&&d| d > budget)
            .count() as u64;
        (late, 100.0 * late as f64 / self.len as f64)
    }
 }
 impl Default for FrameReport {
@@ -296,4 +481,68 @@ mod tests {
        // same pattern here.
        assert!(stats.worst <= Duration::from_millis(5));
    }
    #[test]
    fn no_marks_means_no_phases() {
        let mut r = FrameReport::new();
        r.record(Duration::from_millis(5));
        assert!(r.phase_stats(Instant::now(), 60.0).is_empty());
    }
    #[test]
    fn phases_slice_frames_by_when_they_were_marked() {
        let mut r = FrameReport::new();
        r.mark_phase("a");
        for _ in 0..5 {
            r.record(Duration::from_millis(10)); // 10ms: late at 60Hz (16.7ms budget)... no, 10<16.7, not late
        }
        r.mark_phase("b");
        for _ in 0..3 {
            r.record(Duration::from_millis(20)); // 20ms: late at 60Hz
        }
        let now = Instant::now();
        let phases = r.phase_stats(now, 60.0);
        assert_eq!(phases.len(), 2);
        assert_eq!(phases[0].name, "a");
        assert_eq!(phases[0].frames, 5);
        assert_eq!(phases[0].late, 0);
        assert_eq!(phases[0].worst, Duration::from_millis(10));
        assert_eq!(phases[1].name, "b");
        assert_eq!(phases[1].frames, 3);
        assert_eq!(phases[1].late, 3);
        assert_eq!(phases[1].late_percent, 100.0);
        assert_eq!(phases[1].worst, Duration::from_millis(20));
        assert!(phases[0].complete);
        assert!(phases[1].complete);
    }
    #[test]
    fn the_last_phase_runs_until_now() {
        let mut r = FrameReport::new();
        r.mark_phase("only");
        r.record(Duration::from_millis(1));
        std::thread::sleep(Duration::from_millis(20));
        let now = Instant::now();
        let phases = r.phase_stats(now, 60.0);
        assert_eq!(phases.len(), 1);
        assert!(phases[0].duration >= Duration::from_millis(20));
    }
    #[test]
    fn reset_clears_phase_marks() {
        let mut r = FrameReport::new();
        r.mark_phase("a");
        r.record(Duration::from_millis(1));
        r.reset();
        assert!(r.phase_stats(Instant::now(), 60.0).is_empty());
    }
    #[test]
    fn late_at_hz_uses_the_given_refresh_rate_not_the_fixed_60hz_constant() {
        let mut r = FrameReport::new();
        // 10ms is under 60Hz's 16.7ms budget but over 120Hz's 8.3ms one.
        r.record(Duration::from_millis(10));
        assert_eq!(r.late_at_hz(60.0), (0, 0.0));
        assert_eq!(r.late_at_hz(120.0), (1, 100.0));
    }
 }
@@ -165,8 +165,10 @@ impl<'a> Painter<'a> {
        attrs: &TextAttrs,
        width: Option<f32>,
    ) -> RenderedText {
        let density = self.state.density;
        let ui = self.rsc.ui_mut();
-        ui.text.render(buffer, attrs, width, &mut ui.textures)
+        ui.text
            .render(buffer, attrs, width, &mut ui.textures, density)
    }
    /// Draw a laid-out string: one quad per glyph, all sampling the atlas.
@@ -210,6 +212,12 @@ impl<'a> Painter<'a> {
        self.state.output_size
    }
    /// Physical pixels per `dp` -- see `UiRenderState::density`'s field
    /// doc. What `Len::dp`'s `apply_rest` call resolves against.
    pub fn density(&self) -> f32 {
        self.state.density
    }
    pub fn px_size(&mut self) -> Vec2 {
        self.region.size().to_abs(self.state.output_size)
    }
@@ -9,6 +9,12 @@ pub struct UiRenderState {
    pub active: HashMap<WidgetId, ActiveData>,
    pub layers: PrimitiveLayers,
    pub(super) output_size: Vec2,
    /// Physical pixels per `dp` -- see `Len::dp`'s field doc. `1.0` (an
    /// unscaled display) until a backend that knows its own density calls
    /// `set_density` (Android's `content_scale`, read at `surface_changed`
    /// time); the winit backend has no analogous per-monitor value wired up
    /// yet and stays at the default.
    pub(super) density: f32,
    old_root: Option<WidgetId>,
    resized: bool,
@@ -35,6 +41,7 @@ impl UiRenderState {
            active: Default::default(),
            layers: Default::default(),
            output_size: Vec2::ZERO,
            density: 1.0,
            old_root: None,
            resized: false,
            draw_started: Default::default(),
@@ -60,6 +67,20 @@ impl UiRenderState {
        self.resized = true;
    }
    /// Sets the physical-pixels-per-dp ratio every `Len::dp` in the tree
    /// resolves against from the next layout pass on -- see `density`'s
    /// field doc. Not folded into `resize` because the two change on
    /// different triggers (a surface resize on every rotation or keyboard
    /// open; a density change only if the app follows the display to a
    /// different screen, which Android surfaces separately).
    pub fn set_density(&mut self, density: f32) {
        self.density = density;
    }
    pub fn density(&self) -> f32 {
        self.density
    }
    pub fn update<'a>(&mut self, root: impl Into<Option<&'a StrongWidget>>, rsc: &mut dyn UiRsc) {
        // safety mechanism for memory leaks; might wanna return a result instead so user can
        // decide whether to panic or not
@@ -311,7 +332,7 @@ impl UiRenderState {
        };
        let from = active
            .size
-            .to_uivec2()
+            .to_uivec2(self.density)
            .align(RegionAlign::TOP_LEFT)
            .within(&active.region);
        let slot = active.move_slot;
@@ -68,12 +68,15 @@ fn build_row<Rsc: UiRsc + 'static>(rsc: &mut Rsc, i: usize) -> StrongWidget {
        let mut span = Span::empty(Dir::DOWN);
        span.push(text);
        span.push(img);
-        span.pad(8.0).background(rect(tint)).add_strong(rsc).any()
+        span.pad(dp(8.0))
            .background(rect(tint))
            .add_strong(rsc)
            .any()
    } else {
        wtext(row_text(i))
            .wrap(true)
            .color(text_color)
-            .pad(8.0)
+            .pad(dp(8.0))
            .background(rect(tint))
            .add_strong(rsc)
            .any()
@@ -23,7 +23,7 @@ mod view;
 pub use insets::Insets;
 pub use render::AndroidRenderer;
 pub use view::{
-    AndroidAppState, AndroidRsc, AndroidUiState, HasAndroidUiState, IrisViewPeer, LogicalInsets,
+    AndroidAppState, AndroidRsc, AndroidUiState, HasAndroidUiState, IrisViewPeer, WindowInsets,
    new_peer,
 };
@@ -208,14 +208,14 @@ impl AndroidRenderer {
        surface.configure(&device, &config);
        let encoder = Self::create_encoder(&device);
-        // Logical size (physical / `content_scale`) -- see
+        // Physical pixels, matching the swapchain's own `width`/`height`
-        // `android::view::AndroidUiState::content_scale`'s field comment
+        // exactly -- see `android::view::AndroidUiState::content_scale`'s
-        // for why this crate now divides at all (RUST.md's P0 box, "text
+        // field comment for why this is no longer divided into a separate
-        // is far too small"). The swapchain above stays at the real
+        // logical space (that stopgap is what made text blurry, RUST.md's
-        // physical `width`/`height` for a sharp framebuffer.
+        // P0 box). `Len::dp` folds the density in at layout time instead,
-        let logical_size =
+        // so nothing here needs to know it at all.
-            iris_core::util::Vec2::new(width as f32 / content_scale, height as f32 / content_scale);
+        let window_size = iris_core::util::Vec2::new(width as f32, height as f32);
-        let ui = match UiRenderNode::new(&device, &queue, &config, logical_size) {
+        let ui = match UiRenderNode::new(&device, &queue, &config, window_size) {
            Ok(ui) => ui,
            Err(wgpu_error) => return Err(Self::diagnostic(&adapter, &wgpu_error)),
        };
@@ -398,25 +398,27 @@ impl AndroidRenderer {
        submit_start.elapsed()
    }
-    /// Logical size (physical / `content_scale`) -- the unit layout and
+    /// Physical pixels -- the unit layout and hit-testing use, matching
-    /// hit-testing use, matching the window uniform's own units. See
+    /// the window uniform's own units. See
    /// `android::view::AndroidUiState::content_scale`'s field comment.
    pub fn size(&self) -> iris_core::util::Vec2 {
-        iris_core::util::Vec2::new(
+        iris_core::util::Vec2::new(self.config.width as f32, self.config.height as f32)
            self.config.width as f32 / self.content_scale,
            self.config.height as f32 / self.content_scale,
        )
    }
    /// Reconfigures the surface and rewrites the window uniform for a new
    /// physical size -- deliberately the *only* two things this does.
    /// `device`, `ui`'s atlas, buffers and bind groups are untouched, so a
    /// call here (as opposed to a fresh `AndroidRenderer::new`) never
    /// invalidates a glyph the CPU-side cache already placed in the atlas.
    /// See `android::view::IrisViewPeer::surface_changed`'s doc comment for
    /// why that distinction matters -- it is what keeps text on screen
    /// across an IME resize.
    pub fn resize(&mut self, width: u32, height: u32) {
        self.config.width = width;
        self.config.height = height;
        self.surface.configure(&self.device, &self.config);
-        let logical = iris_core::util::Vec2::new(
+        let size = iris_core::util::Vec2::new(width as f32, height as f32);
-            width as f32 / self.content_scale,
+        self.ui.resize(size, &self.queue);
            height as f32 / self.content_scale,
        );
        self.ui.resize(logical, &self.queue);
    }
 }
@@ -70,19 +70,31 @@ pub struct AndroidUiState {
    /// because `dumpsys gfxinfo` cannot see a `SurfaceView`'s own
    /// GPU-drawn frames at all. See `iris_core::FrameReport`'s own doc.
    pub frame_report: FrameReport,
-    /// `DisplayMetrics.density` (`new_peer`'s doc comment), read once at
+    /// `DisplayMetrics.density` (`new_peer`'s doc comment): physical pixels
-    /// view construction: physical pixels per dp on this device. Neither
+    /// per dp on this device, read once at view construction and carried
-    /// this crate nor `default::` had ever divided by it before RUST.md's
+    /// on `UiRenderState::density` (`render.set_density`, `new_peer`) from
-    /// P0 box's phone report ("text is far too small") -- `window_size`
+    /// then on -- every `Len::dp` in the widget tree resolves against it at
-    /// below and `surface_changed`'s call into `UiRenderState::resize` both
+    /// layout time (`Len::dp`'s field doc, IRIS_TODO.md's
-    /// report *logical* (physical / `content_scale`) dimensions now, which
+    /// "density-independent length unit" item, 2026-09-06).
-    /// is what makes a `font_size: 16.0` 16 dp rather than 16 raw device
+    ///
-    /// pixels on a ~3x-density phone. The actual wgpu surface/swapchain
+    /// **Everything else in this module is physical pixels, matching the
-    /// stays at the real physical resolution (`AndroidRenderer`'s own
+    /// real wgpu surface/swapchain resolution** -- window size, touch
-    /// `config.width/height`) for a sharp framebuffer; only the *logical*
+    /// coordinates, insets. That is a correction from an earlier version
-    /// coordinate system layout, hit-testing and the window uniform agree
+    /// of this comment, which had `window_size`/`surface_changed`'s
-    /// on is scaled. Touch coordinates (`on_touch_event`) are divided by
+    /// `UiRenderState::resize` call divide by `content_scale` into a
-    /// this too, so they land in the same space layout is using.
+    /// *logical* coordinate space instead, as a global stopgap for
    /// RUST.md's P0 box's phone report ("text is far too small"). That
    /// stopgap fixed the size but not the *sharpness*: dividing to logical
    /// units meant a `16.0`-sized glyph rasterised at 16 physical px and
    /// then implicitly upscaled ~3x by the NDC mapping onto the real
    /// physical framebuffer -- the exact "blurry ... glyphs drawn at
    /// logical size and stretched by the scale" Iris reported next.
    /// Resolving `dp` at layout time replaces it: a widget author writes
    /// `dp(16)` for a size that should look the same physical size on any
    /// density, and everything downstream (layout, hit-testing, the window
    /// uniform, and the font size handed to the text shaper) works in the
    /// display's own physical pixels throughout, so nothing is
    /// rasterised at one resolution and displayed at another.
    pub content_scale: f32,
    /// The last insets `render()` saw -- compared each frame so
    /// `AndroidAppState::on_insets_changed` fires only when they actually
@@ -154,21 +166,26 @@ pub trait AndroidAppState: HasAndroidUiState {
    /// (RUST.md's P0 box: "the status-bar inset is not applied" reported
    /// the two top buttons sitting under it, because nothing read `.top`
    /// at all), and again on a rotation or the keyboard opening/closing.
-    /// `insets` is in the same *logical* units `content_scale` converts
+    /// `insets` is in the same physical-pixel units everything else in the
-    /// everything else to (physical / `content_scale`), so a widget can add
+    /// tree now uses (`AndroidUiState::content_scale`'s field comment), so
-    /// it to a layout size directly. The default does nothing -- most
+    /// a widget can add it to a layout size directly -- `dp(...) +
-    /// screens have no chrome that sits under a system bar.
+    /// abs(insets.top)` if the widget wants a density-independent size
    /// plus the system bar's own (already-physical) height. The default
    /// does nothing -- most screens have no chrome that sits under a
    /// system bar.
    #[allow(unused_variables)]
-    fn on_insets_changed(&mut self, rsc: &mut AndroidRsc<Self>, insets: LogicalInsets) {}
+    fn on_insets_changed(&mut self, rsc: &mut AndroidRsc<Self>, insets: WindowInsets) {}
 }
-/// `insets::Insets`, converted from physical to logical units -- see
+/// `insets::Insets` as `f32`, for the widget-facing callback above -- a
-/// `AndroidUiState::content_scale`'s field comment. A distinct type from
+/// distinct type from `insets::Insets` so a caller of `on_insets_changed`
-/// `insets::Insets` (rather than dividing in place) so a reader at the call
+/// is not coupled to that module's own (`i32`, JNI-shaped) representation.
-/// site can tell which unit a value is already in without checking where it
+/// Both are physical pixels; this used to divide by `content_scale` into a
-/// came from.
+/// separate *logical* unit (hence the old name, `LogicalInsets`), back when
 /// the rest of layout was logical too -- see `AndroidUiState::content_scale`'s
 /// field comment for why that stopgap is gone.
 #[derive(Clone, Copy, Default, Debug, PartialEq)]
-pub struct LogicalInsets {
+pub struct WindowInsets {
    pub left: f32,
    pub top: f32,
    pub right: f32,
@@ -176,14 +193,14 @@ pub struct LogicalInsets {
    pub ime_bottom: f32,
 }
-impl LogicalInsets {
+impl WindowInsets {
-    fn from_physical(insets: Insets, content_scale: f32) -> Self {
+    fn from_physical(insets: Insets) -> Self {
        Self {
-            left: insets.left as f32 / content_scale,
+            left: insets.left as f32,
-            top: insets.top as f32 / content_scale,
+            top: insets.top as f32,
-            right: insets.right as f32 / content_scale,
+            right: insets.right as f32,
-            bottom: insets.bottom as f32 / content_scale,
+            bottom: insets.bottom as f32,
-            ime_bottom: insets.ime_bottom as f32 / content_scale,
+            ime_bottom: insets.ime_bottom as f32,
        }
    }
 }
@@ -343,10 +360,9 @@ impl<State: AndroidAppState> IrisViewPeer<State> {
        let ui_state = self.state.android_state();
        let current_insets = ui_state.insets();
        if current_insets != ui_state.last_insets {
-            let content_scale = ui_state.content_scale;
+            let physical = WindowInsets::from_physical(current_insets);
            let logical = LogicalInsets::from_physical(current_insets, content_scale);
            self.state.android_state_mut().last_insets = current_insets;
-            self.state.on_insets_changed(&mut self.rsc, logical);
+            self.state.on_insets_changed(&mut self.rsc, physical);
        }
        let ui_state = self.state.android_state();
@@ -504,16 +520,10 @@ impl<State: AndroidAppState> ViewPeer for IrisViewPeer<State> {
    ) -> bool {
        self.drain_tasks();
        let action = event.action_masked(&mut ctx.env);
-        // Device (physical) pixels, same as every other Android coordinate
+        // Device (physical) pixels, same space layout now uses throughout
-        // -- divided so a touch lands in the same *logical* space layout
+        // -- see `AndroidUiState::content_scale`'s field comment.
-        // now uses (`AndroidUiState::content_scale`'s field comment).
+        let x = event.x(&mut ctx.env);
-        // Without this, `window_size()` reporting logical dims while touch
+        let y = event.y(&mut ctx.env);
        // stayed physical would land every tap off by exactly the density
        // factor on any phone denser than 1x.
        let ui_state = self.state.android_state();
        let content_scale = ui_state.content_scale;
        let x = event.x(&mut ctx.env) / content_scale;
        let y = event.y(&mut ctx.env) / content_scale;
        let ui_state = self.state.android_state_mut();
        match action {
            MotionAction::Down => {
@@ -564,7 +574,6 @@ impl<State: AndroidAppState> ViewPeer for IrisViewPeer<State> {
        height: i32,
    ) {
        self.drain_tasks();
        let window = holder.surface(&mut ctx.env).to_native_window(&mut ctx.env);
        // The layout engine's own notion of the canvas size is separate
        // from the wgpu surface's -- winit's backend sets it from
        // `WindowEvent::Resized`, and there is no equivalent automatic
@@ -574,29 +583,55 @@ impl<State: AndroidAppState> ViewPeer for IrisViewPeer<State> {
        // whatever size `UiRenderState::new` starts at instead of the
        // surface's real one.
        //
-        // **Logical, not physical** -- `content_scale`'s field comment on
+        // **Physical pixels, matching `AndroidRenderer`'s own
-        // `AndroidUiState`. This call sets `UiRenderState::output_size`,
+        // `size()`/`resize()`/`new()`** -- `AndroidUiState::content_scale`'s
-        // which is what every widget's absolute `PixelRegion` (a fixed
+        // field comment. This call sets `UiRenderState::output_size`, which
-        // `.height(56)`, in particular) is computed against; `AndroidRenderer`'s
+        // every `rel`/`rest` length resolves against and every `abs`
-        // own `size()`/`resize()`/`new()` already report logical dimensions
+        // pixel-region compares to directly; a `dp(56)` height now folds
-        // to the *shader*'s window uniform, so leaving this call on raw
+        // in the density at `Len::apply_rest` time instead of this call
-        // physical `width`/`height` split the two into different units --
+        // dividing the whole window into a separate logical space, which
-        // layout placed a "56"-unit-tall row in an ~2219-tall physical
+        // is what used to make every `abs`-unit size (a fixed `.height(56)`
-        // canvas (an absolute, correctly-56-unit box), the shader then
+        // in particular) mean something different from a `rest`-based one.
-        // divided that same 56 by a ~845-unit *logical* window dimension,
+        self.render.resize((width as f32, height as f32));
-        // and the row rendered far too short rather than too tall or
+
-        // right, because a fixed-size item's absolute unit value never
+        // **Reuse the existing renderer (device, atlas, buffers, bind
-        // adapts to the mismatch the way a `rest(n)`-proportional one
+        // groups) when one is already live -- only reconfigure the
-        // does. Found by measuring a fresh install's top button row at
+        // surface.** `surfaceChanged` fires on *every* size or format
-        // ~40 physical px instead of the ~147px `56 * content_scale`
+        // change, not only on a genuinely new `Surface`/window: showing
-        // predicts, immediately after the density fix below was added.
+        // the IME under `adjustResize` resizes the same `SurfaceView` and
-        let content_scale = self.state.android_state().content_scale;
+        // is reported through this exact callback. Rebuilding the whole
-        self.render
+        // `AndroidRenderer` here used to mean a fresh `UiRenderNode::new`
-            .resize((width as f32 / content_scale, height as f32 / content_scale));
+        // -- a brand-new, empty glyph atlas and fresh GPU buffers -- while
-        // Drop the old renderer (and the surface it owns) before building
+        // `iris_core`'s CPU-side glyph cache (`primitive/text.rs`) kept the
-        // one from the new window -- see `AndroidRenderer`'s doc comment.
+        // atlas coordinates it had already handed out against the *old*
        // atlas. Every glyph then drew from a UV rectangle that pointed
        // into a texture that had just been recreated empty, so text
        // vanished on the first keyboard open while rects (which never go
        // through the atlas) kept drawing -- exactly the "rectangles stay,
        // glyphs disappear" Iris reported. Confirmed by reading this path
        // end to end (no fresh-atlas rebuild anywhere in `resize()` below,
        // only in `AndroidRenderer::new`) before changing anything, per
        // AGENTS.md's "verify before finishing".
        //
        // `AndroidRenderer::resize` only reconfigures the wgpu surface and
        // rewrites the window uniform -- device, atlas, buffers and bind
        // groups are untouched, so the glyph cache's coordinates stay
        // valid. A genuinely new surface (after `surface_destroyed`, e.g.
        // backgrounding) still goes through `AndroidRenderer::new` below,
        // since `renderer` is `None` in that case.
        let already_live = self.state.android_state().renderer.is_some();
        if already_live {
            let ui_state = self.state.android_state_mut();
-        ui_state.renderer = None;
+            ui_state
                .renderer
                .as_mut()
                .expect("checked Some above")
                .resize(width as u32, height as u32);
            self.render(ctx);
            return;
        }
        let window = holder.surface(&mut ctx.env).to_native_window(&mut ctx.env);
        // `AndroidRenderer::new` used to panic here through wgpu's own
        // default uncaptured-error handler on a bind-group-layout
        // validation failure -- exactly what aborted the P0 bench APK on
@@ -607,6 +642,11 @@ impl<State: AndroidAppState> ViewPeer for IrisViewPeer<State> {
        // the one place in the app that can turn it into something a
        // person can read, since `ctx.view`/`ctx.env` (needed to reach the
        // Java side) are only in scope inside a `ViewPeer` callback.
        //
        // `content_scale` reaches `AndroidRenderer` only for the
        // Diagnostics page's report text now -- window size and the
        // shader's window uniform are physical pixels throughout (see the
        // `resize` call above), not divided by it.
        let content_scale = self.state.android_state().content_scale;
        match AndroidRenderer::new(window, width as u32, height as u32, content_scale) {
            Ok(renderer) => {
@@ -771,15 +811,22 @@ pub fn new_peer<'local, State: AndroidAppState>(
        state: Default::default(),
        _state: PhantomData,
    };
    // See `TextData::density`'s field doc for why this is set alongside
    // `render.set_density` below rather than read from there.
    rsc.ui.text.density = content_scale;
    let shared = Rc::new(RefCell::new(Shared::default()));
    let ui_state = AndroidUiState::new(shared.clone(), content_scale);
    let mut state = State::new(ui_state, &mut rsc);
    let platform_vm = env.get_java_vm().unwrap();
    let platform_view = env.new_global_ref(&view.0).unwrap();
    state.platform_ready(&mut rsc, platform_vm, platform_view);
    let mut render = UiRenderState::new();
    // Every `Len::dp` in the tree resolves against this from now on -- see
    // `UiRenderState::density`'s field doc and `Len::dp`'s.
    render.set_density(content_scale);
    let peer = IrisViewPeer {
        rsc,
-        render: UiRenderState::new(),
+        render,
        state,
        task_recv,
    };
@@ -489,6 +489,24 @@ impl List {
        true
    }
    /// The anchor's own row index and pixel offset, formatted the same
    /// shape Compose's `firstVisibleItemIndex`/`firstVisibleItemScrollOffset`
    /// report (`idx=N/off=Mpx`) -- what RUST.md's "Benchmark v2" fling
    /// phase reads before/after/between its fling runs so the two apps'
    /// travel can be compared directly. `more_before`/`more_after`
    /// sentinels print as `idx=more-before`/`idx=more-after` rather than
    /// leaking their internal `isize` representation; `idx=none` if the
    /// list has never drawn (no anchor yet -- e.g. right after
    /// `jump_to_end` and before the next frame runs `repair_anchor`).
    pub fn anchor_position_display(&self) -> String {
        match self.anchor {
            None => "idx=none".to_string(),
            Some(a) if a.slot == BEFORE_SLOT => "idx=more-before".to_string(),
            Some(a) if a.slot == AFTER_SLOT => "idx=more-after".to_string(),
            Some(a) => format!("idx={}/off={}px", a.slot, a.offset.round() as i64),
        }
    }
    /// Snap to the newest content (last item, or the `more_after`
    /// sentinel if set), bottom-aligned to the viewport. O(1).
    pub fn jump_to_end(&mut self) {
@@ -734,9 +752,10 @@ impl List {
        let axis = self.axis;
        let output_len = painter.output_size().axis(axis);
        let container_len = painter.region().axis(axis).len();
        let density = painter.density();
        let resolve = move |used: Size| -> f32 {
            used.axis(axis)
-                .apply_rest()
+                .apply_rest(density)
                .within_len(container_len)
                .to_abs(output_len)
        };
@@ -1455,4 +1474,22 @@ mod tests {
            first.top
        );
    }
    #[test]
    fn anchor_position_display_before_any_draw_is_none() {
        let list = List::new(Axis::Y);
        assert_eq!(list.anchor_position_display(), "idx=none");
    }
    #[test]
    fn anchor_position_display_reports_slot_and_offset() {
        let mut rsc = TestRsc {
            ui: UiData::default(),
        };
        let (list_weak, root, mut render) = build_flingable_list(&mut rsc);
        let _ = (&root, &mut render);
        let list_ref = rsc.ui.widgets.get(&list_weak).unwrap();
        assert!(list_ref.anchor_position_display().starts_with("idx="));
        assert!(!list_ref.anchor_position_display().contains("none"));
    }
 }
@@ -17,14 +17,15 @@ impl Widget for Aligned {
        // already-resolved region double-applies that composition and is
        // wrong for any widget nested below the root.
        let used = painter.widget(&self.inner);
        let density = painter.density();
        let region = match self.align.tuple() {
-            (Some(x), Some(y)) => used.to_uivec2().align(RegionAlign { x, y }),
+            (Some(x), Some(y)) => used.to_uivec2(density).align(RegionAlign { x, y }),
            (Some(x), None) => {
-                let x = used.x.apply_rest().align(x);
+                let x = used.x.apply_rest(density).align(x);
                UiRegion::new(x, UiSpan::FULL)
            }
            (None, Some(y)) => {
-                let y = used.y.apply_rest().align(y);
+                let y = used.y.apply_rest(density).align(y);
                UiRegion::new(UiSpan::FULL, y)
            }
            (None, None) => UiRegion::FULL,
@@ -9,12 +9,12 @@ pub struct MaxSize {
 impl MaxSize {
    /// Caps a reported length at `max`, comparing in pixels since `Len`'s
    /// rel/abs/rest components are not otherwise comparable.
-    fn clamp(len: Len, max: Option<Len>, output: f32) -> Len {
+    fn clamp(len: Len, max: Option<Len>, output: f32, density: f32) -> Len {
        let Some(max) = max else {
            return len;
        };
-        let len_px = len.apply_rest().to_abs(output);
+        let len_px = len.apply_rest(density).to_abs(output);
-        let max_px = max.apply_rest().to_abs(output);
+        let max_px = max.apply_rest(density).to_abs(output);
        if len_px > max_px { max } else { len }
    }
@@ -24,11 +24,11 @@ impl MaxSize {
    /// start, if it does not. Needed so the child is never painted bigger
    /// than the size this widget reports for it -- see the identical
    /// requirement noted on `Sized::draw`.
-    fn clamp_region(offered_px: f32, max: Option<Len>, output: f32) -> UiSpan {
+    fn clamp_region(offered_px: f32, max: Option<Len>, output: f32, density: f32) -> UiSpan {
        let Some(max) = max else {
            return UiSpan::FULL;
        };
-        let max_scalar = max.apply_rest();
+        let max_scalar = max.apply_rest(density);
        let max_px = max_scalar.to_abs(output);
        if offered_px > max_px {
            max_scalar.align(AxisAlign::Neg)
@@ -41,15 +41,16 @@ impl MaxSize {
 impl Widget for MaxSize {
    fn draw(&mut self, painter: &mut Painter) -> Size {
        let output = painter.output_size();
        let density = painter.density();
        let offered = painter.px_size();
        let region = UiRegion {
-            x: Self::clamp_region(offered.x, self.x, output.x),
+            x: Self::clamp_region(offered.x, self.x, output.x, density),
-            y: Self::clamp_region(offered.y, self.y, output.y),
+            y: Self::clamp_region(offered.y, self.y, output.y, density),
        };
        let used = painter.widget_within(&self.inner, region);
        Size {
-            x: Self::clamp(used.x, self.x, output.x),
+            x: Self::clamp(used.x, self.x, output.x, density),
-            y: Self::clamp(used.y, self.y, output.y),
+            y: Self::clamp(used.y, self.y, output.y, density),
        }
    }
 }
@@ -7,9 +7,12 @@ pub struct Pad {
 impl Widget for Pad {
    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let used = painter.widget_within(&self.inner, self.padding.region());
+        let density = painter.density();
-        let width = self.padding.left + self.padding.right;
+        let used = painter.widget_within(&self.inner, self.padding.region(density));
-        let height = self.padding.top + self.padding.bottom;
+        let width =
            self.padding.left.apply_rest(density).abs + self.padding.right.apply_rest(density).abs;
        let height =
            self.padding.top.apply_rest(density).abs + self.padding.bottom.apply_rest(density).abs;
        Size {
            x: used.x + Len::abs(width),
            y: used.y + Len::abs(height),
@@ -17,23 +20,29 @@ impl Widget for Pad {
    }
 }
 /// Each side is a `Len`, not a bare `f32`, so `.pad(dp(10))` resolves
 /// against the display's density the same way any other size does -- see
 /// `Len::dp`'s field doc. `.pad(10)` (a bare number) still works via
 /// `From<T: UiNum>` below, unchanged: it becomes an `abs` (physical-pixel)
 /// `Len`, exactly as a bare number always has meant elsewhere in this
 /// crate.
 pub struct Padding {
-    pub left: f32,
+    pub left: Len,
-    pub right: f32,
+    pub right: Len,
-    pub top: f32,
+    pub top: Len,
-    pub bottom: f32,
+    pub bottom: Len,
 }
 impl Padding {
    pub const ZERO: Self = Self {
-        left: 0.0,
+        left: Len::ZERO,
-        right: 0.0,
+        right: Len::ZERO,
-        top: 0.0,
+        top: Len::ZERO,
-        bottom: 0.0,
+        bottom: Len::ZERO,
    };
-    pub fn uniform(amt: impl UiNum) -> Self {
+    pub fn uniform(amt: impl Into<Len>) -> Self {
-        let amt = amt.to_f32();
+        let amt = amt.into();
        Self {
            left: amt,
            right: amt,
@@ -41,80 +50,84 @@ impl Padding {
            bottom: amt,
        }
    }
-    pub fn region(&self) -> UiRegion {
+    pub fn region(&self, density: f32) -> UiRegion {
        let mut region = UiRegion::FULL;
-        region.x.start.abs += self.left;
+        region.x.start.abs += self.left.apply_rest(density).abs;
-        region.y.start.abs += self.top;
+        region.y.start.abs += self.top.apply_rest(density).abs;
-        region.x.end.abs -= self.right;
+        region.x.end.abs -= self.right.apply_rest(density).abs;
-        region.y.end.abs -= self.bottom;
+        region.y.end.abs -= self.bottom.apply_rest(density).abs;
        region
    }
-    pub fn x(amt: impl UiNum) -> Self {
+    pub fn x(amt: impl Into<Len>) -> Self {
-        let amt = amt.to_f32();
+        let amt = amt.into();
        Self {
            left: amt,
            right: amt,
-            top: 0.0,
+            top: Len::ZERO,
-            bottom: 0.0,
+            bottom: Len::ZERO,
        }
    }
-    pub fn y(amt: impl UiNum) -> Self {
+    pub fn y(amt: impl Into<Len>) -> Self {
-        let amt = amt.to_f32();
+        let amt = amt.into();
        Self {
-            left: 0.0,
+            left: Len::ZERO,
-            right: 0.0,
+            right: Len::ZERO,
            top: amt,
            bottom: amt,
        }
    }
-    pub fn top(amt: impl UiNum) -> Self {
+    pub fn top(amt: impl Into<Len>) -> Self {
        let mut s = Self::ZERO;
-        s.top = amt.to_f32();
+        s.top = amt.into();
        s
    }
-    pub fn bottom(amt: impl UiNum) -> Self {
+    pub fn bottom(amt: impl Into<Len>) -> Self {
        let mut s = Self::ZERO;
-        s.bottom = amt.to_f32();
+        s.bottom = amt.into();
        s
    }
-    pub fn left(amt: impl UiNum) -> Self {
+    pub fn left(amt: impl Into<Len>) -> Self {
        let mut s = Self::ZERO;
-        s.left = amt.to_f32();
+        s.left = amt.into();
        s
    }
-    pub fn right(amt: impl UiNum) -> Self {
+    pub fn right(amt: impl Into<Len>) -> Self {
        let mut s = Self::ZERO;
-        s.right = amt.to_f32();
+        s.right = amt.into();
        s
    }
-    pub fn with_top(mut self, amt: impl UiNum) -> Self {
+    pub fn with_top(mut self, amt: impl Into<Len>) -> Self {
-        self.top = amt.to_f32();
+        self.top = amt.into();
        self
    }
-    pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
+    pub fn with_bottom(mut self, amt: impl Into<Len>) -> Self {
-        self.bottom = amt.to_f32();
+        self.bottom = amt.into();
        self
    }
-    pub fn with_left(mut self, amt: impl UiNum) -> Self {
+    pub fn with_left(mut self, amt: impl Into<Len>) -> Self {
-        self.left = amt.to_f32();
+        self.left = amt.into();
        self
    }
-    pub fn with_right(mut self, amt: impl UiNum) -> Self {
+    pub fn with_right(mut self, amt: impl Into<Len>) -> Self {
-        self.right = amt.to_f32();
+        self.right = amt.into();
        self
    }
 }
-impl<T: UiNum> From<T> for Padding {
+/// Covers both a bare number (`.pad(8)`, via `Len`'s own `From<N: UiNum>`
 /// blanket -- an `abs`/physical-pixel `Len`) and a `Len` directly
 /// (`.pad(dp(10))`) with the one impl, since `Len: Into<Len>` is the
 /// reflexive case of the same bound.
 impl<T: Into<Len>> From<T> for Padding {
    fn from(amt: T) -> Self {
-        Self::uniform(amt.to_f32())
+        Self::uniform(amt.into())
    }
 }
@@ -43,7 +43,7 @@ impl Widget for Scroll {
        self.content_len = used
            .axis(axis)
-            .apply_rest()
+            .apply_rest(painter.density())
            .within_len(container_len)
            .to_abs(output_len);
@@ -17,12 +17,13 @@ impl Widget for Sized {
        // learn its size, then moves it into place with a pure
        // translation; that translation is only valid if what got painted
        // is already the reported size, anchored the same way both times.
        let density = painter.density();
        let mut region = UiRegion::FULL;
        if let Some(x) = self.x {
-            region.x = x.apply_rest().align(AxisAlign::Neg);
+            region.x = x.apply_rest(density).align(AxisAlign::Neg);
        }
        if let Some(y) = self.y {
-            region.y = y.apply_rest().align(AxisAlign::Neg);
+            region.y = y.apply_rest(density).align(AxisAlign::Neg);
        }
        let used = painter.widget_within(&self.inner, region);
        Size {
@@ -4,12 +4,18 @@ use std::marker::PhantomData;
 pub struct Span {
    pub children: Vec<StrongWidget>,
    pub dir: Dir,
-    pub gap: f32,
+    /// A `Len` (not a bare `f32`) so `dp(4)` resolves against the display's
    /// density the same way any other size in the tree does -- see
    /// `Len::dp`'s field doc. Only the `abs` component (folded from `dp` at
    /// draw time, `Widget::draw` below) is meaningful here; `rel`/`rest`
    /// were never supported for a gap and still are not.
    pub gap: Len,
 }
 impl Widget for Span {
    fn draw(&mut self, painter: &mut Painter) -> Size {
        let axis = self.dir.axis;
        let gap = self.gap.apply_rest(painter.density()).abs;
        // Phase 1: draw each child once, at the ambient (unmodified, full)
        // region a size-only query used to see before this migration, to
@@ -25,7 +31,7 @@ impl Widget for Span {
            .map(|child| painter.widget(child).axis(axis))
            .collect();
-        let gap_total = self.gap * self.children.len().saturating_sub(1) as f32;
+        let gap_total = gap * self.children.len().saturating_sub(1) as f32;
        let total = lens.iter().fold(Len::abs(gap_total), |s, &l| s + l);
        // Phase 2: place each child for real, using the lengths just
@@ -54,7 +60,7 @@ impl Widget for Span {
                child_region.flip(axis);
            }
            let used = painter.widget_within(child, child_region);
-            start.abs += self.gap;
+            start.abs += gap;
            let ortho = used.axis(!axis);
            if ortho.rel > 0.0 || ortho.rest > 0.0 {
@@ -82,12 +88,12 @@ impl Span {
        Self {
            children: Vec::new(),
            dir,
-            gap: 0.0,
+            gap: Len::ZERO,
        }
    }
-    pub fn gap(mut self, gap: impl UiNum) -> Self {
+    pub fn gap(mut self, gap: impl Into<Len>) -> Self {
-        self.gap = gap.to_f32();
+        self.gap = gap.into();
        self
    }
@@ -103,7 +109,7 @@ impl Span {
 pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
    pub children: Wa,
    pub dir: Dir,
-    pub gap: f32,
+    pub gap: Len,
    _pd: PhantomData<(State, Tag)>,
 }
@@ -129,13 +135,13 @@ impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
        Self {
            children,
            dir,
-            gap: 0.0,
+            gap: Len::ZERO,
            _pd: PhantomData,
        }
    }
-    pub fn gap(mut self, gap: impl UiNum) -> Self {
+    pub fn gap(mut self, gap: impl Into<Len>) -> Self {
-        self.gap = gap.to_f32();
+        self.gap = gap.into();
        self
    }
 }
@@ -141,7 +141,8 @@ impl<'a> TextEditCtx<'a> {
    fn layout(&mut self) -> &Layout<UiColor> {
        let attrs = self.text.view.attrs.clone();
        let width = self.text.view.wrap_width();
-        self.text.view.buf.shape(self.data, &attrs, width);
+        let density = self.data.density;
        self.text.view.buf.shape(self.data, &attrs, width, density);
        self.text.view.buf.layout()
    }
@@ -39,7 +39,7 @@ where
        .label("Message")
        .add(rsc);
-    let bar: WeakWidget = (field.pad(12).width(rest(1)),)
+    let bar: WeakWidget = (field.pad(dp(12)).width(rest(1)),)
        .span(Dir::RIGHT)
        .background(rect(UiColor::new(40, 40, 46, 255)))
        .add(rsc);
@@ -174,8 +174,8 @@ where
    (header, field.width(rest(1)))
        .span(Dir::DOWN)
-        .gap(4)
+        .gap(dp(4))
-        .pad(10)
+        .pad(dp(10))
        .add_strong(rsc)
        .any()
 }
Author	SHA1	Message	Date
irisandClaude Fable 5.1	03c6be80a3	iris android-app: header-duplicate investigation, ime-inset fix for keyboard confirmation Two follow-ups after the keyboard/dp/header pass, both requested against the P0 box: (a) The header row rendering a second time inside the transcript area after a keyboard-triggered resize: reproduced reliably (tap the composer, screenshot after the keyboard opens). Ruled out one concrete hypothesis -- on_insets_changed rebuilding top_bar on every ime_bottom change, unrelated to the header's own status-bar padding -- with a guard (last_top_pad) that reproduced the identical duplicate afterward, so repeated rebuilding is not the cause. Kept the guard as a real (if insufficient) fix for needless rebuilds. Not root-caused: Span's two-phase provisional/real draw and the redraw_all-vs-redraw_updates split are the two live suspects, but pinning which one (or something else) produces the duplicate needs instrumenting draw_inner directly or the phone. Full writeup in RUST.md's P0 box. (b) Why on_insets_changed's ime_bottom never confirmed the keyboard being shown, on either the auto-diagnostics or the new bench keyboard phase: MainActivity.java uses windowSoftInputMode="adjustResize", under which WindowInsets.Type.ime()'s own inset amount is defined to read zero (the window already resized to avoid the overlap that inset would describe) -- the same trap AGENTS.md already names for the Compose side. Fixed to read insets.isVisible(ime()) instead, a boolean unaffected by resize-vs-pan. This alone did not make the callback re-fire on this emulator, which still shows no insets callback after the initial one at attach -- named but unconfirmed hypothesis: a non-edge-to-edge Activity may not get insets redelivered for a pure IME toggle handled via resize, needing an edge-to- edge opt-in this pass did not attempt given the risk to adjustResize's own behavior. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 01:23:36 -04:00
iris	4afc453faa	Merge remote-tracking branch 'origin/rustify' into worktree-agent-a16b22e34539b810e # Conflicts: # iris/android-app/src/bench_client.rs # iris/android-app/src/bench_jni.rs	2026-09-06 01:05:18 -04:00
irisandClaude Fable 5.1	1aab61bf26	iris android-app: Benchmark v2 -- fling, type and keyboard phases Implements RUST.md's "Benchmark v2" spec in bench_client.rs: fling (8 out + 8 back at 12,000px/s through List::fling, waits for !is_scrolling() capped 3s, reports travel as row index + offset via List's new anchor_position_display), stream (unchanged), type (the 600-char P0 constant, one char per 50ms into the composer's real TextEdit via .set(), then deleted), and keyboard (5 show/hide cycles via bench_jni.rs's new InputMethodManager calls, confirmed from on_insets_changed's real ime_bottom transitions rather than assumed from the JNI call returning). FrameReport gained mark_phase/phase_stats/late_at_hz (iris/core) so the report can show a per-phase block (frames, late%, p50/p90/p99, worst) against the display's real refresh rate (bench_jni's new refresh_rate_hz), matching the shape docs/bench/compose-phone-v2 uses. RING_CAPACITY bumped 4096->16384 since a full v2 run is ~3,000+ frames. Found and fixed a real deadlock while wiring this up: read_from_state (a new helper that gets a value back out of a spawned task's ctx.update, which has no return channel of its own) only worked for its first call in a chain, because nothing called redraw.request_redraw() after enqueueing later ones -- nothing then drains the task channel to run them. Every call now triggers its own redraw. Verified end to end on this checkout's x86_64 emulator (force-gles, cold boot): fling/stream/type all report populated phase blocks; keyboard's show never got a real on_insets_changed confirmation this run (see follow-up work). Full report and travel numbers go in RUST.md's P0 box next. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 01:02:04 -04:00
iris	dc01f88d75	Merge branch 'worktree-agent-a1ff0294b6c29127e' into tmp-merge	2026-09-06 00:54:21 -04:00
iris	c589a75fa0	Merge remote-tracking branch 'origin/rustify' into worktree-agent-a1ff0294b6c29127e # Conflicts: # docs/RUST.md	2026-09-06 00:54:06 -04:00
irisandClaude Fable 5.1	4b62cc642e	docs/RUST.md: emulator verification results for the keyboard/dp/header fixes run-bench.sh end to end clean (24/24 swipes, 400/400 events); header background confirmed by screenshot; the keyboard wipe fix confirmed two ways (a forced wm size resize and an actual soft-keyboard open, both real surface_changed triggers, text intact both times). Also records two things found during this verification and not fixed: the top button row appears to render a second time, out of place, after a keyboard-triggered resize, and a tap aimed at the field below can land on it instead -- and the keyboard diagnostics auto-capture never fired in this session. Neither is root-caused; explicitly not attributed to this pass's changes without more evidence, per the standing rule against blaming ambient failures on your own code without measuring first. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:51:27 -04:00
irisandClaude Fable 5.1	80c2eadec9	docs: record the keyboard-wipe fix, the dp unit and the header fix docs/IRIS.md's 2026-09-06 entry (public API), docs/LAYOUT.md's "Density: Len::dp" design section, IRIS_TODO.md's density-unit item ticked, and docs/RUST.md's P0 box gets the investigation: the keyboard-wipe hypothesis and confirmation, the blur root cause and why the dp unit turned out to be the same fix, the header cause, and what remains unverified (an emulator screenshot of the keyboard fix, and Iris's real phone). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:40:59 -04:00
irisandClaude Fable 5.1	0b587629e6	iris/android-app bench: auto-capture diagnostics when the keyboard opens So Iris can get a report off the phone even if the keyboard wipe (or some other keyboard-triggered regression) is still present on whatever build she is holding, independent of whether the on-screen Diagnostics button itself is drawing. on_insets_changed edge-triggers on ime_bottom becoming non-zero, waits KEYBOARD_DIAGNOSTICS_DELAY_MS (500ms, long enough for the resize and a couple of frames to settle) via a spawned task, then capture_keyboard_diagnostics reuses show_diagnostics's exact report text, logs it, copies it to the clipboard unprompted, and shows it through a new PlatformHandle::show_diagnostics_overlay call into IrisView.showDiagnosticsOverlay -- a plain TextView + Copy/Close panel added over the existing IrisView (not replacing it, unlike showRendererError's one-way trip) so it draws independently of whatever iris's own renderer is doing, and Close returns to the still-running session underneath. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:39:14 -04:00
irisandClaude Fable 5.1	3163256d2c	iris/android-app: opaque header background, header sizes onto dp Iris's phone report (build a9232ac): "the header buttons have nothing behind them and overlap the transcript text." Only each button's own rect painted anything, so the gaps between and around them (and the status-bar strip above) showed CLEAR_COLOR (black) one layer back, and the row's reserved height was three abs (physical-pixel) button boxes -- smaller, on a dense phone, than the dp-correct size the transcript below now uses post the previous two commits, which is what reads as overlap once the two disagree. Fixed with a HEADER_SURFACE rect stacked behind the whole button row (not just behind each button), and every non-text size in the header (button padding, row height, the report field's padding) moved from a bare number to dp(...), so the row's reserved height in the outer Span::DOWN matches what is actually painted. The list/report field already sit below the header in that same Span::DOWN, not behind it -- no stacking change needed there. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:35:45 -04:00
irisandClaude Fable 5.1	6102e0d4d9	iris: a dp length unit, resolved against density; crisp glyphs at physical size Iris asked for this 2026-09-06 (IRIS_TODO.md, "a third length kind beside relative and pixels ... a unit resolved against the display's density at layout time"): before this, a Len was abs (physical pixels) or rel/rest (a fraction of the parent), and the only way to make a design size look the same physical size on a denser display was a single global multiply applied after layout -- which the previous commit found is also what made text blurry. Len gains a `dp` field, resolved against a `density: f32` (physical pixels per dp) now carried on UiRenderState/Painter (`UiRenderState::set_density`/`density()`, `Painter::density()`) and threaded through every `apply_rest`/`to_uivec2` call site. `len_fns::dp` / `Len::dp` construct one, exactly parallel to the existing `abs`/`rel`/ `rest`. A bare number is unaffected (still `abs`, physical pixels) -- `dp` is opt-in. Text: `TextBuffer::shape` now takes `density` and multiplies `font_size`/`line_height` (and any span override) by it before handing them to parley, so the size that reaches the shaper and the rasteriser (`TextData::place`) is the display's real physical size -- the atlas holds a bitmap at the resolution it is actually shown at, instead of a low-resolution one stretched afterward. `GlyphKey.size` already keys on the resolved `font_size`, so a cache entry is naturally per physical size with no further change. `TextData` also carries its own `density` copy for `TextEditCtx::layout` (cursor movement/hit-testing), which shapes text from an input callback with no `Painter` to read it from. `Span::gap` and `Padding`'s four sides move from bare `f32` to `Len`, so `.gap(dp(4))`/`.pad(dp(10))` work the same way any other size does; a bare number still means physical pixels, unchanged. Migrated transcript-ui's non-text sizes (row gap/padding, composer padding) and one example to the new unit, per IRIS_TODO.md's "done when" list. Android's own density (`DisplayMetrics.density`) is wired to both copies in `new_peer`; the winit backend has no per-monitor density wired up yet and stays at the default (1.0). docs/IRIS.md, docs/LAYOUT.md and IRIS_TODO.md updated next. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:35:38 -04:00
irisandClaude Fable 5.1	f0da383e28	iris/android: reuse the renderer across a surface resize, fix the keyboard glyph wipe Hypothesis confirmed by reading the path end to end before changing anything: surface_changed fires on every SurfaceView size/format change, not only a genuinely new Surface -- showing the IME under adjustResize resizes the same surface through this exact callback. The handler unconditionally dropped AndroidRenderer and rebuilt it via AndroidRenderer::new, which allocates a brand-new, empty glyph atlas and fresh GPU buffers, while iris_core's CPU-side glyph cache kept the UV coordinates it had already handed out against the old atlas -- so every glyph drew from a rectangle pointing into a texture that had just been recreated empty. Rects never go through the atlas, so they kept drawing: exactly Iris's report ("rectangles stay; only text disappears"). Fixed by reusing the existing AndroidRenderer (device, atlas, buffers, bind groups) and only reconfiguring the surface + window uniform via its existing resize() when a renderer is already live; AndroidRenderer::new now runs only when surface_changed finds `renderer` already None (a genuinely new surface, e.g. after surface_destroyed/backgrounding). While in this path, removed the global logical/physical scale stopgap (dividing window size, touch coordinates and insets by content_scale) that the P0 "text too small" fix had added: it is what made text blurry next (a glyph rasterised small then stretched by the NDC mapping onto the real physical framebuffer). Window size, touch and insets are physical pixels throughout now, matching AndroidRenderer's own swapchain resolution; density is resolved per-length instead (next commit). LogicalInsets renamed to WindowInsets to match. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:35:22 -04:00
irisandClaude Fable 5.1	2d3695a1d3	Merge iris fling/jitter fix into rustify Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-06 00:20:39 -04:00