[alexandre-vl]

Closes #1004

The problem

A mouse-wheel notch moved content in one jump. GPUI hands non-precise wheels to containers as ScrollDelta::Lines, and they apply them at once, so a 3-line notch scrolls the transcript 60px in a single frame. Chrome on macOS glides the same notch over 200ms. The in-app browser stepped too, because WKWebView applies a non-precise tick at once (120px).

The change

Settings → Appearance → Motion → Smooth scrolling is on by default. It affects mouse wheels only, since trackpads already stream pixels. Reduce motion turns it off, and the row says so.

• smooth_scroll wraps the window root. It takes each notch at the end of the capture phase and replays it over the next frames as fractional Lines slices. Every container keeps its own line height, and a notch travels exactly as far as before: slices sit on a 1/4096-line grid, so they sum exactly.
• Chrome's curve is ported from cc::ScrollOffsetAnimationCurve (kMouseWheel): ease-in-out cubic-bezier(0.42, 0, 0.58, 1) over 200ms, shortening to 100ms for long moves. A notch in flight retargets at the current velocity (UpdateTarget), so a spin is one continuous glide. One departure: a notch against the glide drops the rest of that axis instead of netting it into a target clamped to the scroller, because the root can't see scroller bounds.
• Left raw: precise input; fractional lines outside macOS (X11 reports touchpads that way, and X11, Wayland and Windows report high-resolution wheels that way), since a standard notch there is whole lines; notches with Ctrl, Alt, Cmd or Fn held (zoom stays discrete), and WebView2, which eases notches itself. A click stops a glide.
• In-app browser (macOS): AppKit hands a page its wheel directly, so it never reaches the root. A local event monitor (PageGlide) holds the page's ticks and replays the same glide as precise pixel deltas. WebKit routes those like a trackpad's: to the scroller under the pointer, clamped at its edges.
• Transcript: upward input now breaks the stick-to-bottom pin as it arrives, as use-stick-to-bottom's wheel handler does. Before, the pin broke only when one event moved the view more than 1px, and that check was deferred until after the spring's frame step had pulled the view back. A glided notch up from the bottom of a chat drifted back down. Recording the demo below caught this.

Demo

Both takes get the same notches in the same window: three single notches, then a quick spin. Left: smoothing off (before). Right: on (this PR).

Full resolution at 60fps, real time then ½ speed: smooth-scroll-off-vs-on.mp4

Dark	Light

With Reduce motion on:

Measured offsets for one 3-line notch:

• Transcript (from the recording above): off moves 60px in one frame. On moves 0 → 1 → 3 → 7 → 13 → 20 → 29 → 37 → 47 → 50 → 54 → 58 → 59 → 60px over about 200ms, landing exactly where off does.
• In-app browser (Zeron's real WKWebView, page scrollY after the tick): +14ms 1px · +47ms 11 · +80ms 36 · +114ms 70 · +148ms 99 · +181ms 117 · +197ms 120. Before, all 120px landed at once.

How the media was made

A throwaway fixture (not committed) ran the production Shell against an isolated engine in a real window. It dispatched the same ScrollDelta::Lines notches on the same schedule for both takes and captured every presented frame with its timestamp: about 120Hz while idle, about 60Hz while the transcript re-lays out each frame. The videos are resampled from those timestamps. The stills and frames are composited onto an opaque backdrop, because the frosted theme renders translucent.

Tests

• smooth_scroll (14 tests):
  • the curve's shape and landing, and Chrome's durations;
  • retargeting, checked against Chromium's own unit-test numbers;
  • merging and reversing notches, frame-rate independence, and whole-row accumulators;
  • GPUI fixtures for precise, modified, reduced-motion and raw-region input, interruptions, and an empty notch.
• browser::macos (2 tests): a tick replays in whole pixels to exactly its lines, and the replay is a precise event at the tick's window location.
• transcript::tests::a_glided_notch_leaves_the_bottom_and_stays_where_it_lands fails without the pin fix. The arrival-time escape applies to wheel notches only; precise input keeps its old distance test.
• settings and shell: on by default, persisted as smoothScrolling.
• Full -p zeron-ui --lib --test voice_orb_geometry on this head (macOS): 1898 + 11 passed, 0 failed. The browser-fixture feature (library and browser-fixture example) builds.

Not verified: a physical mouse in the macOS in-app browser, i.e. AppKit's real event routing into the monitor. The replay path was verified in Zeron's real WKWebView with synthetic ticks, because this machine can't post real wheel events.

🤖 Generated with Claude Code

[zeronsh]

Security audit: clean. No network, new hosts, build/CI changes or new crates (objc2-core-graphics was already locked); the only unsafe is AppKit monitor/timer FFI. Media is plain PNG/GIF/H.264 with no metadata or trailing bytes.

Review: precise input, fractional lines off macOS, modified notches and WebView2 pass through untouched. The frame loop stops once a glide lands (on_next_frame is only re-queued while active), so the display link parks. Reduced motion and pause-in-background both turn it off. Every wheel consumer in the app is proportional to its delta, so slicing a notch is safe. The settings row matches its Motion siblings.

Follow-ups pushed: rebased onto main, dropped the unused fixture_wheel hook, added the row to settings search (#1018), and gated #1018's Appshots test to the platforms that show Appshots (it failed on Windows). zeron-ui lib tests are green locally on Linux, on this head and merged with main; macOS and Windows CI are green on e3afc8a.