Cut per-frame UI cost and add frame-level profiling

[arizkami]

Why

Playback stuttered on sessions with many plug-ins, and every attempt to fix it
was a guess: the profiler could time this crate's render functions, but those
turned out to be 3 ms of a 32 ms frame. Everything after them — layout, paint,
present — was invisible.

So this branch does two things: it fixes the per-frame costs that measurement
could prove, and it builds the instrumentation that found them.

What the measurements ruled out

Each of these was a plausible cause. All were eliminated with numbers rather
than reasoning:

Hypothesis	Evidence against
Audio and UI threads not separated	Callback is wait-free; plug-ins run out of process
MIDI clip drawing	A nearly empty viewport still took 40 ms
GPU / renderer	present is 0.30 ms
Channel count	The slow session has 31 tracks
Font fallback / text shaping	0.08 ms, 7 cache misses
Accessibility tree	0.04 ms
Too many elements	3,034 layout nodes
Taffy re-measuring	1.2 measure calls per node

What was left: 13.5 ms across 3,637 measure calls — 3.7 us each.

Fixes

Truncated text re-measured every pass. TextLayout::layout refused its own
cached size whenever the style truncated, because a cached layout might have
been built without truncation. Taffy measures a node more than once per frame
and this UI truncates nearly every label it draws. Recording the truncation
width the layout was built with answers that question instead of assuming the
worst; a layout is reused only when it was built for exactly the width being
asked for, so output is unchanged.

Repaint scope. The studio root was notified on playhead motion, so GPUI
re-rendered, re-laid-out, and repainted every panel in the window ~31 times a
second for a bar.beat label that changes twice. It now follows what the chrome
actually displays; the playhead, meters, and status footer already reach their
own isolated entities.

Whole-project clones per row per frame. Lane, clip, automation, and ruler
event closures must own what they read to be 'static, and did so by cloning
the entire TimelineState — every track, clip, and MIDI note — once per visible
row per frame. They now carry only the viewport transform and snap grid.

MIDI clip previews. Resolved into paint-ready geometry during element build,
in one allocation-free pass bounded by visible pixels rather than note count,
and culled to the on-screen slice of the clip.

Meter path. Meters were resolved against the track list with a linear find
each — O(tracks x meters) at the display refresh — and allocated two owned key
strings per plug-in output channel per tick.

Measured in release at the reported scale (2,103 channels):

TimelineState::clone x12 rows   54.30 ms/frame -> 0.003 ms
meter tick (lookup + keys)       3.41 ms       -> 0.32 ms
meter path per second          491 ms/s        -> 47 ms/s

Instrumentation

The Profiler overlay now shows hot scopes, a frame breakdown, the draw split,
and the build stamp of the running executable. Collection follows the overlay
and clears when it closes, so it costs nothing when not in use.

GPUI is patched (recorded in crates/gpui/PATCHED.md) with frame_profile,
reporting draw/present duration, the prepaint/paint/a11y split, layout solve and
measure-callback time, layout node count, and text shaping that missed the
line-layout cache. Cost is a handful of Instant::now() calls per frame.

Also here

The WGPU timeline renderer's clear-only scaffold is replaced with a real
instanced quad pipeline drawing the same primitives as the GPUI paint fallback,
with cached target and buffers. Compositing into GPUI is still pending, so the
paint fallback remains the user-visible path — and the 0.30 ms present time says
this was never where the frame went.

Clip visual geometry moved to render/clip_geometry.rs so the element path and
a future snapshot painter cannot disagree.

Testing

cargo fmt --all -- --check clean; cargo test -p sphere_ui_components --lib
976 passing; cargo check -p futureboard_native clean. New tests cover the
gesture context against the state it replaces, clip preview bounds and pitch
mapping, meter key formatting and generation-based pruning, the repaint rule,
the WGPU instance builder, and a GPU readback of the offscreen pass (skipped
when no adapter is present).

Not verified: the effect of the text-measure fix on a real session. The numbers
above are from release micro-benchmarks at the reported scale and from the
in-app profiler; the last build has not been run yet.

🤖 Generated with Claude Code