feat(plot): a figure can keep an empty band to the right of its data

`layout_.axes` reached the viewport's right edge, so the rightmost x tick label -- centred on its tick -- had half of itself outside the plot, and the newest sample's ink landed on the frame. `Plot::set_right_gutter()` reserves a band there, out of the same `1 - kMinAxesShare` allowance the label and title strips are served from, so it can no more squeeze `axes` below the half-viewport floor than they can. `Figure` sets one value on every row, the left gutter's reason: the rows' axes have to end on a common column as well as start on one. Nothing is drawn in the band, so unlike the strips it is a want and never a measurement: no measuring pass, and it cannot feed the layout's fixed point. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
fix: a time label's mantissa cannot reach its own radix
2026-10-05 22:24:27 +02:00 · 2026-10-05 21:31:43 +02:00 · 2026-10-05 18:43:50 +02:00 · 2026-10-05 18:21:16 +02:00 · 2026-10-05 16:12:39 +02:00 · 2026-10-05 14:36:47 +02:00
39 changed files with 2547 additions and 320 deletions
@@ -14,6 +14,11 @@ built on top of it.
 | Qt6 | `plot::qt6` | `adapters/qt6/` |
 | GTK4 | `plot::gtk4` | `adapters/gtk4/` |

+The visible x range is mapped onto sample indices through the series' own x
+(`Series::neighbours()`, a binary search over the real stamps), never through the
+`(x - x0()) / dx()` grid: `dx()` is a *nominal* spacing, and a series whose x is a streamed
+timestamp would otherwise have its draw window land inside the visible range and lose the two
+segments that enter and leave the frame — the empty left and right margins of a zoomed-in view.
 Per-frame rendering cost is O(visible pixels + samples produced since the last frame),
 not O(samples): a trace denser than one sample per pixel is drawn from a min/max LOD
 pyramid rather than from raw samples. The `plot_multiplot_demo` run stages **20,901 GPU
@@ -24,13 +29,27 @@ run touched a GPU, so read it as an upper bound and a record of the software pat

 ## Features

+- a trace whose series answers a *clamped* stamp for its oldest slots -- a ring whose published
+  window is pinned while it slides -- is drawn from its longest increasing *suffix*, so an unreadable
+  front cannot draw a segment from the newest sample back to the oldest (a line across the whole
+  panel);
+- a following group's window stays on its members' data: while the members retain at least a
+  window's worth, the scroll offset is bounded by `retained - span`, so a pan or a zoom-in near an
+  edge cannot leave the window's own span over data the scope never had (a window *wider* than the
+  data keeps the older placement -- right edge on the newest sample);
+- sample **markers** when a window is sparse enough that its samples are the shape
+  (`Style::marker_below_samples`, 50 by default, `marker_px` across, in the trace's own colour);
 - grid with independent major/minor line classes (`Style::grid_major_visible`,
-  `grid_minor_visible`);
+  `grid_minor_visible`), each with its own colour, width and (for the minors) dash — the
+  subdivisions default to thinner, dashed and alpha-blended, so they read as texture under the
+  labelled grid rather than as a second set of ticks;
 - x and y axes, with a vertical (bottom-to-top) y-axis title;
 - cursors in both orientations — vertical markers and horizontal rulers;
 - draggable regions and measurement bands with exact interval statistics;
 - a signal legend anchored to an axes corner;
- a hover crosshair with a per-signal, interpolated readout;
+- a hover crosshair with a per-signal readout, quoting the nearest sample and marking it
+  (`CrosshairValue::NearestSample`, the default) or interpolating between two
+  (`CrosshairValue::Interpolated`);
 - a multi-plot `Figure` of stacked rows sharing one synchronised x axis;
 - live follow (`XFollow::Live`) with relative (multiplicative) zoom and mouse panning;
 - XY series for irregularly sampled data (`plot/data/xy_series.hpp`): sorted-ascending x
@@ -166,10 +166,10 @@ series therefore stages O(visible pixels) vertices, not O(samples), and `FrameSt
 which path each trace took. Below the threshold the raw samples are drawn instead; both
 sides go through the same instanced anti-aliased quad pipeline.

-## Exact versus interpolated
+## One sample or a statistic of many

-The library deliberately holds two conventions next to each other, and they do **not**
-agree:
+Every number the library reports is one the samples actually hold. What differs between
+these two is *how many* samples answer the question:

 - **`Series::reduce` / `sum` / `sumsq` are exact over a sample range.** They answer "what
  are the samples' extremes / sum / sum of squares over `[begin, end)`". Each is
@@ -179,15 +179,23 @@ agree:
  and no query allocates. `Measure::evaluate` and `Plot::region_stats` are built on these,
  never on the `*_buckets` forms, which would silently report wrong extremes for an
  unaligned interval.
- **The crosshair readout is interpolated, and says so.** `crosshair_span(series, x)`
-  returns the two samples `x` lies between (`begin`, `end`, `t`), and
-  `crosshair_interpolate(y_begin, y_end, t)` does a linear interpolation: it answers "what
-  is the signal *at* this instant", which is generally between two samples — a different
-  question from an interval statistic. The lookup is O(1) (one division and a floor) and
-  allocation-free; `Plot::crosshair_value(trace, x, out_y)` exposes the same number to a
-  host. A row whose trace has no sample at the crosshair's x shows `kCrosshairNoValue`
-  (an em dash, `"—"`), and an x outside the series window yields no value rather than the
-  nearest sample's.
+- **The crosshair readout is a single sample — the nearest one — by default.**
+  `crosshair_span(series, x)` returns the two samples `x` lies between (`begin`, `end`, `t`),
+  and `CrosshairValue::NearestSample` takes whichever of the two is nearer: `t <= 0.5` the
+  earlier, otherwise the later. It answers "which datum is under the pointer", not "what is
+  the signal *at* this instant" — a linearly interpolated y is a number the series does not
+  contain, and on a source whose samples are already averaged or decimated at ingest it is a
+  claim about a signal nobody measured. That is why it is the default; a host whose x is a
+  quantity it is willing to interpolate states `CrosshairValue::Interpolated` and gets
+  `crosshair_interpolate(y_begin, y_end, t)` instead, at the crosshair's own x. The lookup is
+  O(1) and allocation-free either way, and it reads level 0, so the value is a stored sample
+  (or a blend of two) and never an LOD bucket's aggregate. `Plot::crosshair_point(trace, x,
+  out_x, out_y)` exposes **both** coordinates to a host and `crosshair_value()` the y alone;
+  `CrosshairRow::x`/`y` and its `marker` are placed from that same pair, so in
+  `NearestSample` the mark snaps onto the quoted sample and the dot and the number cannot
+  disagree. A row whose trace has no sample at the crosshair's x shows `kCrosshairNoValue`
+  (an em dash, `"—"`), and an x outside the series window yields no value rather than
+  clamping to the first or last sample.

 `Measurement` (from `Plot::measurement()`) documents `integral` as a **left-Riemann sum**,
 `sum(begin, end) * dx` — the samples taken as the value at the left edge of each step. That
@@ -106,6 +106,7 @@ one per plot.
 - `set_crosshair_readout(bool)` switches the panel off — or back on — without moving the
  crosshair. `set_crosshair_style(const CrosshairStyle&)` overrides this plot's stroke and
  dash.
+- `set_crosshair_value_mode(CrosshairValue)` chooses what a readout *is* — see below.

 In a `Figure`, the crosshair is applied to **every row** (one shared `x`): each row's readout
 lists its own traces at that instant. `Figure::set_crosshair(x, active)` is vertical-only
@@ -113,9 +114,39 @@ across the figure, and `Figure::set_crosshair(x, hovered_row, y_in_row, active)`
 horizontal line **only in the row the pointer is in** — a figure's rows share x and not y, so
 a figure-wide horizontal line would be a value that means something different in each row.

-Readout values are **interpolated**, not interval statistics (see
-[data-and-performance.md](data-and-performance.md)); a row whose trace has no sample at the
-crosshair's x is listed with the em dash `"—"` and no marker, rather than a fabricated value.
+### What a readout is: the two value modes
+
+`Crosshair::value_mode` (`set_crosshair_value_mode()`) answers two different questions, and
+which one a caller is asking decides the mode:
+
+| mode | the value | the marker | answers |
+|---|---|---|---|
+| `CrosshairValue::NearestSample` (default) | the nearer bracketing sample's y (a tie reads the earlier) | **snapped to that sample's own x** | *which datum is under the pointer?* |
+| `CrosshairValue::Interpolated` | a linear blend of the two bracketing samples | at the crosshair's own x | *what is the signal at this instant?* |
+
+The default is the sample, because a readout that quotes a number the data does not contain is
+a second estimate laid over the first — and once the view is zoomed past the sample spacing the
+polyline between two samples is a line the *renderer* drew, so reading a value off it reports
+the drawing rather than the signal. A host whose x is a continuous quantity it is willing to
+interpolate (a smooth analytic curve, a resampled series) states `Interpolated` and gets the
+blend, exactly at the pointer. Either way the value is a **stored** sample or a blend of two of
+them, never an LOD bucket's aggregate (see
+[data-and-performance.md](data-and-performance.md)).
+
+`CrosshairRow` carries both halves: `x` and `y` are the data coordinate the value belongs to —
+the quoted sample's own in `NearestSample`, the crosshair's x in `Interpolated` — and `marker`
+is that point in screen space. `Plot::crosshair_point(trace, x, out_x, out_y)` is the same
+lookup for a host that draws instruments of its own; `Plot::crosshair_value()` is it with the x
+discarded.
+
+The mark is drawn `Style::crosshair_marker_px` across (9 logical px) at
+`crosshair_marker_width`, both deliberately **larger than a trace's own sample dots**
+(`marker_px`, 3): in `NearestSample` the mark lands *among* those dots, and at the same size it
+would read as one more sample instead of as the one the panel is quoting. `0` across draws no
+mark.
+
+A row whose trace has no sample at the crosshair's x is listed with the em dash `"—"` and no
+marker, rather than a fabricated value.

 ## The gesture table (exactly as implemented)

@@ -36,8 +36,8 @@ Colours (neither logical nor device — nothing to scale):
 | field | default | meaning |
 |---|---|---|
 | `background` | `0x101418` | frame clear colour and legend/readout panel base |
-| `grid_major` | `0x2A3038` | major (labelled-tick) grid lines |
-| `grid_minor` | `0x1C2126` | minor (subdivision) grid lines |
+| `grid_major` | `0x39414C` | major (labelled-tick) grid lines |
+| `grid_minor` | `0x1C2126` at 50% alpha | minor (subdivision) grid lines |
 | `axis_line` | `0x8A94A6` | axis lines |
 | `axis_text` | `0xC8D0DC` | tick labels and axis titles |
 | `cursor` | `0xFFB020` | cursor markers; also the hovered/grab highlight |
@@ -56,8 +56,12 @@ Logical metrics (scaled by `device()`):
 |---|---|---|
 | `axis_font_px` | `12.0` | logical em the axis text is drawn at |
 | `grid_label_pad` | `4.0` | gap between a tick label and the axes, and the inset inside a title strip |
+| `marker_below_samples` | `50` | a dot per raw sample when the window holds at most this many (`0` = never) |
+| `marker_px` | `3.0` | logical size of that dot |
 | `grid_major_width` | `1.0` | width of a major grid line |
-| `grid_minor_width` | `1.0` | width of a minor grid line |
+| `grid_minor_width` | `0.75` | width of a minor grid line (sub-pixel on purpose) |
+| `grid_minor_dash_on` | `3.0` | minor grid dash: ink length in logical pixels |
+| `grid_minor_dash_off` | `3.0` | minor grid dash: gap; `0` draws the minor grid solid |
 | `grid_major_visible` | `true` | stage the major grid at all |
 | `grid_minor_visible` | `true` | stage the minor grid at all |
 | `line_width_px` | `1.5` | width of the strokes framing the data (axis lines, cursor markers) |
@@ -91,6 +95,29 @@ transparent. `Grid` therefore carries both classes' geometry whatever the style
 caller that draws the grid itself applies the same two switches. `Grid::vertical` and
 `Grid::horizontal` (both `true`) control which directions emit lines at all.

+The labelled class is the **structure** and the subdivisions are **texture**, and the minor
+grid's three defaults are what makes that read: it is thinner than the major hairline
+(`grid_minor_width`, a sub-pixel width that at 1x is expressed as coverage and on a HiDPI
+display as a narrower line), its colour carries an **alpha** so it blends into the
+background instead of sitting on it, and it is **dashed** (`grid_minor_dash_on`/`_off`) so an
+unlabelled line at an unlabelled position is never mistaken for a labelled one. Together
+those put a minor line at an order of magnitude less ink than a major one — at full opacity and the
+same width a dense minor grid reads as a second set of ticks. The dash is a fragment-shader
+discard, not extra geometry: the vertices are the line either way. Set
+`grid_minor_dash_off = 0` for the old solid subdivision.
+
+## A cursor's stroke
+
+`set_cursor_color()` gives a cursor its own colour and `set_cursor_stroke()` its own width and
+dash (`Cursor::width`, `Cursor::dash`). Per cursor rather than per plot, because a host uses
+cursors for two different jobs: the instruments that frame a reading — a marker at an edge, a pull
+handle — and the *readout marks* a computation places on the data (a measured level, a peak, a
+pulse's edges). Those want different weights. `width <= 0` means the style's default for that
+cursor (`handle_width_px` while it is hovered or grabbed, `line_width_px` otherwise), and a hover
+can only make the stroke *thicker*: the cue that the pointer has hold of something must not be the
+thing that hides it. `dash.off <= 0` (the default) is solid — the same convention as a trace's,
+the crosshair's and the grid's.
+
 ## The crosshair's dash

 `crosshair_dash_on`/`crosshair_dash_off` are the fragment shader's discard pattern, so no
@@ -33,7 +33,7 @@ class ArraySeries final : public Series {
  Range x_bounds() const override;
  Range y_bounds() const override;
  const MinMaxPyramid& pyramid() const override;
-  void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+  void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
              GatherMode mode = GatherMode::Envelope) const override;

 protected:
@@ -59,12 +59,20 @@ class Series {

  /// Appends interleaved (x, y) pairs for level `level`.
  ///
-  /// **x is relative to `x0()`**: the emitted value is `x_at(i) - x0()` as
-  /// f32, never the absolute coordinate. A consumer reconstructs the absolute
-  /// x in f64 (`x0() + emitted`) before mapping it to the screen; staging an
-  /// absolute epoch-time x as f32 would quantise it to a grid coarser than
-  /// the pixel (f32 carries 24 bits -- 1 s at 1.7e9), while the relative
-  /// value `i*dx` is small and exact. y is unchanged.
+  /// **x is relative to `x_origin`**: the emitted value is `x_at(i) - x_origin` as f32, never
+  /// the absolute coordinate. A consumer reconstructs the absolute x in f64
+  /// (`x_origin + emitted`) before mapping it to the screen; staging an absolute epoch-time x
+  /// as f32 would quantise it to a grid coarser than the pixel (f32 carries 24 bits -- 1 s at
+  /// 1.7e9). y is unchanged.
+  ///
+  /// **The caller names the origin because only the caller knows the span the f32 has to be
+  /// exact against.** The origin was `x0()` -- the start of the series' *retained window* --
+  /// and a relative value's ULP is then a fraction of the whole window however little of it is
+  /// on screen: 1.9 us over 20 s of retained data, which at a view 10 us wide is more than a
+  /// hundred pixels between where a sample is *drawn* and the x a readout quotes for the same
+  /// sample (`x_at()`, exact f64). Passing the visible range's minimum instead makes the error
+  /// 2^-24 of the *visible span* -- a fixed 4e-5 of a pixel over a 700 px axis -- at every
+  /// zoom. A caller with no view in mind may pass `x0()` and get the old behaviour.
  ///
  /// Level 0 emits the raw samples of [begin, end). Level >= 1 emits one
  /// geometry element per *complete* level bucket wholly inside the retained
@@ -85,7 +93,7 @@ class Series {
  /// level_for() picks), and never reaches outside the retained window -- nor
  /// outside [begin, end). Pairs are appended to out_xy, which is never
  /// cleared.
-  virtual void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+  virtual void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                      GatherMode mode = GatherMode::Envelope) const = 0;

  /// Absolute x of sample `i` (`x0() + i*dx()` on a uniform-grid series).
@@ -97,7 +105,7 @@ class Series {
  /// lands exactly on a sample). False when x lies outside the series' x
  /// bounds; `i0`/`i1` are then untouched. The crosshair and measurement
  /// paths read coordinates only through this and `x_at()`, so a series with
-  /// its own x array interpolates exactly.
+  /// its own x array brackets exactly.
  virtual bool neighbours(f64 x, u64& i0, u64& i1) const;

  /// Index of the sample nearest data-space `x`, clamped to `[0, size()-1]`;
@@ -121,7 +129,7 @@ class Series {

  /// The shared body of the concrete gather() overrides: raw samples at level 0,
  /// bucket geometry above it (per `mode`).
-  void gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+  void gather_impl(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                   GatherMode mode) const;

 private:
@@ -143,7 +151,7 @@ class Series {
  /// 0 is entirely this, and a level >= 1 gather uses it for the two partial edge
  /// buckets a pyramid of complete buckets cannot answer for. Precondition:
  /// begin < end, end <= size().
-  void gather_raw(u64 begin, u64 end, std::vector<f32>& out_xy) const;
+  void gather_raw(u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy) const;
 };

 }  // namespace plot::data
@@ -92,7 +92,7 @@ class StreamSeries final : public Series {
  Range x_bounds() const override;
  Range y_bounds() const override;
  const MinMaxPyramid& pyramid() const override;
-  void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+  void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
              GatherMode mode = GatherMode::Envelope) const override;
  /// Always true: this series' `x_bounds()` is the retained ring window, which
  /// slides with every `acquire()` -- the property `XFollow::Live` follows.
@@ -53,8 +53,8 @@ class XYSeries final : public Series {
  Range x_bounds() const override;
  Range y_bounds() const override;
  const MinMaxPyramid& pyramid() const override;
-  /// Same contract as `Series::gather`, with x emitted relative to `x0()`.
-  void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+  /// Same contract as `Series::gather`, with x emitted relative to `x_origin`.
+  void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
              GatherMode mode = GatherMode::Envelope) const override;

  /// The sample's own x.
@@ -52,6 +52,23 @@ struct Axis {
  AxisPlace place = AxisPlace::Bottom;
  bool log = false;
  TickFormat format = TickFormat::Si;
+  /// The value the labels are written *relative to*: every value on this axis is formatted as
+  /// `v - origin`, and the ticks are generated on that shifted grid. A host uses it to read a
+  /// zoomed-in window against its own left edge -- the labels then say `0, 0.5ms, 1ms` with the
+  /// window's start printed once beside the axis, instead of `12.345671s, 12.345672s` (which
+  /// three significant digits cannot even distinguish). 0 by default, which is the plain
+  /// absolute axis; the *positions* of the ticks are unchanged by it in the sense that only
+  /// their printed value shifts.
+  f64 origin = 0.0;
+
+  /// When set, `origin` is re-taken from the axis' own range on every `refresh()` -- the labels
+  /// then count from whatever the left edge currently is, and the tick on that edge reads zero
+  /// exactly, without a host having to predict where the follow will place the window (which it
+  /// cannot: the window moves with the samples, and a value written a frame earlier is a frame
+  /// of scroll stale). The window-start label a host draws beside the axis is then
+  /// `origin` *after* the frame, which is the value these labels were built with.
+  bool origin_follows_range = false;
+
  /// Whether this axis follows the newest sample. Only meaningful on an x axis --
  /// a y axis has no live edge -- and `Off` on both, so nothing changes for a
  /// caller who never asks for it. See XFollow.
@@ -30,6 +30,35 @@ struct CrosshairStyle {
                         ///< (once resolved) means solid.
 };

+/// What a crosshair readout's number *is*: one of the series' own samples, or a value
+/// computed between two of them.
+///
+/// The two answer different questions and the right one is a property of the data, which the
+/// plot cannot know — so it is the caller's to state.
+///
+/// * `NearestSample` answers **"which datum is under the pointer"**. The row reports the y of
+///   whichever bracketing sample is nearer the crosshair's x (a tie reading the earlier), and
+///   the marker is placed at **that sample's own x**, so the mark says *which* sample the
+///   number came from. This is the default, and it is the honest mode for a source whose
+///   samples are already averaged or decimated before they arrive: a number between two of
+///   those is a second estimate of a signal that nothing measured, and at a zoom past the
+///   sample spacing the polyline between two samples is a line the renderer drew, so a
+///   reading off it reports the drawing.
+/// * `Interpolated` answers **"what is the signal at this instant"**, by linear interpolation
+///   between the two bracketing samples (`crosshair_interpolate()`). The marker stays on the
+///   crosshair's own x, on the polyline, because that is where the number is. Right for a
+///   continuous quantity sampled finely enough that the line between two samples is a model
+///   the caller believes — a smooth analytical curve, an interpolating instrument — and
+///   wrong wherever that line is an artefact of plotting.
+///
+/// Set per plot through `Plot::set_crosshair_value_mode()`. It reaches the readout's numbers,
+/// the markers' positions and `Plot::crosshair_value()` alike, so a host and the panel beside
+/// the pointer can never disagree about what the value means.
+enum class CrosshairValue : u8 {
+  NearestSample,  ///< The nearer bracketing sample's y, marked at that sample's x. Default.
+  Interpolated,   ///< A linear blend of the two, marked at the crosshair's own x.
+};
+
 /// The crosshair's state: where it is, which of its two lines it draws, and whether the
 /// per-signal readout is wanted.
 ///
@@ -44,10 +73,10 @@ struct CrosshairStyle {
 /// drawn -- the single-coordinate `Plot::set_crosshair()` leaves the vertical one only,
 /// and a `Figure` is always vertical-only because its rows share x and not y.
 ///
-/// **The readout's values are interpolated, and deliberately so.** The y a row reports for
-/// a trace is *linear interpolation between the two samples adjacent to `x`*, not a sample
-/// and not an interval statistic -- see `crosshair_span()` for the rule stated in full, and
-/// for why it is the opposite convention from `Series::reduce()`/`sum()`/`sumsq()`.
+/// **The readout's values are samples by default** -- the y a row reports is the nearer of
+/// the two samples adjacent to `x`, and its marker sits on that sample. `value_mode` is what
+/// chooses otherwise; see `CrosshairValue` for the two questions it picks between, and
+/// `crosshair_span()` for how both differ from `Series::reduce()`/`sum()`/`sumsq()`.
 struct Crosshair {
  /// Whether the crosshair is drawn at all. Set by `Plot::set_crosshair()`; cleared by
  /// `Plot::clear_crosshair()`, which `input::Controller` calls when the pointer leaves the
@@ -58,7 +87,7 @@ struct Crosshair {
  /// Draw the horizontal line (the row of `y`). On for the two-coordinate overload only:
  /// a crosshair placed at one coordinate has no second value to mark a row with.
  bool horizontal = true;
-  /// List the visible traces and their interpolated values in a panel beside the pointer.
+  /// List the visible traces and their values in a panel beside the pointer.
  /// On by default, and free to leave on: a plot with no visible trace has no rows to
  /// measure and the panel is then not placed at all.
  bool show_readout = true;
@@ -67,6 +96,10 @@ struct Crosshair {
  /// The data y of the horizontal line, on y axis 0. Meaningless for a vertical-only
  /// crosshair, which draws no row and anchors its readout at the top of the axes.
  f64 y = 0.0;
+  /// Whether a row's value is one of the series' samples or a blend of two -- see
+  /// `CrosshairValue`, which also says where each mode puts the marker. Set through
+  /// `Plot::set_crosshair_value_mode()`.
+  CrosshairValue value_mode = CrosshairValue::NearestSample;
  /// This plot's own stroke and dash, when it wants to differ from the global style; a
  /// default-constructed `CrosshairStyle` defers every field to `render::Style` (see
  /// `CrosshairStyle`). Set through `Plot::set_crosshair_style()`.
@@ -84,14 +117,17 @@ struct Crosshair {
 /// arithmetic, which is O(1) in the series' length. The crosshair runs on every pointer
 /// move, so that is a requirement rather than a nicety.
 ///
-/// **Interpolated, not exact.** The value a caller builds from this span by
-/// `crosshair_interpolate()` between the two samples is the signal *at* `x`, which is
-/// generally between two samples -- the opposite convention from `Series::reduce()`,
-/// `sum()` and `sumsq()`, which are **exact over a sample range**. The two conventions sit
-/// next to each other in this library on purpose and they do not agree: `reduce()` answers
-/// "what are the samples' extremes over this interval", this answers "what is the signal at
-/// this instant". A readout that pretended to be exact would be quoting an extreme or a
-/// mean of a window as if it were the value under the pointer.
+/// **`t` is a position, not yet an answer.** It says where the query sits between the two
+/// samples and nothing more; what a caller makes of it is `CrosshairValue`'s to decide. In
+/// `NearestSample` -- the default -- it *selects*, `t <= 0.5` taking `begin`, so the readout
+/// quotes a sample the series actually holds. In `Interpolated` it *blends*, through
+/// `crosshair_interpolate()`. A plot cannot tell which is right, because the question is
+/// about the data and not about the drawing; `CrosshairValue` is where that is argued.
+///
+/// Either way this is a different convention from `Series::reduce()`, `sum()` and `sumsq()`,
+/// which are **exact over a sample range**: those answer "what are the samples'
+/// extremes/total over this interval", a crosshair answers "what is the signal at this one
+/// x". What differs is a statistic of many samples against a reading at one place.
 ///
 /// `valid` is false -- and every field left at its default -- for an **empty series**, a
 /// non-positive `dx()`, a non-finite `x`, and an `x` strictly outside the series' window
@@ -104,13 +140,14 @@ struct CrosshairSpan {
  /// Index of the first sample whose x is at or after the query: `begin` when the query
  /// lands on a sample, `begin + 1` between two of them.
  u64 end = 0;
-  /// The query's position between the two samples, in `[0, 1]`.
+  /// The query's position between the two samples, in `[0, 1]`. Whether it selects one of
+  /// them or blends both is `CrosshairValue`'s -- see the struct comment.
  f64 t = 0.0;
  bool valid = false;
 };

-/// The sample span `x` falls in, on `series`; see `CrosshairSpan` for the rule, for the
-/// interpolation convention it is half of, and for the cases that yield `valid == false`.
+/// The sample span `x` falls in, on `series`; see `CrosshairSpan` for what `t` means, for the
+/// convention it is half of, and for the cases that yield `valid == false`.
 ///
 /// O(1) and allocation-free: a subtraction, a division and a truncation. The series' own sample
 /// fetch is the caller's -- `Plot::crosshair_value()` reads the span through
@@ -118,12 +155,14 @@ struct CrosshairSpan {
 /// allocates.
 CrosshairSpan crosshair_span(const data::Series& series, f64 x) noexcept;

-/// The interpolated y at `t` between two samples: `y_begin` at `t == 0`, `y_end` at
-/// `t == 1`. The one place the interpolation's arithmetic lives, so the lookup's rule and
-/// its documentation cannot drift apart.
-inline f64 crosshair_interpolate(f64 y_begin, f64 y_end, f64 t) noexcept {
-  return y_begin + (y_end - y_begin) * t;
-}
+/// The linear blend of a span's two end samples at `t`: `y_begin + t * (y_end - y_begin)`,
+/// which is what `CrosshairValue::Interpolated` reports.
+///
+/// Written as that form rather than `(1 - t) * a + t * b` so `t == 0` returns `y_begin`
+/// exactly and `t == 1` returns `y_end` exactly, with no rounding of its own at the ends: a
+/// query that landed on a sample must read that sample's value back unchanged, whichever mode
+/// is in force. `NearestSample` does not call it at all.
+f64 crosshair_interpolate(f64 y_begin, f64 y_end, f64 t) noexcept;

 /// One trace's line of the readout: which trace it is about, the value under the pointer
 /// and the boxes the renderer stages.
@@ -150,8 +189,14 @@ struct CrosshairRow {
  /// entries -- so a row that is not listed is still a listed *trace*, with a marker, just
  /// not a line in a panel that has no room for it.
  bool listed = false;
-  /// The trace's interpolated y at the crosshair's x, on the trace's own y axis. Only
-  /// meaningful when `valid`.
+  /// The data x the row's value belongs to, on the trace's own x axis: in
+  /// `CrosshairValue::NearestSample` the **quoted sample's own x**, which is generally not the
+  /// crosshair's; in `Interpolated` the crosshair's x itself, since that is where an
+  /// interpolated number is. `marker` is placed from this and from `y`. Only meaningful when
+  /// `valid`.
+  f64 x = 0.0;
+  /// The row's value, on the trace's own y axis: the nearer sample's y, or the blend of the
+  /// two -- see `CrosshairValue`. Only meaningful when `valid`.
  f64 y = 0.0;
  /// The trace's name, or the positional placeholder of an unnamed one.
  std::string label;
@@ -161,9 +206,24 @@ struct CrosshairRow {
  /// `kCrosshairNoValue`, the em dash. The absence is therefore *legible* -- a blank cell reads as
  /// "still loading" rather than as "nothing here" -- and nothing numeric is fabricated for it.
  std::string value;
-  /// The trace's intersection with the crosshair, in framebuffer pixels: the pen the
-  /// renderer draws the marker at. Placed through the *trace's own* axis pair, so the
-  /// marker is where that trace is actually drawn. Meaningless when `!valid`.
+  /// Where the renderer draws the marker, in framebuffer pixels: the pen for `(x, y)`, placed
+  /// through the *trace's own* axis pair, so a trace on a secondary y axis is marked on the
+  /// scale it is drawn against.
+  ///
+  /// It marks **the point the row reports**, which is the whole job: in
+  /// `CrosshairValue::NearestSample` it is *snapped to the quoted sample*, sitting on the datum
+  /// rather than beside it on the crosshair's column, so the mark says which of the samples
+  /// under the pointer the number came from. (Placing it at the pointer's x with the sample's y
+  /// put it off the data in both coordinates at a deep zoom -- a mark on nothing.) In
+  /// `Interpolated` it stays on the crosshair's column, on the polyline, which is equally where
+  /// *that* mode's number is. One `(x, y)` feeding both the mark and the text is what keeps them
+  /// from ever disagreeing.
+  ///
+  /// It is drawn `Style::crosshair_marker_px` across -- **bigger than a trace's own sample
+  /// markers** on purpose, since a snapped mark lands among them and has to read as "this one"
+  /// rather than as one more sample. A mark for a sample outside the visible range is staged
+  /// where that sample is and left to the axes clip, rather than being dropped by a range test
+  /// of the drawing layer's own. Meaningless when `!valid`.
  Vec2 marker{};
  /// The swatch's box, `Legend::swatch_w` x `Legend::swatch_h` centred in the row. Empty
  /// when `!listed`.
@@ -6,6 +6,7 @@

 #include <plot/core/color.hpp>
 #include <plot/core/types.hpp>
+#include <plot/math/vec2.hpp>

 namespace plot {

@@ -86,6 +87,25 @@ struct Cursor {
  u32 axis_x = 0;  ///< the x axis `x` is in. Dead for `Horizontal`.
  u32 axis_y = 0;  ///< the y axis `y` is in. Dead for `Vertical`.
  bool visible = true;
+  /// Whether the pointer may hit this cursor at all: `false` for a *readout* -- a marker a
+  /// host keeps to show something it computed, which the user must not be able to drag. The
+  /// controller's `cursor_at()` skips it, so it is neither hovered nor grabbed, and the
+  /// hit radius it would have taken is left to whatever is behind it. Drawn exactly as a
+  /// visible one is: this is about the gesture, not the ink.
+  bool selectable = true;
+  /// The stroke's logical width; `<= 0` means the style's default for this cursor
+  /// (`Style::handle_width_px` while it is hovered or grabbed, `Style::line_width_px`
+  /// otherwise). Per cursor, like the colour, because a host uses cursors for two different
+  /// jobs: the instruments that frame a reading (a marker at an edge, a pull handle) and the
+  /// *readout marks* a computation places on the data (a measured level, a peak). Those want
+  /// different weights, and a hover can only make the stroke thicker, never thinner -- the cue
+  /// that the pointer has hold of something must not be the thing that hides it.
+  f32 width = 0.0f;
+  /// The dash, logical pixels: ink length and gap. `off <= 0` (the default) is a solid stroke --
+  /// the same convention as a trace's, the crosshair's and the grid's. A dashed readout mark is
+  /// distinguishable by *form* from the solid chrome around it, which is what an instrument that
+  /// reports a number should be.
+  Vec2 dash{};

  /// True when this is a horizontal ruler (spans the axes' width, reads its `y`). The one
  /// place the orientation becomes a branch, so every consumer takes the same decision and
@@ -138,6 +138,16 @@ class Figure {
  }
  f32 min_y_gutter() const noexcept { return min_y_gutter_; }

+  /// The empty band every row keeps to the right of its `axes`, in device pixels (0.0
+  /// by default, so `axes` reaches the viewport's right edge). It is set here rather
+  /// than row by row for the left gutter's reason: the rows' axes have to line up, and
+  /// they end on a common column only if they are told one width. See
+  /// `Plot::set_right_gutter()` for what it is for. Negative values are clamped to 0.
+  void set_right_gutter(f32 device_px) noexcept {
+    right_gutter_ = device_px > 0.0f ? device_px : 0.0f;
+  }
+  f32 right_gutter() const noexcept { return right_gutter_; }
+
  /// Whether the shared x axis is the figure's: every row reserves no x label strip
  /// and one shared axis is drawn under the last row (the default), or every row
  /// draws its own labels and the figure draws nothing extra.
@@ -326,6 +336,7 @@ class Figure {
  FigureLayout layout_{};
  f32 row_gap_ = 0.0f;
  f32 min_y_gutter_ = 0.0f;
+  f32 right_gutter_ = 0.0f;
  bool labels_bottom_only_ = true;
 };

@@ -88,6 +88,11 @@ struct PlotLayout {
  /// no text backend there is no title to lay out at all and both stay 0.0f.
  f32 y_title_width = 0.0f;
  f32 x_title_height = 0.0f;
+  /// The empty band kept between `axes`' right edge and the viewport's, 0.0f unless a
+  /// caller asked for one (see `Plot::set_right_gutter()`). Reported because it is
+  /// clamped by the same cap as the strips above, so what was asked for and what was
+  /// reserved are not always the same number.
+  f32 right_gutter = 0.0f;
  /// The measured legend: inside `axes`, never reserving any part of it, and empty
  /// when there is nothing to draw. It is measured with the same text backend the
  /// strips above are, and against the same `axes` rect the caller reads back, so
@@ -101,8 +106,8 @@ struct PlotLayout {
  /// where a pointer can grab it cannot drift apart.
  std::vector<RegionLayout> regions;
  /// The crosshair's geometry, when one is active: the two lines' stroke boxes, the
-  /// readout panel and one row per visible trace with the interpolated value the pointer
-  /// is over. Placed here rather than derived by the renderer, exactly as the legend and
+  /// readout panel and one row per visible trace with the value of the sample nearest the
+  /// pointer. Placed here rather than derived by the renderer, exactly as the legend and
  /// the regions are -- and, like them, entirely inside `axes`: the panel is flipped and
  /// clamped against the rect it was measured for, so nothing of the readout can be drawn
  /// over a label strip or into a figure's neighbouring row.
@@ -229,6 +234,13 @@ class Plot {
  /// Measures the interval between two cursors over the series of `trace`.
  u32 add_measure(u32 cursor_a, u32 cursor_b, u32 trace = 0);
  u32 add_annotation(const Annotation& annotation);
+  /// Moves an annotation that is already in the plot, keeping its id -- what a host whose
+  /// annotation is a *readout* needs (the point where a cursor crosses a trace moves with
+  /// the cursor). `Plot` has no `remove_annotation`, so the same parking discipline as the
+  /// cursors applies: set `visible = false` rather than dropping it, and re-place where it
+  /// belongs. An id that names no annotation is ignored, not an error, exactly as every
+  /// other setter here treats a stale id.
+  void set_annotation(u32 id, const Annotation& annotation);
  /// Adds a region. Its bounds are ordered and, when the region asks to snap, pulled
  /// onto the sample grid as it is added -- exactly as `add_cursor()` places a
  /// snapping cursor -- so a region handed to a plot that already holds samples is on
@@ -472,6 +484,46 @@ class Plot {
  ///
  /// Ignored for a vertical cursor, whose snap is `SnapMode` -- see `set_cursor_snap()`.
  void set_cursor_h_snap(u32 id, HRulerSnap mode);
+  /// Recolours a cursor that already exists. A *readout* cursor -- one a host keeps as a
+  /// marker for something it computed, rather than an instrument the user placed -- has to
+  /// be told apart from its neighbours, and its colour is how it says which readout it
+  /// belongs to. An id that names no cursor is ignored, like every other setter here.
+  void set_cursor_color(u32 id, Color color);
+
+  /// A cursor's stroke: its logical width (`<= 0` for the style's default) and its dash
+  /// (`dash.off <= 0` for solid). The instrument's own, like its colour -- see `Cursor::width`.
+  void set_cursor_stroke(u32 id, f32 width, Vec2 dash);
+  /// Makes a cursor unselectable (see `Cursor::selectable`): the pointer cannot hover or
+  /// grab it, which is what a host wants for a marker it draws as a *readout*. An id that
+  /// names no cursor is ignored, like every other setter here.
+  void set_cursor_selectable(u32 id, bool selectable);
+  /// Sets the value an axis' labels are written relative to (see `Axis::origin`). The ticks
+  /// are generated on that shifted grid too, so a host that zooms into a window can label it
+  /// from its own left edge. An id that names no axis of that orientation is ignored, like the
+  /// other setters here -- x and y ids are separate sequences, so the orientation is part of
+  /// the call.
+  void set_x_axis_origin(u32 axis, f64 origin);
+  void set_y_axis_origin(u32 axis, f64 origin);
+  /// The origin the matching setter stored (0 for an axis that never had one).
+  f64 x_axis_origin(u32 axis) const;
+  f64 y_axis_origin(u32 axis) const;
+  /// Makes an axis' label origin follow its own range (see `Axis::origin_follows_range`): the
+  /// labels then count from the left edge the frame actually has, which is the only way a
+  /// host can label a *moving* window from its start without being a frame behind.
+  void set_x_axis_origin_from_range(u32 axis, bool on);
+  void set_y_axis_origin_from_range(u32 axis, bool on);
+
+  /// A one-line caption for the x axis, drawn as **chrome** in the bottom-left corner of the
+  /// axes with the legend's own backplate behind it. It exists for the thing a shifted origin
+  /// leaves unsaid: labels counted from a window's left edge are only readable beside the value
+  /// that edge has, and the reader adds the two. An `Annotation` cannot serve -- its anchor is a
+  /// data coordinate, so the caption crawls across the plot under a pan and drifts under a zoom,
+  /// which is the one thing a legend-like panel must not do. The text is the host's, because only
+  /// the host knows how much precision the sum needs: the axis' own label form carries three
+  /// significant figures, which is exactly what made the shifted origin necessary.
+  /// Empty (the default) draws nothing.
+  void set_x_note(std::string text);
+  const std::string& x_note() const noexcept { return x_note_; }

  /// The measurement for `id`. Re-evaluated only when a cursor moved, when the
  /// measure was added, or when the series underneath it changed: a different
@@ -593,6 +645,20 @@ class Plot {
  }
  f32 min_y_gutter() const noexcept { return min_y_gutter_; }

+  /// An empty band reserved between `axes`' right edge and the viewport's, in device
+  /// pixels. 0.0 -- the default -- is what the layout has always done: `axes` reaches
+  /// the viewport's right edge, which leaves the rightmost x tick label, *centred* on
+  /// that edge, half of it to be drawn in and nothing to draw it in -- and puts the
+  /// newest sample's ink on the frame. It is the mirror of the left gutter in purpose
+  /// and not in kind: nothing is drawn here, so there is nothing to measure and the
+  /// value is the caller's to choose. Reserved inside the same cap as the label and
+  /// title strips, so it can no more squeeze `axes` below the half-viewport floor than
+  /// they can. Negative values are clamped to 0.
+  void set_right_gutter(f32 device_px) noexcept {
+    right_gutter_ = device_px > 0.0f ? device_px : 0.0f;
+  }
+  f32 right_gutter() const noexcept { return right_gutter_; }
+
  /// Grid segments for the primary axis pair (x axis 0, y axis 0), in data space.
  const Grid& grid() const noexcept { return grid_; }

@@ -653,20 +719,31 @@ class Plot {
  /// dash, which live on `CrosshairLayout` because they depend on `ui_scale`.
  const CrosshairStyle& crosshair_style() const noexcept { return crosshair_.style; }

+  /// Chooses what a readout's numbers *are*: one of the series' own samples, or a value
+  /// computed between two of them. `CrosshairValue` argues the two cases and says where each
+  /// puts the marker; the default is `NearestSample`.
+  ///
+  /// Deliberately **not** part of `set_crosshair()`, like the readout switch and the style
+  /// override: it is a statement about the data, so a pointer move must not be able to change
+  /// it. It takes effect on the next `layout()` and reaches `crosshair_value()` immediately.
+  void set_crosshair_value_mode(CrosshairValue mode) noexcept { crosshair_.value_mode = mode; }
+  /// The readout's value mode, as set -- see `set_crosshair_value_mode()`.
+  CrosshairValue crosshair_value_mode() const noexcept { return crosshair_.value_mode; }
+
  /// The crosshair's state: where it is, which lines it draws and whether the readout is
  /// on. Read-only -- `set_crosshair()` and `clear_crosshair()` are how it moves -- so the
  /// coordinates it holds and the geometry `layout()` places from them cannot disagree.
  const Crosshair& crosshair() const noexcept { return crosshair_; }

-  /// The **interpolated** value of `trace`'s series at a data `x`: `crosshair_span()`
-  /// between the two adjacent samples, then `crosshair_interpolate()` -- the same lookup
-  /// the readout's rows are built from, exposed for a host that wants the number for
-  /// itself (a status line, a tooltip of its own).
+  /// The value this plot's readout would report for `trace` at a data `x`: the nearer
+  /// bracketing sample's y, or the blend of the two, according to
+  /// `crosshair_value_mode()` -- the same lookup the readout's rows are built from, exposed
+  /// for a host that wants the number for itself (a status line, a tooltip of its own).
  ///
  /// False, leaving `out_y` untouched, for an id that names no trace, a trace with no
  /// series, and an `x` the series has no sample at -- the cases `CrosshairSpan::valid`
-  /// documents, plus the trace itself. Never a clamped or nearest-sample answer: see
-  /// `crosshair_span()` for why an out-of-window x is not a value.
+  /// documents, plus the trace itself. Never a clamped answer: see `crosshair_span()` for why
+  /// an out-of-window x is not a value.
  ///
  /// O(1) and allocation-free once the plot has looked a value up before: the span is
  /// index arithmetic and the samples are read through one `Series::gather()` of at most
@@ -674,6 +751,17 @@ class Plot {
  /// on every pointer move -- once per visible trace, so nothing here may scan a series.
  bool crosshair_value(u32 trace, f64 x, f64& out_y) const;

+  /// The whole **point** the readout reports, x as well as y: `crosshair_value()`'s number
+  /// together with the data x it belongs to. In `CrosshairValue::NearestSample` that x is the
+  /// quoted sample's own, which is generally not the `x` asked for; in `Interpolated` it is
+  /// `x` itself.
+  ///
+  /// This is what places `CrosshairRow::marker`, and it is public because a host that draws
+  /// instruments of its own -- a cursor pinned to the value it reads, an annotation naming the
+  /// sample -- needs the same snap, and recomputing it would be a second rule that can drift
+  /// from this one. Same failure cases, same cost, same scratch buffer as `crosshair_value()`.
+  bool crosshair_point(u32 trace, f64 x, f64& out_x, f64& out_y) const;
+
 private:
  /// One measure plus its cache. The dirty flag is what keeps measurement() from
  /// re-evaluating every frame; `last_series`, `last_size` and `last_x0` catch a
@@ -781,7 +869,7 @@ class Plot {
  /// never names a trace.
  void build_legend();
  /// Measures the crosshair into `layout_.crosshair`: the two lines' stroke boxes, one row
-  /// per visible trace with its interpolated value and marker, and the readout panel --
+  /// per visible trace with its nearest sample's value and marker, and the readout panel --
  /// placed beside the crosshair, flipped where it would cross an edge and clamped, so
  /// every rect it produces is inside `axes`. A plot with no visible trace still gets its
  /// lines: the rows are the readout's, not the crosshair's.
@@ -791,11 +879,16 @@ class Plot {
  render::Style style_{};
  const render::TextBackend* text_ = nullptr;
  Legend legend_{};
+  /// The x axis' corner caption; see set_x_note(). Empty draws nothing.
+  std::string x_note_;
  /// Which parts of the bottom x chrome are reserved at all; see set_x_strip_mode().
  XStrip x_strip_ = XStrip::Both;
  /// The floor a figure imposes on the left gutter; see set_min_y_gutter(). 0.0 means
  /// none, which is what a plot standing on its own keeps.
  f32 min_y_gutter_ = 0.0f;
+  /// The empty band kept to the right of `axes`; see set_right_gutter(). 0.0 means none,
+  /// which is what the layout did before the setter existed.
+  f32 right_gutter_ = 0.0f;
  /// Which handles a pointer is on, published by the input layer (see HotHandles).
  HotHandles hot_{};

@@ -48,7 +48,10 @@ void format_si(f64 v, char* buf, usize n, const char* unit = nullptr);
 /// field is derived from that one number, so no field can ever reach its radix:
 /// 119.5 s is `2:00`, not `1:60`, and 3599.5 s is `1:00:00`.
 ///
-/// Shapes, by magnitude: below 1 s `500ms`; below 60 s `1.5s`; below 1 h `1:30`;
+/// Shapes, by magnitude: below 1 s the prefixed unit that keeps the mantissa in
+/// `[1, 1000)` -- `500ms`, `5ms`, `500us`, `5us`, `5ns`, `5ps` (the micro sign is
+/// UTF-8 U+00B5, as in `format_si`) -- with an exact zero printed as `0` rather
+/// than as a zero of some unit; below 60 s `1.5s`; below 1 h `1:30`;
 /// at or above 24 h, as a decimal day count `2.5d`. Between 1 h and 24 h the
 /// shape is `1:01:01` -- and because a value that rounds up to 24 h takes the day
 /// shape, the hour field of that shape is always below 24. The 60 s and 1 h
@@ -73,11 +76,20 @@ inline constexpr usize kMaxTicks = 256;
 /// its labelled majors -- every major at or below `hi` is emitted, so the far
 /// end of the axis keeps its numbers.
 ///
+/// A range that straddles the origin gets a tick of **exactly** `0.0` there, labelled
+/// `0`. The walk cannot land on the origin by itself -- it starts at
+/// `ceil(min / stride) * stride`, which is not representable whenever the stride is
+/// not a power of two -- so the tick that means zero arrives a few ULP off and would
+/// otherwise be labelled from the far end of the SI table (`-139a` between `-500m` and
+/// `500m`). Every tick is an integer multiple of the stride, so anything within a
+/// millionth of one *is* the origin and nothing else; a range whose ticks are
+/// legitimately that small keeps them.
+///
 /// Hostile input clears `out` and returns: a non-finite endpoint, `max <= min`
 /// (a zero or negative span, which includes the collapsed range of a
 /// single-sample series), a non-positive `px` or `min_px`, and a span whose step
 /// overflows to infinity.
 void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out,
-                    bool include_minors = false);
+                    bool include_minors = false, f64 origin = 0.0);

 }  // namespace plot
@@ -40,6 +40,14 @@ class LineProgram {
  void set_aa(f32 px) const noexcept;
  /// `u_color`: stroke colour, alpha included.
  void set_color(Color color) const noexcept;
+  /// `u_snap`: with it on, an **axis-aligned** segment's ink is rounded onto whole
+  /// pixels along the axis it is constant on, so a hairline lights one column (or
+  /// row) fully instead of two at half coverage. It is for the chrome that frames a
+  /// plot -- grid lines, axis lines, panel and legend borders. Anything that reports
+  /// a data position -- a trace, a cursor, a region edge, the crosshair -- leaves it
+  /// off, because the rounding moves a line by up to half a pixel. A diagonal segment
+  /// is untouched whatever this says.
+  void set_snap(bool on) const noexcept;

 private:
  gl::Program program_;
@@ -397,7 +397,13 @@ class Renderer {
  /// crosshair passes and a dashed trace -- means **solid**. It is set on every flush,
  /// so one draw's dash can never leak into the next. The AA fringe (`u_aa`) is
  /// likewise set on every flush, from `style().line_aa_px` in device pixels.
-  void flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash = Vec2{}) noexcept;
+  ///
+  /// `snap` is `LineProgram::set_snap()`'s pixel-grid rounding: on for the chrome
+  /// that frames a plot -- the grid, the axis lines, a panel or legend border --
+  /// and off for everything drawn at a data position, since it moves an
+  /// axis-aligned line by up to half a pixel. Set on every flush, like `dash`.
+  void flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash = Vec2{},
+                   bool snap = false) noexcept;
  /// Draws every staged glyph in `batch` -- each instance carries its own tint
  /// (`a_colour`) -- and empties the batch. Text is texture-bound, so this runs
  /// once per text batch, after the line geometry it belongs over.
@@ -439,11 +445,12 @@ class Renderer {
  /// `origin_x` back in, in f64, before the single f32 narrowing (B1), so a
  /// large-magnitude x -- an epoch axis -- never loses sub-pixel precision.
  void stage_segment(f64 origin_x, f64 x0, f64 y0, f64 x1, f64 y1, bool log_x, bool log_y);
-  /// Stages `n` interleaved `x,y` points of a gathered window (see
-  /// `Series::gather`): x **relative to the series' `x0()`**, y absolute. The
-  /// absolute data x is reconstructed in f64 (`series_x0 + rel`) and staged as
+  /// Stages `n` interleaved `x,y` points of a gathered window (see `Series::gather`): x
+  /// **relative to `origin_x`**, which the caller asked the gather for, y absolute. On linear
+  /// axes that is already what the batch wants and the buffer is handed over as it is; a log
+  /// axis reconstructs the absolute x in f64 per segment and stages
  /// `to_space(x_abs) - to_space(origin_x)` -- O(visible pixels), not O(epoch).
-  void stage_xy(const f32* xy, u32 n, f64 series_x0, f64 origin_x, bool log_x, bool log_y);
+  void stage_xy(const f32* xy, u32 n, f64 origin_x, bool log_x, bool log_y);
  /// Lays one run of text out at a framebuffer position and stages it into
  /// `batch`, shifting it into viewport space and tinting it `color` (the
  /// per-instance `a_colour`). Returns the pen past the run.
@@ -528,6 +535,12 @@ class Renderer {
  /// them again, so the panel a test asserts and the panel this draws are the same
  /// numbers.
  void draw_legend(const Plot& plot, const PlotLayout& layout);
+  /// `Plot::x_note()`, in the bottom-left corner of the axes on the legend's backplate. It is
+  /// measured here rather than in `Plot::layout()` on purpose: unlike a legend it reserves no
+  /// space and nothing can be picked on it, so there is no measurement a host or a test needs to
+  /// read back, and a caption that explains the x labels must not be able to move the layout the
+  /// labels were measured into.
+  void draw_x_note(const Plot& plot, const PlotLayout& layout);
  /// The backplate the legend and the crosshair's readout share: the frame's background at
  /// `kLegendPanelAlpha` over `panel`, with a one-device-pixel border in `border` around the
  /// outermost pixels the fill covers (the crisp-hairline rule -- a border drawn on the measured
@@ -44,16 +44,27 @@ extern const char* const kLineFS;
 /// the cell's own +v direction -- so `a_axis` of `(0, -1)` draws a run that
 /// advances up the screen, and it maps `a_uv` over the cell with the same
 /// handedness, so a glyph's top row stays its top row however the cell is
-/// turned. The fragment shader converts back to texels and samples the
-/// single-channel `GL_R8` atlas at the nearest texel centre, so `GL_NEAREST`
-/// never lands on a cell boundary. The instance's own `a_colour` tints the
+/// turned. It also passes the cell's origin through `flat`, which is the bound
+/// the fragment shader filters against.
+///
+/// The fragment shader converts back to texels and blends the four texels the
+/// fragment sits between, **clamped to the instance's own cell**. Filtering is
+/// the shader's, not the sampler's: every fetch is an explicit texel centre, so
+/// `GL_NEAREST` stays correct, and the clamp keeps a footprint reaching past a
+/// cell edge from blending in the neighbouring glyph of what is a tight,
+/// unpadded strip of cells. A point sample would have been enough only at an
+/// integer scale: at the library's own default of a 12 px style on the 13 px
+/// embedded bake it *deleted* one of every 8 columns and one of every 17 rows of
+/// every glyph. At scale 1 with a whole pen the two taps coincide and the result
+/// is exactly as crisp as a point sample. The instance's own `a_colour` tints the
 /// straight alpha -- per vertex, so one draw can carry runs of several colours.
 ///
 /// Uniforms: `u_viewport` (vec2, pixels), `u_px_range` (vec2, the glyph cell's
 /// size on screen in pixels), `u_glyph_uv` (vec2, the glyph cell's size in
 /// normalised atlas coordinates -- one size for the whole draw, since every
-/// glyph of a frame comes from one atlas), `u_tex_size` (vec2, atlas size in
-/// texels), `u_atlas` (sampler2D, unit 0).
+/// glyph of a frame comes from one atlas; read in *both* stages, the fragment
+/// one needing it for the clamp), `u_tex_size` (vec2, atlas size in texels),
+/// `u_atlas` (sampler2D, unit 0).
 extern const char* const kTextVS;
 extern const char* const kTextFS;

@@ -38,8 +38,19 @@ struct Style {
  // --- colours: neither logical nor device, so nothing to scale ------------

  Color background = Color::hex(0x101418);
-  Color grid_major = Color::hex(0x2A3038);
-  Color grid_minor = Color::hex(0x1C2126);
+  /// The labelled grid. Brighter than the subdivisions and still well under `axis_line`
+  /// (0x8A94A6): the grid is structure the eye can read, the axis is the frame, and the
+  /// hierarchy between the three is what keeps a dense plot legible. It is already fully
+  /// opaque, so "more prominent" means a brighter colour and nothing else.
+  Color grid_major = Color::hex(0x39414C);
+  /// The minor grid's colour, **with an alpha** so it blends into the background rather than
+  /// sitting on it: a subdivision is a reading aid, and at full opacity a dense minor grid
+  /// reads as a second set of ticks competing with the labelled one. The line shader applies
+  /// `u_color.a` (see `src/render/shaders.cpp`), so this one blends and the major -- opaque at
+  /// 0x39414C -- stays the structure the eye picks out. Together with `grid_minor_width` and
+  /// the dash below, the defaults put a minor line at an order of magnitude less ink than a
+  /// major one.
+  Color grid_minor = Color::hex(0x1C2126, 0.5f);
  Color axis_line = Color::hex(0x8A94A6);
  Color axis_text = Color::hex(0xC8D0DC);
  Color cursor = Color::hex(0xFFB020);
@@ -75,6 +86,21 @@ struct Style {
  f32 crosshair_width = 0.75f;
  f32 crosshair_dash_on = 4.0f;
  f32 crosshair_dash_off = 4.0f;
+  /// The full extent, in logical pixels, of the little cross drawn at each trace's readout
+  /// point (`CrosshairRow::marker`), in that trace's own colour.
+  ///
+  /// **Deliberately larger than `marker_px`**, which is what a trace's own samples are dotted
+  /// with at a deep zoom. In the default `CrosshairValue::NearestSample` the readout's mark is
+  /// *snapped to a sample*, so it lands among those dots -- at the same size it would read as
+  /// one more sample instead of as "this is the one the panel is quoting". The lines are chrome
+  /// and recede; this mark is the answer to the question the hover asks, and it is the one
+  /// crosshair element that should not.
+  ///
+  /// Its stroke is `crosshair_marker_width`, thicker than the lines' for the same reason. `0`
+  /// across draws no mark at all, which is how a caller that wants the panel without the marks
+  /// says so.
+  f32 crosshair_marker_px = 9.0f;
+  f32 crosshair_marker_width = 1.5f;

  // --- the scale ----------------------------------------------------------

@@ -96,10 +122,31 @@ struct Style {
  /// skips it before the first segment is staged, so a dense plot's minor grid
  /// costs nothing rather than being drawn transparent (spec §11). The colours
  /// above are already per class.
+  /// When a trace's window holds at most this many raw samples, each one is also drawn as a dot
+  /// `marker_px` logical pixels across, in the trace's own colour. `0` draws none. Zoomed in far
+  /// enough to see individual samples -- a handful of them across a whole panel -- the polyline
+  /// *between* them stops being the shape, and the samples themselves are what a reader is looking
+  /// at; a marker makes each one a place rather than a bend in a line.
+  f32 marker_below_samples = 50.0f;
+  f32 marker_px = 3.0f;
  f32 grid_major_width = 1.0f;     ///< logical width of a major (labelled-tick) line.
-  f32 grid_minor_width = 1.0f;     ///< logical width of a minor (subdivision) line.
+  /// Logical width of a minor (subdivision) line: **thinner than the major hairline**, and
+  /// sub-pixel on purpose. At 1x that is expressed as *coverage* -- the anti-aliased ramp
+  /// (`line_aa_px`) lights one column at roughly three quarters of the ink -- and on a HiDPI
+  /// display as a line that is literally narrower. The point is hierarchy: the labelled grid is
+  /// structure, the subdivisions are texture.
+  f32 grid_minor_width = 0.75f;
  bool grid_major_visible = true;  ///< stage the major grid at all.
  bool grid_minor_visible = true;  ///< stage the minor grid at all.
+  /// The minor grid's dash, in logical pixels: ink length and gap. **`off == 0` draws it
+  /// solid** -- the same convention as the crosshair's and a trace's dash -- which is what a
+  /// caller that wants the old solid subdivision states. Dashed is the default because an
+  /// unlabelled line at an unlabelled position should never be mistaken for a labelled one, and
+  /// because a broken line carries less weight over data than a continuous one. The dash is a
+  /// fragment discard, never extra geometry, so a dense minor grid costs no more vertices for
+  /// being dashed.
+  f32 grid_minor_dash_on = 3.0f;
+  f32 grid_minor_dash_off = 3.0f;
  f32 line_width_px = 1.5f;        ///< logical width of the strokes framing the data
                                   ///< (axis lines, cursor markers).
  /// Logical half-width of the anti-aliased fringe the line shader blends at
@@ -75,9 +75,9 @@ Range ArraySeries::y_bounds() const { return y_bounds_; }

 const MinMaxPyramid& ArraySeries::pyramid() const { return pyramid_; }

-void ArraySeries::gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+void ArraySeries::gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                         GatherMode mode) const {
-  gather_impl(level, begin, end, out_xy, mode);
+  gather_impl(level, begin, end, x_origin, out_xy, mode);
 }

 void ArraySeries::copy_raw(u64 begin, u64 end, f32* out) const {
@@ -176,21 +176,24 @@ u64 Series::snap_index(f64 x) const {
  return static_cast<u64>(k);
 }

-void Series::gather_raw(u64 begin, u64 end, std::vector<f32>& out_xy) const {
+void Series::gather_raw(u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy) const {
  const f64 step = dx();
+  // Sample i sits at `x0() + i*step`, so this is `x_at(i) - x_origin` with the subtraction done
+  // once in f64 rather than per sample: see gather() for why the caller owns the origin.
+  const f64 shift = x0() - x_origin;
  f32 raw[kGatherChunk];
  for (u64 i = begin; i < end;) {
    const u64 take = std::min<u64>(kGatherChunk, end - i);
    copy_raw(i, i + take, raw);
    for (u64 k = 0; k < take; ++k) {
-      out_xy.push_back(f32(f64(i + k) * step));   // x relative to x0(): see gather()
+      out_xy.push_back(f32(shift + f64(i + k) * step));   // x relative to x_origin: see gather()
      out_xy.push_back(raw[k]);
    }
    i += take;
  }
 }

-void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+void Series::gather_impl(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                         GatherMode mode) const {
  const u64 n = size();
  const u64 b = std::min(begin, n);
@@ -198,7 +201,7 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
  if (b >= e) return;

  if (level == 0) {
-    gather_raw(b, e, out_xy);
+    gather_raw(b, e, x_origin, out_xy);
    return;
  }
  // Public levels clamp to the deepest representable one (R3): past
@@ -226,6 +229,7 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
  // picks, so the envelope path stays O(buckets) and the geometry still spans
  // the requested range exactly, for every mode.
  const f64 step = dx();
+  const f64 shift = x0() - x_origin;   // as in gather_raw(): x_at(i) - x_origin = shift + i*step
  const u64 span = u64{kBucket} << level;
  const u64 origin = pyramid().window_base();
  const u64 lbase = pyramid().level_base(level);
@@ -235,11 +239,11 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
  if (first >= last) {
    // No complete bucket of this level is inside the range -- a window squeezed
    // into one bucket -- so the raw samples are the only exact geometry there is.
-    gather_raw(b, e, out_xy);
+    gather_raw(b, e, x_origin, out_xy);
    return;
  }
  const u64 lead = first * span - origin;   // window index the first emitted bucket starts at
-  if (b < lead) gather_raw(b, std::min(lead, e), out_xy);
+  if (b < lead) gather_raw(b, std::min(lead, e), x_origin, out_xy);

  switch (mode) {
    case GatherMode::Envelope: {
@@ -252,9 +256,9 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
        const MinMax m = pyramid().bucket(level, bi);
        const u64 first_sample = bi * span - origin;   // >= 0: stored buckets start inside the window
        const u64 last_sample = std::min((bi + 1) * span, origin + e) - 1 - origin;
-        out_xy.push_back(f32(f64(first_sample) * step));   // x relative to x0()
+        out_xy.push_back(f32(shift + f64(first_sample) * step));   // x relative to x_origin
        out_xy.push_back(m.min);
-        out_xy.push_back(f32(f64(last_sample) * step));
+        out_xy.push_back(f32(shift + f64(last_sample) * step));
        out_xy.push_back(m.max);
      }
      break;
@@ -269,7 +273,7 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
        const u64 centre = bi * span + span / 2 - origin;   // inside [b, e): the bucket is wholly inside
        f32 v = 0.0f;
        copy_raw(centre, centre + 1, &v);
-        out_xy.push_back(f32(f64(centre) * step));   // x relative to x0()
+        out_xy.push_back(f32(shift + f64(centre) * step));   // x relative to x_origin
        out_xy.push_back(v);
      }
      break;
@@ -283,7 +287,7 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
        const u32 count = pyramid().bucket_count(level, bi);
        if (count == 0) continue;
        const u64 centre = bi * span + span / 2 - origin;
-        out_xy.push_back(f32(f64(centre) * step));   // x relative to x0()
+        out_xy.push_back(f32(shift + f64(centre) * step));   // x relative to x_origin
        out_xy.push_back(f32(pyramid().bucket_sum(level, bi) / f64(count)));
      }
      break;
@@ -291,7 +295,7 @@ void Series::gather_impl(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy
  }

  const u64 trail = last * span - origin;   // one past the last emitted bucket's span
-  if (trail < e) gather_raw(trail, e, out_xy);
+  if (trail < e) gather_raw(trail, e, x_origin, out_xy);
 }

 }  // namespace plot::data
@@ -87,9 +87,9 @@ Range StreamSeries::y_bounds() const { return y_bounds_; }

 const MinMaxPyramid& StreamSeries::pyramid() const { return pyramid_; }

-void StreamSeries::gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+void StreamSeries::gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                          GatherMode mode) const {
-  gather_impl(level, begin, end, out_xy, mode);
+  gather_impl(level, begin, end, x_origin, out_xy, mode);
 }

 void StreamSeries::copy_raw(u64 begin, u64 end, f32* out) const {
@@ -100,16 +100,16 @@ u64 XYSeries::snap_index(f64 x) const {
             : hi;                      // ties go to the lower index
 }

-void XYSeries::gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
+void XYSeries::gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out_xy,
                      GatherMode mode) const {
  const u64 n = size();
  const u64 b = std::min(begin, n);
  const u64 e = std::min(std::max(end, b), n);
  if (b >= e) return;

-  // x emitted relative to x0(): see Series::gather(). The x array is f64, so
+  // x emitted relative to the caller's origin: see Series::gather(). The x array is f64, so
  // the subtraction happens wide and only the small, exact offset narrows.
-  const f64 origin = x0();
+  const f64 origin = x_origin;

  if (level == 0) {
    for (u64 i = b; i < e; ++i) {
@@ -127,7 +127,7 @@ void XYSeries::gather(u32 level, u64 begin, u64 end, std::vector<f32>& out_xy,
  // `begin`, `last` one past the last bucket wholly before `end`, and the two
  // edge spans around them are read from the raw arrays -- so no emitted
  // geometry comes from outside [begin, end), and the emitted x values are the
-  // array's own coordinates relative to x0().
+  // array's own coordinates relative to the caller's origin.
  const u64 span = u64{kBucket} << level;
  const u64 lend = pyramid().level_size(level);
  const u64 first = std::min(ceil_div(b, span), lend);
@@ -323,17 +323,27 @@ void Controller::on_key(const KeyEvent& e) {
  if (zooms) {
    const f64 notches = e.key == kKeyZoomIn ? kKeyZoomNotches : -kKeyZoomNotches;
    const f64 factor = zoom_factor(notches);
-    for (u32 i = 0; i < plot_->x_axis_count(); ++i) {
-      const Axis& a = plot_->x_axis(i);
-      const f64 lo = to_space(a.range.min, a.log);
-      const f64 hi = to_space(a.range.max, a.log);
-      zoom_x_axis(i, from_space(0.5 * (lo + hi), a.log), factor);
+    // Ctrl restricts the zoom to x, Alt to y; bare +/- zooms both. (Shift cannot be
+    // used: '+' is shift+'=' on common layouts, so key_from() folds them together and
+    // a bare zoom-in already arrives with Mod::Shift set.) Ctrl+Alt zooms neither,
+    // which is harmless and needs no special case.
+    const bool only_x = has_mod(e.mods, Mod::Ctrl);
+    const bool only_y = has_mod(e.mods, Mod::Alt);
+    if (!only_y) {
+      for (u32 i = 0; i < plot_->x_axis_count(); ++i) {
+        const Axis& a = plot_->x_axis(i);
+        const f64 lo = to_space(a.range.min, a.log);
+        const f64 hi = to_space(a.range.max, a.log);
+        zoom_x_axis(i, from_space(0.5 * (lo + hi), a.log), factor);
+      }
    }
-    for (u32 i = 0; i < plot_->y_axis_count(); ++i) {
-      const Axis& a = plot_->y_axis(i);
-      const f64 lo = to_space(a.range.min, a.log);
-      const f64 hi = to_space(a.range.max, a.log);
-      zoom_y_axis(i, from_space(0.5 * (lo + hi), a.log), factor);
+    if (!only_x) {
+      for (u32 i = 0; i < plot_->y_axis_count(); ++i) {
+        const Axis& a = plot_->y_axis(i);
+        const f64 lo = to_space(a.range.min, a.log);
+        const f64 hi = to_space(a.range.max, a.log);
+        zoom_y_axis(i, from_space(0.5 * (lo + hi), a.log), factor);
+      }
    }
  } else if (fits) {
    plot_->auto_fit_x();
@@ -925,7 +935,9 @@ u64 Controller::cursor_at(f32 px, f32 py) const {
  f32 best_d = 0.0f;
  for (u32 i = 0; i < plot_->cursor_count(); ++i) {
    const Cursor& cursor = plot_->cursor(i);
-    if (!cursor.visible) continue;
+    // A readout is drawn but not offered to the pointer: skipping it here is what makes it
+    // undraggable, rather than fighting the drag a frame at a time.
+    if (!cursor.visible || !cursor.selectable) continue;
    // One hit test for both orientations, because a cursor *is* one line across the axes:
    // what the pointer has to be near is that line's own coordinate -- the column of a
    // vertical marker, the row of a horizontal ruler -- measured with the same radius
@@ -3,18 +3,32 @@

 #include <plot/plot/axis.hpp>

+#include <cmath>
+
 namespace plot {

 void Axis::format_value(f64 v, char* buf, usize n) const {
+  // The one place a value on this axis becomes text, so the origin is applied here and
+  // everything that goes through it -- tick labels, and the crosshair's readout -- reads in
+  // the same frame of reference as the axis itself.
+  // The subtraction leaves a residue when the value and the origin are the same distant number
+  // (a tick exactly on the origin then formatted as `1.78e-12ms` instead of `0ms`). Snapping it
+  // is a *relative* test, so a genuinely small value on a large axis is not swallowed -- what
+  // this removes is arithmetic dust, not data.
+  f64 shown = v - origin;
+  if (std::fabs(shown) < 1.0e-12 * std::max(1.0, std::fabs(v))) shown = 0.0;
  if (format == TickFormat::Time) {
-    format_time(v, buf, n);
+    format_time(shown, buf, n);
    return;
  }
-  format_si(v, buf, n);
+  format_si(shown, buf, n);
 }

 void Axis::refresh(f32 px, f32 min_px, bool include_minors) {
-  generate_ticks(range, px, min_px, ticks, include_minors);
+  // The range first, so a following origin is this frame's edge and not the last one's: the
+  // zero tick then sits exactly on the window start, which is the whole point of asking.
+  if (origin_follows_range) origin = range.min;
+  generate_ticks(range, px, min_px, ticks, include_minors, origin);
  if (format != TickFormat::Time) return;
  // generate_ticks labels with format_si; a time axis relabels its majors here,
  // because the tick generator has no business knowing about a clock -- through the one
@@ -4,6 +4,7 @@
 #include <plot/plot/figure.hpp>

 #include <algorithm>
+#include <cstdio>
 #include <cmath>
 #include <cstddef>

@@ -277,13 +278,23 @@ bool Figure::place_live_window(XLink& group) {
  // The offset can outlive the window it names: a ring that dropped samples moves
  // the oldest x forward under it, so it is clamped against what the members hold
  // *now* -- measured in the same space, or a log group could hold an offset larger
-  // than everything it retains. An offset past that would put the window's right
-  // edge behind the oldest sample left, i.e. over data that is gone.
+  // than everything it retains.
+  //
+  // The bound is about the whole *window*, not just its right edge -- but only when the window
+  // *can* sit on the data. `retained >= span` is that case, and there the offset may not exceed
+  // `retained - span`: with the loose bound a scroll could put the window's right edge exactly on
+  // the oldest sample, which leaves the entire span to its left over data the scope never had --
+  // an empty margin as wide as the view, reached by a pan or by a zoom-in near that edge. When the
+  // window is *wider* than what the members retain (a ring still filling, or one just trimmed)
+  // nothing can avoid a margin, and the honest placement is the old one: the window's right edge
+  // on the newest sample, the shortfall on the left, which is what a scope that just started
+  // should look like.
  const bool log = !plots_.empty() && plots_.back().x_axis(0u).log;
  const f64 newest_space = to_link_space(live.max, log);
  const f64 retained =
      std::max(0.0, newest_space - to_link_space(live.min, log));
-  group.offset = std::clamp(group.offset, 0.0, retained);
+  const f64 reach = retained >= group.span ? retained - group.span : retained;
+  group.offset = std::clamp(group.offset, 0.0, std::max(0.0, reach));
  group.live_newest = live.max;
  group.has_live = true;
  const f64 right = newest_space - group.offset;
@@ -440,6 +451,10 @@ const FigureLayout& Figure::layout() {
    // not drawn once per row. A figure told to label every row keeps them everywhere,
    // and then there is no shared axis to speak of: each row has its own.
    p.set_x_strip_mode(labels_bottom_only_ && row != bottom_row ? XStrip::None : XStrip::Both);
+    // Before either pass below, and the same value for every row: nothing is measured on
+    // the right, so unlike the left gutter this needs no measurement pass -- the rows end
+    // on a common column because they are all told the one width.
+    p.set_right_gutter(right_gutter_);
  }
  // After the viewports, so a row's ticks and grid -- built from its axes rect -- and
  // its transforms describe this frame's rects; and before the rows lay themselves
@@ -306,6 +306,57 @@ u32 Plot::add_annotation(const Annotation& annotation) {
  return static_cast<u32>(annotations_.size() - 1);
 }

+void Plot::set_cursor_color(u32 id, Color color) {
+  if (id >= cursors_.size()) return;
+  cursors_[id].color = color;
+}
+
+void Plot::set_cursor_stroke(u32 id, f32 width, Vec2 dash) {
+  if (id >= cursors_.size()) return;
+  cursors_[id].width = width;
+  cursors_[id].dash = dash;
+}
+
+void Plot::set_cursor_selectable(u32 id, bool selectable) {
+  if (id >= cursors_.size()) return;
+  cursors_[id].selectable = selectable;
+}
+
+void Plot::set_x_axis_origin(u32 axis, f64 origin) {
+  if (axis >= x_axes_.size()) return;
+  x_axes_[axis].origin = origin;
+}
+
+void Plot::set_y_axis_origin(u32 axis, f64 origin) {
+  if (axis >= y_axes_.size()) return;
+  y_axes_[axis].origin = origin;
+}
+
+void Plot::set_x_axis_origin_from_range(u32 axis, bool on) {
+  if (axis >= x_axes_.size()) return;
+  x_axes_[axis].origin_follows_range = on;
+}
+
+void Plot::set_y_axis_origin_from_range(u32 axis, bool on) {
+  if (axis >= y_axes_.size()) return;
+  y_axes_[axis].origin_follows_range = on;
+}
+
+void Plot::set_x_note(std::string text) { x_note_ = std::move(text); }
+
+f64 Plot::x_axis_origin(u32 axis) const {
+  return axis < x_axes_.size() ? x_axes_[axis].origin : 0.0;
+}
+
+f64 Plot::y_axis_origin(u32 axis) const {
+  return axis < y_axes_.size() ? y_axes_[axis].origin : 0.0;
+}
+
+void Plot::set_annotation(u32 id, const Annotation& annotation) {
+  if (id >= annotations_.size()) return;
+  annotations_[id] = annotation;
+}
+
 u32 Plot::add_region(const Region& region) {
  // A region whose bounds are not numbers is not an interval this plot can hold, and a
  // `Free` one stored that way could never be dragged back (every motion re-derives both
@@ -988,12 +1039,21 @@ const PlotLayout& Plot::layout() {
    x_height = std::min(x_height, x_budget);
    const f32 y_title_width = std::min(y_title_w, y_budget - y_width);
    const f32 x_title_height = std::min(x_title_h, x_budget - x_height);
+    // The right-hand band, out of what is left of the same allowance the two left
+    // strips were served from -- so the three together cannot take more than
+    // `1 - kMinAxesShare` of the width however much each asks for. Nothing is drawn
+    // in it, so unlike the strips above it is a want and never a measurement, and it
+    // cannot feed the fixed point below: the y labels are chosen from the row's range
+    // and height, so a narrower `axes` does not change what they need.
+    const f32 right_gutter =
+        std::min(right_gutter_, y_budget - (y_width + y_title_width));
    layout_.y_axis_width = y_width;
    layout_.x_axis_height = x_height;
    layout_.y_title_width = y_title_width;
    layout_.x_title_height = x_title_height;
+    layout_.right_gutter = right_gutter;
    layout_.axes = Rect{viewport_.x + y_width + y_title_width, viewport_.y,
-                        vw - (y_width + y_title_width),
+                        vw - (y_width + y_title_width + right_gutter),
                        vh - (x_height + x_title_height)};
    layout_.y_title_area = Rect{viewport_.x, layout_.axes.y, y_title_width, layout_.axes.h};
    layout_.y_label_area =
@@ -1033,7 +1093,7 @@ const PlotLayout& Plot::layout() {
  build_regions();
  build_legend();
  // The crosshair last: its panel is fitted into `axes` and its lines are held inside it, and
-  // its rows are the interpolated values at a data x -- so it wants the transforms the
+  // its rows are the sample values nearest a data x -- so it wants the transforms the
  // settled layout pins, exactly as the legend and the regions do.
  build_crosshair();
  return layout_;
@@ -1303,13 +1363,13 @@ void Plot::build_regions() {
 CrosshairSpan crosshair_span(const data::Series& series, f64 x) noexcept {
  CrosshairSpan span;
  const u64 n = series.size();
-  // No samples and no finite query: nothing to interpolate between.
+  // No samples and no finite query: nothing to bracket.
  if (n == 0u || !std::isfinite(x)) return span;

  // The bracketing samples, straight from the series (`neighbours()`/`x_at()`):
  // the window is closed at both ends -- the oldest and the newest sample are
-  // samples too -- and a query outside it has no neighbours to interpolate
-  // between. Answering with the nearest sample's value instead is the clamped lie
+  // samples too -- and a query outside it has no neighbours at all. Answering
+  // with the nearest sample's value instead is the clamped lie
  // this refuses: the readout would report a number as if it were under the
  // pointer when the series does not reach that far. The series owns where its
  // samples are, so an XY series is bracketed by its own x array exactly, where
@@ -1322,8 +1382,8 @@ CrosshairSpan crosshair_span(const data::Series& series, f64 x) noexcept {
  // A query that landed **on** a sample is a span of one, whichever side the
  // series' bracket reported: a sample at the query is the answer, and the two
  // ends of the window are samples too -- a bracket of (0, 1) at a query sitting
-  // on sample 0 would read as an interpolation with no width. Decided on the
-  // samples' own coordinates, so it holds for any `neighbours()` implementation.
+  // on sample 0 would read as a span with a width it does not have. Decided on
+  // the samples' own coordinates, so it holds for any `neighbours()` impl.
  if (series.x_at(i0) == x) {
    span.begin = span.end = i0;
    span.t = 0.0;
@@ -1338,16 +1398,16 @@ CrosshairSpan crosshair_span(const data::Series& series, f64 x) noexcept {
  }

  if (i0 == i1) {
-    // The series bracketed a single sample for a query that is not on it: nothing
-    // to interpolate with, and the sample is the honest answer.
+    // The series bracketed a single sample for a query that is not on it: there
+    // is no second sample to choose between, and this one is the honest answer.
    span.begin = span.end = i0;
    span.t = 0.0;
  } else {
    span.begin = i0;
    span.end = i1;
-    // `t` from the samples' own x coordinates, so the interpolation is exact on
+    // `t` from the samples' own x coordinates, so "which is nearer" is exact on
    // any grid, uniform or not. A degenerate pair (two samples sharing an x)
-    // interpolates nothing and reads the earlier sample.
+    // reads the earlier sample.
    const f64 xa = series.x_at(i0);
    const f64 xb = series.x_at(i1);
    span.t = xb > xa ? (x - xa) / (xb - xa) : 0.0;
@@ -1361,6 +1421,13 @@ CrosshairSpan crosshair_span(const data::Series& series, f64 x) noexcept {
  return span;
 }

+f64 crosshair_interpolate(f64 y_begin, f64 y_end, f64 t) noexcept {
+  // This form, not `(1 - t) * a + t * b`: at `t == 0` it is `y_begin` and at `t == 1` it is
+  // `y_end`, both exactly, so a query that landed on a sample reads that sample back whatever
+  // mode is in force. The symmetric form rounds at both ends.
+  return y_begin + t * (y_end - y_begin);
+}
+
 std::string crosshair_unnamed_label(u32 trace) {
  char buf[16];
  std::snprintf(buf, sizeof buf, "#%u", static_cast<unsigned>(trace));
@@ -1390,6 +1457,11 @@ void Plot::set_crosshair(f64 x, f64 y, bool active) {
 }

 bool Plot::crosshair_value(u32 trace, f64 x, f64& out_y) const {
+  f64 ignored = 0.0;
+  return crosshair_point(trace, x, ignored, out_y);
+}
+
+bool Plot::crosshair_point(u32 trace, f64 x, f64& out_x, f64& out_y) const {
  if (trace >= traces_.size()) return false;
  const data::Series* series = traces_[trace].series;
  if (series == nullptr) return false;
@@ -1401,12 +1473,31 @@ bool Plot::crosshair_value(u32 trace, f64 x, f64& out_y) const {
  // when it fell between them. The scratch is cleared and refilled rather than reallocated,
  // and sized for two pairs from construction, so the pointer path allocates nothing.
  crosshair_scratch_.clear();
-  series->gather(0u, span.begin, span.end + 1u, crosshair_scratch_);
+  // The origin is the query itself: only y is read out of the pairs below -- the x comes back
+  // through `x_at()` -- so this names the one origin that cannot lose precision for a caller
+  // that might.
+  series->gather(0u, span.begin, span.end + 1u, x, crosshair_scratch_);
  const usize pairs = static_cast<usize>(span.end - span.begin + 1u);
  if (crosshair_scratch_.size() != 2u * pairs) return false;  // a series that produced nothing
  const f64 y_begin = static_cast<f64>(crosshair_scratch_[1u]);
  const f64 y_end = static_cast<f64>(crosshair_scratch_[2u * pairs - 1u]);
-  out_y = crosshair_interpolate(y_begin, y_end, span.t);
+  if (crosshair_.value_mode == CrosshairValue::Interpolated) {
+    // The signal the samples imply *at* this x, so the point is the query's own x: that is
+    // where an interpolated number lives, and the marker on the polyline there is honest
+    // about it.
+    out_x = x;
+    out_y = crosshair_interpolate(y_begin, y_end, span.t);
+    return true;
+  }
+  // `NearestSample`: the nearer of the two, and **its own x with it**. `span.t` is measured on
+  // the samples' own coordinates, so "nearer" is exact on any grid; a tie reads the earlier
+  // sample, which is the bias `crosshair_span()` already takes for a degenerate pair. The x
+  // comes back through `x_at()` rather than from the gathered pairs, which are relative to a
+  // caller-named origin by the `Series::gather()` contract -- adding it back here would be a
+  // second reconstruction of a coordinate the series will hand over directly.
+  const bool take_begin = span.t <= 0.5;
+  out_x = series->x_at(take_begin ? span.begin : span.end);
+  out_y = take_begin ? y_begin : y_end;
  return true;
 }

@@ -1475,17 +1566,23 @@ void Plot::build_crosshair() {
    row.trace = i;
    row.valid = false;
    row.listed = false;
+    row.x = 0.0;
    row.y = 0.0;
    row.marker = Vec2{};
    row.swatch = Rect{};
    row.label_box = Rect{};
    row.value_box = Rect{};
    row.label.assign(trace.name.empty() ? crosshair_unnamed_label(i) : trace.name);
-    // The value: the interpolated number where the trace has a sample at this x, and the em dash
-    // where it does not. The row is listed either way, so the absence has to be *said* -- a blank
-    // value cell reads as a value that has not arrived -- and the dash is measured into the panel's
-    // width like any other value, so the row's boxes are placed by one rule.
-    if (crosshair_value(i, crosshair_.x, row.y)) {
+    // The value where the trace has one at this x, and the em dash where it does not. The row is
+    // listed either way, so the absence has to be *said* -- a blank value cell reads as a value
+    // that has not arrived -- and the dash is measured into the panel's width like any other
+    // value, so the row's boxes are placed by one rule.
+    //
+    // The **point**, not just the number: `crosshair_point()` reports the x the value belongs to
+    // as well, which in the default `NearestSample` mode is the quoted sample's own and not the
+    // pointer's. Both coordinates come from that one call, so the mark and the text cannot
+    // disagree about which datum is being read (see `CrosshairRow::marker`).
+    if (crosshair_point(i, crosshair_.x, row.x, row.y)) {
      row.valid = true;
      char value[32];
      // The trace's *own* y axis formats the number, so a readout reads exactly like the
@@ -1494,7 +1591,7 @@ void Plot::build_crosshair() {
      row.value.assign(value);
      // Placed through the trace's own axis pair, so the marker sits where that trace is
      // actually drawn however its axes are scaled.
-      row.marker = Vec2{static_cast<f32>(x_transform(trace.axis_x).to_screen_x(crosshair_.x)),
+      row.marker = Vec2{static_cast<f32>(x_transform(trace.axis_x).to_screen_x(row.x)),
                        static_cast<f32>(y_transform(trace.axis_y).to_screen_y(row.y))};
    } else {
      row.value.assign(kCrosshairNoValue);
@@ -98,15 +98,42 @@ void format_time(f64 seconds, char* buf, usize n) {
  const char* const sign = seconds < 0.0 ? "-" : "";
  const f64 t = std::fabs(seconds);

-  if (t < 1.0) {
-    // Sub-second: milliseconds. The 999.5 cut keeps %.3g out of scientific
-    // notation (it would print "1e+03ms") right below the one-second boundary.
-    const f64 ms = t * 1000.0;
-    if (ms < 999.5) {
-      std::snprintf(buf, n, "%s%.3gms", sign, ms);
-    } else {
-      std::snprintf(buf, n, "%s%.3gs", sign, t);
+  // `0.9995` and not `1.0`: three significant figures of 0.9999 s are `1e+03ms`, so a value
+  // that *rounds* to a second belongs to the whole-second branch below, which writes it `1s`.
+  // The same spill one rung down is handled inside the ladder.
+  if (t < 0.9995) {
+    // Sub-second: the prefix that keeps the mantissa in [1, 1000) -- the same rule the SI
+    // formatter uses on a y axis, and the reading a zoomed-in window needs. A fixed
+    // millisecond unit printed `0.005ms` where `5us` is what the axis is showing, and
+    // `1e-05ms` where `10ns` is. The micro sign is the UTF-8 sequence the embedded font has a
+    // glyph for (see `format_si`), not a Latin-1 byte.
+    // Exactly zero carries no unit, the same convention `format_si` states: every prefixed
+    // form of it is "0" with a unit the value does not have.
+    if (t == 0.0) {
+      std::snprintf(buf, n, "0");
+      return;
    }
+    static const struct {
+      f64 scale;
+      const char* unit;
+    } kUnits[] = {
+        {1.0e-3, "ms"},
+        {1.0e-6, "\u00b5s"},
+        {1.0e-9, "ns"},
+        {1.0e-12, "ps"},
+    };
+    // The rung is picked by the *rounded* mantissa, which is what `format_si`'s own 999.5
+    // check buys there: 0.9999 ms is `999.9µs` before rounding and `1e+03µs` after, so it is
+    // the millisecond rung's value and reads `1ms`. Testing the raw `t < u.scale` let the
+    // mantissa reach 1000 at every rung boundary.
+    for (const auto& u : kUnits) {
+      if (t < u.scale * 0.9995) continue;
+      std::snprintf(buf, n, "%s%.3g%s", sign, t / u.scale, u.unit);
+      return;
+    }
+    // Below a picosecond nothing on a time axis reads in prefixed units; plain seconds keep
+    // the fallback's own precision rather than inventing one.
+    std::snprintf(buf, n, "%s%.3gs", sign, t);
    return;
  }

@@ -131,7 +158,8 @@ void format_time(f64 seconds, char* buf, usize n) {
  }
 }

-void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out, bool include_minors) {
+void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out, bool include_minors,
+                    f64 origin) {
  out.clear();

  const f64 lo = range.min;
@@ -157,7 +185,10 @@ void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out, boo
                                                      : 10.0);
  if (!std::isfinite(step) || !(step > 0.0)) return;  // span so large the step overflowed

-  const f64 first_major = std::ceil(lo / step) * step;
+  // The major walk starts on the *origin's* grid: with an origin the ticks a host reads are
+  // round numbers relative to it (0, 0.5ms, 1ms of the window it zoomed into), which is the
+  // whole point of having one. `origin = 0` is the plain absolute grid.
+  const f64 first_major = origin + std::ceil((lo - origin) / step) * step;
  if (!std::isfinite(first_major)) return;

  // Minor ticks subdivide the major step: by 4 when the step's leading digit is
@@ -189,6 +220,23 @@ void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out, boo
  const f64 first = include_minors ? std::ceil(lo / minor_step) * minor_step : first_major;
  if (!std::isfinite(first)) return;

+  // The walk starts at `ceil(lo / stride) * stride`, which is not representable
+  // whenever the stride is not a power of two -- 0.1 and 0.2 are the common ones --
+  // so a range that straddles the origin never lands *on* it: [-1, 1] stepped by 0.1
+  // reaches -1.39e-16 where it means zero, and that renders as `-139a`, a label from
+  // the far end of the SI table sitting between `-500m` and `500m`. Deriving `v` by
+  // multiplication instead of accumulation does not help, because the error is
+  // already in `first`.
+  //
+  // Every tick is an integer multiple of the stride, so the smallest magnitude a
+  // *non-zero* tick can have is the stride itself, while the residue is a few ULP of
+  // the range -- a relative gap of some ten orders of magnitude. Anything inside a
+  // millionth of the stride is therefore the zero tick and nothing else, and it is
+  // stored as exactly `0.0` rather than merely labelled as such: `Axis::refresh()`
+  // re-formats a time axis from `tick.value`, where the same residue reads
+  // `3.19e-13ms`.
+  const f64 zero_tol = (include_minors ? minor_step : step) * 1e-6;
+
  char label[kLabelBuf];
  usize minors = 0;
  for (f64 v = first; v <= hi + stride * 1e-9;) {
@@ -213,12 +261,14 @@ void generate_ticks(Range range, f32 px, f32 min_px, std::vector<Tick>& out, boo
    }
    if (!major) ++minors;
    Tick tick;
-    tick.value = v;
+    // The walk variable itself is left alone: `minor_index_is_major` counts indices
+    // from `first_major` and both operands have to stay on the walk's own grid.
+    tick.value = std::fabs(v) < zero_tol ? 0.0 : v;
    tick.major = major;
    if (major) {
      // format_si owns both label guards: it never writes past the buffer, and it
      // falls back to %.3g for a non-finite value or a label over 12 characters.
-      format_si(v, label, sizeof label);
+      format_si(tick.value, label, sizeof label);
      tick.label = label;
    }
    out.push_back(std::move(tick));
@@ -9,12 +9,17 @@
 namespace plot::render {
 namespace {

+#ifndef NDEBUG
 /// Two declared cells agree when neither size differs by more than the atlas'
 /// tolerance: the test `glyph_is_cell()` makes, for a cell against a cell.
+///
+/// Guarded because its one caller is an `assert` (see `TextBatch::set_cell`), so a
+/// release build has no use for it and would warn that it is unused.
 bool same_cell(Vec2 a, Vec2 b) noexcept {
  const auto near = [](f32 p, f32 q) { return std::fabs(p - q) <= kAtlasCellTolerance; };
  return near(a.x, b.x) && near(a.y, b.y);
 }
+#endif

 /// `axis` as a unit vector: the cell's local +x, which is what the instance and
 /// the shader both take (see `TextInstance`). A zero, infinite or NaN direction
@@ -34,6 +34,10 @@ void LineProgram::set_color(Color color) const noexcept { program_.set_uniform("

 void LineProgram::set_aa(f32 px) const noexcept { program_.set_uniform("u_aa", px); }

+void LineProgram::set_snap(bool on) const noexcept {
+  program_.set_uniform("u_snap", on ? 1.0f : 0.0f);
+}
+
 bool TextProgram::create(Status* st) noexcept {
  program_ = gl::Program::from_source(kTextVS, kTextFS, st);
  if (program_.id() == 0) {
@@ -9,6 +9,7 @@
 #include <plot/render/detail/text_scale.hpp>

 #include <algorithm>
+#include <cstring>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
@@ -42,15 +43,6 @@ bool fail(Status* st, ErrorCode code, const char* message) noexcept {
 /// clamp, so it lands off-scale rather than as NaN.
 f64 space(f64 v, bool log) noexcept { return log ? Transform::log10_positive(v) : v; }

-/// Sample index for a (possibly fractional, possibly non-finite) position in a
-/// series' index space, clamped to [0, n]: NaN and -inf to 0, +inf to n, so a
-/// range the axis cannot map still yields a valid window.
-u64 clamp_index(f64 v, u64 n) noexcept {
-  if (!(v > 0.0)) return 0;
-  if (v >= static_cast<f64>(n)) return n;
-  return static_cast<u64>(v);
-}
-
 /// One ASCII/UTF-8 line of the measurement readout. `format_si` leaves room for
 /// three significant digits plus a prefix and sign.
 constexpr usize kNumberChars = 24;
@@ -541,6 +533,7 @@ void Renderer::draw_plot(Plot& plot, const PlotLayout& layout) {
  draw_measures(plot, layout);
  draw_annotations(plot);
  draw_legend(plot, layout);
+  draw_x_note(plot, layout);
  // The under text batch goes out here, so the readout's panel below it can
  // occlude what it covers: legend names, cursor labels, measure labels and
  // annotation captions are all chrome the panel is allowed to sit on.
@@ -621,7 +614,8 @@ void Renderer::upload_text_vertices(std::span<const f32> interleaved) noexcept {
  text_vao_.upload(interleaved.data(), static_cast<u32>(interleaved.size() / 10u));
 }

-void Renderer::flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash) noexcept {
+void Renderer::flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash,
+                           bool snap) noexcept {
  const u32 segments = lines_.segment_count();
  if (segments != 0 && ready_) {
    upload_vertices(lines_.data());
@@ -633,6 +627,9 @@ void Renderer::flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash
    // Set on *every* flush, solid included, so the crosshair's dash cannot leak into the
    // grid, a trace or a cursor drawn after it (see draw_crosshair_lines()).
    line_program_.set_dash(dash);
+    // Likewise set on every flush: the grid's snap must not follow the trace drawn
+    // after it onto the pixel grid.
+    line_program_.set_snap(snap);
    line_program_.set_color(color);
    // The AA fringe, too: the style's logical knob in device pixels, clamped so
    // a 0 style still keeps a quarter pixel of ramp. 1.0 -- the default -- is
@@ -739,24 +736,16 @@ void Renderer::stage_segment(f64 origin_x, f64 x0, f64 y0, f64 x1, f64 y1, bool
                          static_cast<f32>(space(y1, log_y))});
 }

-void Renderer::stage_xy(const f32* xy, u32 n, f64 series_x0, f64 origin_x, bool log_x,
-                        bool log_y) {
+void Renderer::stage_xy(const f32* xy, u32 n, f64 origin_x, bool log_x, bool log_y) {
  if (!log_x && !log_y) {
-    // The common case: reconstruct the absolute data x in f64 (`x0 + rel` --
-    // the gather contract's own reconstruction), stage it relative to the
-    // draw's origin, and the f32 is O(visible pixels), not O(epoch).
-    staged_.clear();
-    staged_.reserve(usize(n) * 2u);
-    const f64 origin_s = space(origin_x, log_x);
-    for (u32 i = 0; i < n; ++i) {
-      staged_.push_back(static_cast<f32>(xy[2u * i] + series_x0 - origin_s));
-      staged_.push_back(xy[2u * i + 1u]);
-    }
-    lines_.add_polyline_xy(staged_.data(), n);
+    // The common case costs nothing at all: the gather emitted x relative to this very origin
+    // (`draw_traces` asks it for `x_range.min`, which is the draw's origin too) and a linear y
+    // needs no mapping, so the gathered buffer *is* the staged one.
+    lines_.add_polyline_xy(xy, n);
    return;
  }
  for (u32 i = 0; i + 1u < n; ++i) {
-    stage_segment(origin_x, xy[2u * i] + series_x0, xy[2u * i + 1u], xy[2u * i + 2u] + series_x0,
+    stage_segment(origin_x, xy[2u * i] + origin_x, xy[2u * i + 1u], xy[2u * i + 2u] + origin_x,
                  xy[2u * i + 3u], log_x, log_y);
  }
 }
@@ -803,7 +792,7 @@ void Renderer::draw_grid(const Plot& plot) {
  // to draw rather than being drawn transparent. Majors first, minors over them, as
  // the single group order always did. `LineBatch::clear()` keeps its capacity, so
  // the second pass re-uses the first one's storage.
-  const auto draw_class = [&](bool major, bool visible, Color color, f32 width) {
+  const auto draw_class = [&](bool major, bool visible, Color color, f32 width, Vec2 dash) {
    if (!visible) {
      return;
    }
@@ -811,12 +800,23 @@ void Renderer::draw_grid(const Plot& plot) {
      if (line.major != major) continue;  // grid.build() already dropped non-finite ones
      stage_segment(x_range.min, line.x0, line.y0, line.x1, line.y1, log_x, log_y);
    }
-    flush_lines(map, color, width);
+    // Snapped: a grid line is chrome at a round *data* value, and a hairline that
+    // straddles two columns reads as a grey smear and shimmers as the view pans.
+    flush_lines(map, color, width, dash, true);
  };
  draw_class(true, style_.grid_major_visible, style_.grid_major,
-             style_.device(style_.grid_major_width));
+             style_.device(style_.grid_major_width), Vec2{});
+  // The minor grid's dash rides the same per-draw uniform the crosshair and a dashed trace use,
+  // and `off == 0` is the solid default. Each line starts its own pattern (the dash distance is
+  // per-segment), and every segment here is built from the range's minimum, so the dashes of the
+  // vertical lines line up with each other -- the grid reads as one texture rather than as a
+  // jumble of unrelated dashes.
+  const Vec2 minor_dash = style_.grid_minor_dash_off > 0.0f
+                              ? Vec2{style_.device(style_.grid_minor_dash_on),
+                                     style_.device(style_.grid_minor_dash_off)}
+                              : Vec2{};
  draw_class(false, style_.grid_minor_visible, style_.grid_minor,
-             style_.device(style_.grid_minor_width));
+             style_.device(style_.grid_minor_width), minor_dash);
 }

 // ------------------------------------------------------------- axis chrome
@@ -835,14 +835,18 @@ void Renderer::draw_axis_lines(const Plot& plot) {
    const Axis& axis = plot.x_axis(i);
    const f64 y = axis.place == AxisPlace::Top ? y_range.max : y_range.min;
    stage_segment(axis.range.min, axis.range.min, y, axis.range.max, y, axis.log, log_y0);
+    // Snapped, like the grid: an axis line is the frame of the plot, and it is the
+    // one line a reader compares every other against, so a smeared one is the worst
+    // place for the half-coverage pair.
    flush_lines(mapping(plot, i, 0, axis.range.min), style_.axis_line,
-                style_.device(style_.line_width_px));
+                style_.device(style_.line_width_px), Vec2{}, true);
  }
  for (u32 i = 0; i < plot.y_axis_count(); ++i) {
    const Axis& axis = plot.y_axis(i);
    const f64 x = axis.place == AxisPlace::Right ? x_range.max : x_range.min;
    stage_segment(x, x, axis.range.min, x, axis.range.max, log_x0, axis.log);
-    flush_lines(mapping(plot, 0, i, x), style_.axis_line, style_.device(style_.line_width_px));
+    flush_lines(mapping(plot, 0, i, x), style_.axis_line,
+                style_.device(style_.line_width_px), Vec2{}, true);
  }
 }

@@ -984,15 +988,26 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
    const u64 n = series.size();
    if (!(dx > 0.0) || n == 0) continue;

-    // Map the visible x range onto sample indices. One sample of slack on each
-    // side covers a partially visible end bucket; the range is clamped to the
-    // series, so a zoomed-out view never asks for more than exists.
+    // The visible x range onto sample indices, through the series' *own* x.
+    //
+    // Not the `(x - x0()) / dx()` grid: `dx()` is documented as a nominal spacing (the LOD
+    // level, a coarse snap) and for a series whose x is a streamed timestamp it is only the
+    // mean of the retained window. Walking that grid lands the window inside the visible range
+    // -- and the first and last *segments*, the ones that enter and leave the frame, are then
+    // not drawn at all, which is the empty margin at both edges of a zoomed-in view. A series
+    // with a uniform x answers the same question through the same call, so this is the one
+    // path. One sample of slack on each side keeps a partially visible end bucket whole, and
+    // the result is clamped to the series: a zoomed-out view never asks for more than exists,
+    // and a window that reaches past the data leaves the margin genuinely -- correctly -- empty.
    const Range x_range = plot.x_range(trace.axis_x);
-    f64 lo = (x_range.min - series.x0()) / dx;
-    f64 hi = (x_range.max - series.x0()) / dx;
-    if (hi < lo) std::swap(lo, hi);
-    const u64 first = clamp_index(std::floor(lo) - 1.0, n);
-    const u64 last = clamp_index(std::ceil(hi) + 1.0, n);
+    // `dx` is still read above for the samples-per-pixel estimate -- a density, where a nominal
+    // spacing is exactly right -- and never for the window itself.
+    u64 first = 0;
+    u64 last = n;
+    u64 i0 = 0;
+    u64 i1 = 0;
+    if (series.neighbours(x_range.min, i0, i1)) first = i0 > 0 ? i0 - 1 : 0;
+    if (series.neighbours(x_range.max, i0, i1)) last = std::min(n, i1 + 1);
    if (last <= first) continue;

    // This is the whole performance contract: the window, never the series.
@@ -1003,24 +1018,85 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
                          : 0u;

    gather_.clear();
-    series.gather(level, first, last, gather_, trace.mode);
+    // The visible range's minimum is the gather origin: the emitted f32 is then O(the span on
+    // screen), so its ULP is a fixed 2^-24 of the axis at every zoom. `series.x0()` -- the origin
+    // before -- is the start of the *retained window*, so the quantisation was a fraction of data
+    // the view need not even hold, and a deep zoom drew a sample visibly off the x a readout
+    // quotes for it. See `Series::gather()`.
+    series.gather(level, first, last, x_range.min, gather_, trace.mode);
    if (gather_.size() < 4u) continue;  // fewer than two points is no segment

    stats_.visible_samples += visible;
+    // Markers for a window sparse enough that its samples are the shape: one dot per raw sample,
+    // in the trace's own colour. Level 0 only -- above it the geometry is *buckets*, which are not
+    // points a reader can find. Drawn after the polyline they sit on, so a dot is never half
+    // covered by its own line, and inside the axes only (a marker is a place, and a place outside
+    // the frame is not one).
+    if (level == 0u && style_.marker_below_samples > 0.0f && visible > 0u &&
+        visible <= static_cast<u64>(style_.marker_below_samples)) {
+      const auto& xt = plot.x_transform(trace.axis_x);
+      const auto& yt = plot.y_transform(trace.axis_y);
+      const f32 half = 0.5f * style_.device(style_.marker_px);
+      for (u32 k = 0; k + 1 < gather_.size(); k += 2) {
+        const f64 x_abs = x_range.min + static_cast<f64>(gather_[k]);
+        const f64 y_abs = static_cast<f64>(gather_[k + 1]);
+        if (!std::isfinite(x_abs) || !std::isfinite(y_abs)) continue;
+        const f32 sx = static_cast<f32>(xt.to_screen_x(x_abs));
+        const f32 sy = static_cast<f32>(yt.to_screen_y(y_abs));
+        if (!(sx >= layout.axes.x && sx <= layout.axes.right() && sy >= layout.axes.y &&
+              sy <= layout.axes.bottom())) {
+          continue;
+        }
+        fill_pixels(Rect{sx - half, sy - half, 2.0f * half, 2.0f * half}, trace.color);
+      }
+    }
    if (level == 0u) {
      ++stats_.raw_traces;
    } else {
      ++stats_.lod_traces;
    }

-    // Gathered x is relative to `series.x0()` (the gather contract); the staging
-    // reconstructs the absolute data x in f64 and emits `to_space(x_abs) -
-    // to_space(origin)` -- the visible x range's minimum is the natural origin
-    // for a trace -- so the f32 is O(visible pixels), not O(epoch) (B1). The
-    // mapping folds the origin back into the offset uniform, in f64.
+    // Gathered x is relative to `x_range.min` (the gather contract, with the origin this
+    // function asked for); the staging reconstructs the absolute data x in f64 and emits
+    // `to_space(x_abs) - to_space(origin)` about that same origin, so the f32 is O(visible
+    // pixels), not O(epoch) (B1). The mapping folds the origin back into the offset uniform,
+    // in f64.
    const bool log_x = plot.x_axis(trace.axis_x).log;
    const bool log_y = plot.y_axis(trace.axis_y).log;
    const Mapping map = mapping(plot, trace.axis_x, trace.axis_y, x_range.min);
+    // Keep the longest **increasing suffix** of the gathered points, and drop what precedes it.
+    //
+    // A ring-backed series may answer a *clamped* stamp for the oldest slots of its window -- the ones
+    // the producer has already overwritten. The clamp is deliberate (the alternative was a sentinel
+    // that collapsed the whole index mapping), but it makes the stamps *non-increasing at the front*:
+    // the first few points carry the newest stamp, and everything after them is older. A polyline
+    // through that draws a segment from the newest sample back to the oldest -- a line across the
+    // whole panel, which is what a saturated ring shows as a flicker.
+    //
+    // A forward filter cannot express this: the bad points are at the *front* and everything behind
+    // them is legitimately smaller, so dropping "anything that does not advance" would delete the
+    // trace. Walking backwards keeps each point that is strictly older than the one kept after it,
+    // which stops at the first unreadable slot and leaves the real samples alone. The cost is one
+    // pass over the visible points, which the staging below is about to walk anyway.
+    {
+      const usize count = gather_.size() / 2u;
+      usize kept = 0;
+      f64 next = std::numeric_limits<f64>::infinity();
+      for (usize k = count; k > 0; --k) {
+        const usize p = k - 1u;  // the point index; `i` above is the trace's
+        const f64 x = static_cast<f64>(gather_[2u * p]) + x_range.min;
+        if (!(x < next)) continue;  // out of order with what follows: unreadable, and a NaN too
+        next = x;
+        gather_[2u * (count - 1u - kept)] = gather_[2u * p];
+        gather_[2u * (count - 1u - kept) + 1u] = gather_[2u * p + 1u];
+        ++kept;
+      }
+      if (kept != count) {
+        // The kept points were written back-to-front into the tail; move them down to the front.
+        std::memmove(gather_.data(), gather_.data() + 2u * (count - kept), 2u * kept * sizeof(f32));
+        gather_.resize(2u * kept);
+      }
+    }
    const u32 points = static_cast<u32>(gather_.size() / 2u);

    // A trace's dash rides on the same per-draw uniform the crosshair uses, in
@@ -1035,7 +1111,7 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
    // trace/axis hierarchy on a high-DPI panel. `width == 0` is scatter: the
    // markers below are the whole trace.
    if (trace.width > 0.0f) {
-      stage_xy(gather_.data(), points, series.x0(), x_range.min, log_x, log_y);
+      stage_xy(gather_.data(), points, x_range.min, log_x, log_y);
      flush_lines(map, trace.color, style_.device(trace.width), dash);
    }

@@ -1053,7 +1129,7 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
      const f64 origin_s = space(x_range.min, log_x);
      u32 staged = 0;
      for (u32 p = 0; p < points; p += stride) {
-        const f64 x_abs = static_cast<f64>(gather_[2u * p]) + series.x0();
+        const f64 x_abs = static_cast<f64>(gather_[2u * p]) + x_range.min;
        const f32 rx = static_cast<f32>(space(x_abs, log_x) - origin_s);
        const f32 ry = static_cast<f32>(space(gather_[2u * p + 1u], log_y));
        const Vec2 centre{rx * map.scale.x + map.offset.x, ry * map.scale.y + map.offset.y};
@@ -1096,7 +1172,12 @@ void Renderer::draw_cursors(const Plot& plot, const PlotLayout& layout) {
    // belongs to the plot, and `to_screen_y()` of a range maximum can undershoot `axes.y` by
    // a floating-point ulp, which a bare `<` would mistake for "outside". Only the ones
    // beyond that margin are skipped.
-    const f32 half = 0.5f * style_.device(on ? style_.handle_width_px : style_.line_width_px);
+    // The cursor's own width when it has one, else the style's; a hover or a grab can only make
+    // it thicker (the cue that the pointer has hold of something).
+    const f32 own = cursor.width > 0.0f ? style_.device(cursor.width)
+                                       : style_.device(style_.line_width_px);
+    const f32 width = on ? std::max(own, style_.device(style_.handle_width_px)) : own;
+    const f32 half = 0.5f * width;
    if (horizontal ? (at < layout.axes.y - half || at > layout.axes.bottom() + half)
                   : (at < layout.axes.x - half || at > layout.axes.right() + half)) {
      continue;
@@ -1120,15 +1201,13 @@ void Renderer::draw_cursors(const Plot& plot, const PlotLayout& layout) {
      stage_segment(x_range.min, x_range.min, y_drawn, x_range.max, y_drawn, log_x,
                    plot.y_axis(cursor.axis_y).log);
      flush_lines(mapping(plot, 0, cursor.axis_y, x_range.min),
-                  on ? style_.cursor : cursor.color,
-                  style_.device(on ? style_.handle_width_px : style_.line_width_px));
+                  on ? style_.cursor : cursor.color, width, cursor.dash);
    } else {
      const f64 x_drawn = plot.x_transform(cursor.axis_x).to_data_x(static_cast<f64>(drawn));
      stage_segment(x_drawn, x_drawn, y_range.min, x_drawn, y_range.max,
                    plot.x_axis(cursor.axis_x).log, log_y);
      flush_lines(mapping(plot, cursor.axis_x, 0, x_drawn),
-                  on ? style_.cursor : cursor.color,
-                  style_.device(on ? style_.handle_width_px : style_.line_width_px));
+                  on ? style_.cursor : cursor.color, width, cursor.dash);
    }
    draw_cursor_label(plot, layout, cursor, drawn);
  }
@@ -1322,6 +1401,28 @@ void Renderer::draw_legend(const Plot& plot, const PlotLayout& layout) {
  }
 }

+void Renderer::draw_x_note(const Plot& plot, const PlotLayout& layout) {
+  const std::string& text = plot.x_note();
+  if (text.empty()) return;
+  const Rect& axes = layout.axes;
+  const f32 line_h = font_backend_.height();
+  const f32 width = font_backend_.measure(text.c_str());
+  if (!(width > 0.0f) || !(line_h > 0.0f)) return;
+  // The pad is the legend's, so the two panels read as the same kind of chrome.
+  const f32 pad = style_.device(4.0f);
+  const Rect panel{axes.x + pad, axes.bottom() - pad - line_h - 2.0f * pad, width + 2.0f * pad,
+                   line_h + 2.0f * pad};
+  // A sliver of axes gets no caption rather than one hanging over the frame: the panel is chrome
+  // *inside* the axes, and a backplate crossing the axis line would read as a second plot.
+  if (panel.w > axes.w || panel.h > axes.h) return;
+  draw_readout_panel(panel, style_.axis_line);
+  // Bottom-left, beside the labels it qualifies -- the reader adds the caption to a tick, so it
+  // belongs at the end of the tick row and not in a corner of its own. `glyphs_under_` because
+  // the panel is flushed with the frame's line geometry and the under-text batch goes out after
+  // it: text staged into the over batch would be drawn before its own backplate.
+  stage_text(glyphs_under_, {panel.x + pad, panel.y + pad}, text.c_str(), style_.axis_text);
+}
+
 void Renderer::stage_marker(plot::Marker marker, Vec2 centre_px, f32 size_px) {
  // Marker shapes as line segments, in viewport pixels: the trace's flush maps
  // them with `pixel_mapping()`, so the size is device pixels whatever the data
@@ -1441,19 +1542,28 @@ void Renderer::draw_crosshair_lines(const Plot& plot, const PlotLayout& layout)
    flush_lines(data, style_.crosshair, stroke, crosshair.dash);
  }

-  // A small cross at each trace's intersection, in the trace's own colour -- opaque, like a
-  // legend's swatch, so a trace drawn at 15% still has a marker that can be seen. The arm
-  // length is a logical size like every other marker's, and the position is the layout's: a
-  // marker for a sample far outside the visible y range is staged where the trace is and the
-  // axes clip keeps it inside, rather than being skipped by a range test of this layer's own.
-  const f32 arm = style_.device(3.0f);
-  for (const CrosshairRow& row : crosshair.rows) {
-    if (!row.valid) continue;
-    Color color = plot.trace(row.trace).color;
-    color.a = 1.0f;
-    lines_.add_segment({row.marker.x - arm, row.marker.y}, {row.marker.x + arm, row.marker.y});
-    lines_.add_segment({row.marker.x, row.marker.y - arm}, {row.marker.x, row.marker.y + arm});
-    flush_lines(pixel_mapping(), color, style_.device(1.0f));
+  // A cross at each trace's readout point, in the trace's own colour -- opaque, like a legend's
+  // swatch, so a trace drawn at 15% still has a mark that can be seen. The position is the
+  // layout's, and in the default `CrosshairValue::NearestSample` that is the *quoted sample*
+  // rather than the pointer's column: a mark for a sample outside the visible range is staged
+  // where that sample is and the axes clip keeps it inside, rather than being skipped by a range
+  // test of this layer's own.
+  //
+  // `crosshair_marker_px` is the cross' full extent and is larger than `marker_px`, which dots a
+  // trace's own samples at a deep zoom -- a snapped mark lands among those dots and has to read
+  // as the one the panel is quoting. `0` across draws nothing, so a caller can have the panel
+  // and the lines without the marks.
+  const f32 arm = 0.5f * style_.device(style_.crosshair_marker_px);
+  const f32 mark_stroke = style_.device(style_.crosshair_marker_width);
+  if (arm > 0.0f) {
+    for (const CrosshairRow& row : crosshair.rows) {
+      if (!row.valid) continue;
+      Color color = plot.trace(row.trace).color;
+      color.a = 1.0f;
+      lines_.add_segment({row.marker.x - arm, row.marker.y}, {row.marker.x + arm, row.marker.y});
+      lines_.add_segment({row.marker.x, row.marker.y - arm}, {row.marker.x, row.marker.y + arm});
+      flush_lines(pixel_mapping(), color, mark_stroke);
+    }
  }
 }

@@ -20,6 +20,7 @@ uniform vec2 u_offset;    // pixels
 uniform vec2 u_viewport;  // render target size, pixels
 uniform float u_width;    // stroke width, pixels
 uniform float u_aa;       // AA fringe half-width, pixels
+uniform float u_snap;     // non-zero: put an axis-aligned segment's ink on whole pixels

 out float v_dist;   // signed distance to the segment axis, pixels
 // Distance travelled from a_p0, pixels -- and the dash's phase anchor. Both of the
@@ -32,6 +33,40 @@ out float v_along;
 void main() {
  vec2 p0 = a_p0 * u_scale + u_offset;
  vec2 p1 = a_p1 * u_scale + u_offset;
+
+  // The pixel-grid snap, for the chrome that *frames* the plot: a grid line, an
+  // axis line, a panel or legend border. Those are staged in data space like
+  // everything else, so a 1 px stroke's centre lands wherever the mapping puts it
+  // -- at x = 100.0 the ink spans [99.5, 100.5] and lights two columns at half
+  // coverage each (a grey smear), at x = 100.5 it spans [100, 101] and lights one
+  // crisply. Which of the two a given line got depended on the view, so a frame's
+  // gridlines were a mix of both and panning made each shimmer between them.
+  //
+  // Snapping the ink's *leading edge* to a pixel boundary -- rather than the
+  // centre to a half pixel -- is the form that holds for any width: it reduces to
+  // integer + 0.5 for an odd stroke and to an integer for an even one, with no
+  // case analysis. `u_aa` is deliberately not in `ink`: the fringe is symmetric
+  // about the ink and snapping with it folded in would bias the line by half a
+  // fringe.
+  //
+  // Only for an axis-aligned segment, and only on the axis it is constant along:
+  // a diagonal has no single perpendicular to round, and moving either end of one
+  // by a part of a pixel would tilt it. That restriction is also why this is safe
+  // to leave on for a whole draw -- the grid and the axis lines are nothing *but*
+  // axis-aligned segments. Traces, cursors, regions and the crosshair pass 0: a
+  // line that reports a data position may not be moved off it, however little.
+  if (u_snap != 0.0) {
+    float ink = u_width * 0.5;
+    vec2 snapped = floor(p0 - vec2(ink) + vec2(0.5)) + vec2(ink);
+    if (abs(p1.x - p0.x) < 1e-4) {  // vertical: round x, leave y
+      p0.x = snapped.x;
+      p1.x = snapped.x;
+    } else if (abs(p1.y - p0.y) < 1e-4) {  // horizontal: round y, leave x
+      p0.y = snapped.y;
+      p1.y = snapped.y;
+    }
+  }
+
  vec2 d = p1 - p0;
  float len = length(d);
  float half_w = u_width * 0.5 + u_aa;  // + the AA fringe
@@ -112,6 +147,10 @@ uniform vec2 u_glyph_uv;  // glyph cell in the atlas, normalised (width, height)

 out vec2 v_uv;      // normalised atlas coordinate of this fragment
 out vec4 v_colour;  // the instance's tint
+// This glyph's cell origin, flat: the fragment shader filters inside the cell and
+// has to know where it starts. Interpolating it would make the bound it clamps
+// against drift across the quad, which is the one thing the clamp is there to stop.
+flat out vec2 v_cell0;

 void main() {
  // The cell's two axes: the run direction the instance carries and its
@@ -131,24 +170,67 @@ void main() {
  // way round: u runs along the basis, v down the glyph.
  v_uv = a_uv + corner * u_glyph_uv;
  v_colour = a_colour;
+  v_cell0 = a_uv;
 }
 )";

 const char* const kTextFS = R"(#version 330 core
 in vec2 v_uv;      // normalised atlas coordinate of this fragment
 in vec4 v_colour;  // the instance's tint
+flat in vec2 v_cell0;  // this glyph's cell origin, normalised

-uniform sampler2D u_atlas;  // GL_R8 glyph atlas, GL_NEAREST
-uniform vec2 u_tex_size;    // atlas size in texels
+uniform sampler2D u_atlas;    // GL_R8 glyph atlas, GL_NEAREST
+uniform vec2 u_tex_size;      // atlas size in texels
+uniform vec2 u_glyph_uv;      // the cell's size in normalised atlas coordinates

 out vec4 o_color;

+/// Coverage of one texel, addressed by its integer index. Every fetch in here is
+/// an explicit texel centre, which is why the sampler can stay `GL_NEAREST`: the
+/// filtering below is this shader's, not the sampler's, so no fetch can tie at a
+/// texel boundary and no fetch can be steered outside the cell clamped for it.
+float tap(vec2 texel) {
+  return texture(u_atlas, (texel + vec2(0.5)) / u_tex_size).r;
+}
+
 void main() {
-  // Sample the centre of the texel the fragment lands in. GL_NEAREST alone
-  // would tie at a texel boundary, where the driver may pick the neighbouring
-  // glyph cell; rounding to a centre removes the tie by construction.
-  vec2 texel = clamp(floor(v_uv * u_tex_size), vec2(0.0), u_tex_size - vec2(1.0));
-  float coverage = texture(u_atlas, (texel + vec2(0.5)) / u_tex_size).r;
+  // Bilinear over the four texels the fragment sits between, **clamped to this
+  // glyph's own cell**.
+  //
+  // It used to be a single point sample of the texel the fragment landed in, and
+  // the two halves of that -- a point sample, and `AxisFont` drawing the atlas at
+  // `requested_px / em_px` -- are each reasonable and jointly wrong: a point
+  // sample at a non-integer scale *deletes* texels rather than blending them. The
+  // library's own default is a 12 px style on the 13 px embedded bake, i.e. 12/13,
+  // which dropped one of every 8 columns and one of every 17 rows of every glyph
+  // -- whole strokes, not softened edges, and which stroke went depended on where
+  // the unsnapped pen happened to fall. Filtering costs four fetches of a texture
+  // that is one row of cells and is in cache for the whole pass.
+  //
+  // The clamp is what keeps the old guarantee: the atlas is a tight strip of cells
+  // with no padding between them, so a footprint reaching past a cell edge would
+  // blend in the neighbouring glyph. Clamping to the cell's own texel range
+  // replicates its edge instead, and a cell's border texels are blank (the cell is
+  // the face's widest advance by its full ascent-to-descent extent), so the
+  // replication is of nothing.
+  //
+  // `floor(x + 0.5)` on both bounds, not a raw product: they come back from a
+  // normalised coordinate times a size, so an exact texel index arrives a few ULP
+  // either side of itself, and a `floor` of 191.99999 is off by a whole texel.
+  vec2 lo = floor(v_cell0 * u_tex_size + vec2(0.5));
+  vec2 hi = lo + floor(u_glyph_uv * u_tex_size + vec2(0.5)) - vec2(1.0);
+  // Texel *centres* are at integer + 0.5 in normalised-times-size space, so
+  // subtracting the half puts the sample on a grid whose integers are the centres:
+  // `f` is then the distance between the two taps, and a fragment that lands on a
+  // centre -- every fragment, when the scale is 1 and the pen is whole -- gets
+  // `f == 0` and exactly one texel, as crisp as the point sample ever was.
+  vec2 t = v_uv * u_tex_size - vec2(0.5);
+  vec2 t0 = floor(t);
+  vec2 f = t - t0;
+  vec2 a = clamp(t0, lo, hi);
+  vec2 b = clamp(t0 + vec2(1.0), lo, hi);
+  float coverage = mix(mix(tap(vec2(a.x, a.y)), tap(vec2(b.x, a.y)), f.x),
+                       mix(tap(vec2(a.x, b.y)), tap(vec2(b.x, b.y)), f.x), f.y);
  o_color = vec4(v_colour.rgb, v_colour.a * coverage);
 }
 )";
@@ -71,6 +71,12 @@ bool TextAtlas::sync(const TextBackend& backend, Status* st) noexcept {
    // no second create -- and it keeps the filter, which is why the filter is set
    // on every upload rather than once at creation.
    texture_.upload_r8(width, height, pixels);
+    // `GL_NEAREST` on purpose, and it is not the absence of filtering: `kTextFS`
+    // filters, with four fetches it aims at explicit texel centres and clamps to
+    // the instance's own cell. `GL_LINEAR` here would do the blending with the
+    // *sampler's* footprint instead, which knows nothing of cell bounds -- and the
+    // atlas is a tight strip of cells with no padding, so a glyph at a cell edge
+    // would pick up its neighbour.
    texture_.set_filter(gl::GL_NEAREST, gl::GL_NEAREST);
  }
  gl::glPixelStorei(gl::GL_UNPACK_ALIGNMENT, host_alignment);
@@ -263,6 +263,27 @@ PLOT_TEST(key_minus_zooms_out) {
  PLOT_CHECK(f.plot.x_range(f.ax).span() > 100.0);
 }

+PLOT_TEST(ctrl_plus_zooms_only_x) {
+  Fixture f;
+  f.ay = f.plot.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  const f64 x_before = f.plot.x_range(f.ax).span();
+  const f64 y_before = f.plot.y_range(f.ay).span();
+  f.controller.on_key({plot::input::kKeyZoomIn, kCtrl, true});
+  PLOT_CHECK(f.plot.x_range(f.ax).span() < x_before);
+  PLOT_CHECK_NEAR(f.plot.y_range(f.ay).span(), y_before, 1e-12);
+}
+
+PLOT_TEST(alt_plus_zooms_only_y) {
+  Fixture f;
+  f.ay = f.plot.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  constexpr plot::u32 kAlt = static_cast<plot::u32>(plot::input::Mod::Alt);
+  const f64 x_before = f.plot.x_range(f.ax).span();
+  const f64 y_before = f.plot.y_range(f.ay).span();
+  f.controller.on_key({plot::input::kKeyZoomIn, kAlt, true});
+  PLOT_CHECK_NEAR(f.plot.x_range(f.ax).span(), x_before, 1e-12);
+  PLOT_CHECK(f.plot.y_range(f.ay).span() < y_before);
+}
+
 /// A host can hand the controller a coordinate that is not a number: ImGui reports
 /// (-FLT_MAX, -FLT_MAX) for "no mouse position", and any host can produce a NaN out
 /// of a degenerate mapping of its own. The pan arithmetic runs through the axis
@@ -1788,6 +1809,47 @@ PLOT_TEST(a_middle_drag_on_a_figures_bottom_row_zooms_the_shared_x_axis) {
 // pointer) rather than on the live edge, and the window walked back off the newest sample
 // by a fifth of its width. These two cases pin the fix from the two ends: the gesture keeps
 // the edge, and the hint that makes it possible exists exactly while a group follows.
+/// A following group's window stays **on the data**: the offset bound is `retained - span`, not
+/// `retained`. With the loose bound, scrolling back put the window's *right* edge on the oldest
+/// retained sample, which leaves the window's whole span to its left over data the scope never
+/// had -- an empty margin as wide as the view, reached by a pan or by a zoom-in near that edge.
+/// That is the "sometimes zooming in, the left or right margin becomes empty" report, and it is
+/// why the bound has to be about the window and not about one edge of it.
+PLOT_TEST(a_following_group_keeps_its_whole_window_on_the_data) {
+  plot::data::StreamSeries series(1u << 12, 0.0, 1.0 / 1000.0);
+  plot::f32 samples[512];
+  for (u32 i = 0; i < 512u; ++i) samples[i] = static_cast<plot::f32>(i % 7u);
+  series.push(samples, 512u);
+  series.acquire();
+
+  plot::Figure figure(1u);
+  figure.set_viewport({0.0f, 0.0f, 800.0f, 600.0f});
+  figure.plot(0u).add_x_axis({"t", {0.0, 1.0}, false, plot::AxisPlace::Bottom, false});
+  figure.plot(0u).add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  figure.plot(0u).add_trace({&series, plot::Color::hex(0x4FA3FF), 1.5f, 0u, 0u, "s"});
+  const u32 group = figure.add_x_link();
+  PLOT_CHECK(figure.link_x(0u, group));
+  PLOT_CHECK(figure.set_x_link_range(group, {0.0, 0.25}));
+  PLOT_CHECK(figure.set_x_link_follow(group, plot::XFollow::Live));
+  figure.layout();
+
+  const plot::Range data = series.x_bounds();
+  const f64 span = figure.x_link_range(group).span();
+  PLOT_CHECK(span > 0.0);
+  // Ask to scroll far past the oldest sample, the way a drag or a zoom-in near the left edge does.
+  PLOT_CHECK(figure.set_x_link_range(group, {data.min - 10.0 * span, data.min - 9.0 * span}));
+  figure.layout();
+
+  const plot::Range after = figure.x_link_range(group);
+  std::printf("[follow-bound] data=[%.4f..%.4f] span=%.4f after=[%.4f..%.4f]\n", data.min,
+              data.max, span, after.min, after.max);
+  // The window is still a window, and its *left* edge is on the data: that is the assertion the
+  // loose bound failed, where `after.min` came out a whole span below `data.min`.
+  PLOT_CHECK_NEAR(after.span(), span, 1e-9 * span);
+  PLOT_CHECK(after.min >= data.min - 1e-9);
+  PLOT_CHECK(after.max <= data.max + 1e-9);
+}
+
 PLOT_TEST(a_wheel_on_a_following_figures_axis_strip_keeps_the_live_edge) {
  constexpr u32 kFigureRows = 3u;
  constexpr f64 kWheelDx = 1.0 / 1000.0;
@@ -2309,3 +2371,35 @@ PLOT_TEST(double_click_needs_both_timestamps_and_the_window) {
  f.controller.on_pointer({410.0f, 200.0f, 0, 0, plot::input::Button::Left, 0, false, false,
                           true, 20.1});
 }
+
+// A readout cursor is drawn but not offered to the pointer: the host that keeps it is showing
+// a computed value, and a drag on it would be a drag on a number rather than on an instrument.
+// The hit test is where that is enforced -- re-placing the marker every frame would only fight
+// the drag, which is the shape this replaces.
+PLOT_TEST(an_unselectable_cursor_is_neither_hovered_nor_grabbed) {
+  plot::Plot p;
+  p.set_viewport({0, 0, 800, 400});
+  const u32 ax = p.add_x_axis({"t", {0.0, 100.0}, false, plot::AxisPlace::Bottom, false});
+  const u32 readout = p.add_cursor(50.0, plot::Color::hex(0x00FF00));
+  p.set_cursor_selectable(readout, false);
+  PLOT_CHECK(p.cursor(readout).visible);        // drawn all the same
+  PLOT_CHECK(!p.cursor(readout).selectable);
+  // A normal cursor right beside it stays grabbable, so the flag is a property of one cursor
+  // and not a switch on the plot.
+  const u32 normal = p.add_cursor(50.0, plot::Color::hex(0xFF0000));
+
+  plot::input::Controller c(p);
+  c.set_viewport({0, 0, 800, 400});
+  const f32 sx = screen_x_of(p, ax, 50.0);
+  c.on_pointer({sx, 200, 0, 0, plot::input::Button::Left, 0, false, false, false});
+  PLOT_CHECK(c.hovered_cursor() == normal);     // the readout is not in the running
+
+  // Press and move: the pointer grabbed the *normal* cursor (the two are at the same x, so
+  // the readout would otherwise be the nearer hit), and the readout's own x never moves.
+  const f64 before = p.cursor(readout).x;
+  c.on_pointer({sx, 200, 0, 0, plot::input::Button::Left, 0, true, true, false});
+  PLOT_CHECK(c.grabbed_cursor() == normal);
+  c.on_pointer({sx + 40, 200, 40, 0, plot::input::Button::Left, 0, true, false, false});
+  PLOT_CHECK_NEAR(p.cursor(readout).x, before, 1e-12);
+  PLOT_CHECK(c.grabbed_cursor() == normal);
+}
@@ -425,6 +425,52 @@ PLOT_TEST(figure_gutter_never_squeezes_the_axes_below_the_floor) {
  }
 }

+/// The other side of the same band. `axes` reached the viewport's right edge, which left
+/// the rightmost x tick label -- centred on it -- half outside the plot, so a figure can
+/// ask for an empty band there. One value for every row, like the left gutter, because
+/// the rows' axes have to end on a common column as well as start on one.
+PLOT_TEST(figure_rows_share_one_right_gutter) {
+  plot::Figure figure = different_magnitude_figure();
+  figure.layout();
+  const plot::f32 flush = figure.plot(0u).layout().axes.right();
+  PLOT_CHECK_NEAR(static_cast<plot::f64>(figure.right_gutter()), 0.0, 1e-12);
+  // The default is the layout as it always was: nothing between the data and the frame.
+  PLOT_CHECK_NEAR(static_cast<plot::f64>(flush), static_cast<plot::f64>(kW), 1e-4);
+
+  figure.set_right_gutter(30.0f);
+  figure.layout();
+  const plot::Rect first = figure.plot(0u).layout().axes;
+  for (plot::u32 row = 0; row < 3u; ++row) {
+    const plot::PlotLayout& rl = figure.plot(row).layout();
+    PLOT_CHECK_NEAR(static_cast<plot::f64>(rl.right_gutter), 30.0, 1e-4);
+    PLOT_CHECK_NEAR(static_cast<plot::f64>(rl.axes.right()), static_cast<plot::f64>(kW) - 30.0,
+                    1e-4);
+    // The band comes off the right alone: the left gutter the rows agreed on is untouched,
+    // so a host can balance the two sides without the one moving when it sets the other.
+    PLOT_CHECK_NEAR(static_cast<plot::f64>(rl.axes.x), static_cast<plot::f64>(first.x), 1e-4);
+    PLOT_CHECK_NEAR(static_cast<plot::f64>(rl.axes.w), static_cast<plot::f64>(first.w), 1e-4);
+    // ... and the x strip follows the data area rather than the viewport, or the shared
+    // axis would be labelled over a band that holds no data.
+    PLOT_CHECK_NEAR(static_cast<plot::f64>(rl.x_label_area.w), static_cast<plot::f64>(rl.axes.w),
+                    1e-4);
+  }
+  // Clamped by the same cap as the strips: a band wider than the whole figure cannot
+  // squeeze `axes` below the floor `Plot::layout()` guarantees.
+  figure.set_right_gutter(10.0f * kW);
+  figure.layout();
+  for (plot::u32 row = 0; row < 3u; ++row) {
+    const plot::Rect& axes = figure.plot(row).layout().axes;
+    PLOT_CHECK(axes.w >= 0.5f * kW - 1e-3f);
+  }
+  // Negative means "none", like the gutter and the row gap, and the data area goes back
+  // to the viewport's edge.
+  figure.set_right_gutter(-5.0f);
+  PLOT_CHECK_NEAR(static_cast<plot::f64>(figure.right_gutter()), 0.0, 1e-12);
+  figure.layout();
+  PLOT_CHECK_NEAR(static_cast<plot::f64>(figure.plot(0u).layout().axes.right()),
+                  static_cast<plot::f64>(flush), 1e-4);
+}
+
 /// The degenerate neighbour: a figure of one row imposes exactly what that row
 /// measured, so it lays out as the plot would on its own -- the gutter cannot move a
 /// row that has no sibling to line up with.
@@ -844,20 +890,29 @@ PLOT_TEST(a_following_log_group_holds_decades) {

  // A member panned while the group follows: the adopted scroll state is the
  // adopted range's span *in decades* -- two here (edge/1000 to edge/10 is a
-  // factor of 100) -- and the offset one decade behind the edge, both of which
-  // survive the next frames' advances.
+  // factor of 100) -- and the offset as far behind the edge as the retained data
+  // allows, both of which survive the next frames' advances.
+  //
+  // The pan *asks* for a full decade back, and the group may not take it: the offset is bounded by
+  // `retained - span`, so the window stops with its left edge on the oldest sample. Asserting
+  // `max == edge/10` here was asserting the *old* bound, which put a whole span of the window over
+  // data the members never held -- the empty-left-margin defect this bound exists for. The
+  // log-space assertions above are this test's subject and are unchanged.
  const plot::f64 edge = left.x_bounds().max;
  figure.plot(1u).set_x_range(0u, {edge / 1000.0, edge / 10.0});
  figure.layout();
  PLOT_CHECK_NEAR(decades_of(figure.plot(0u)), 2.0, 1e-9);
  PLOT_CHECK_NEAR(decades_of(figure.plot(1u)), 2.0, 1e-9);
-  PLOT_CHECK_NEAR(figure.plot(0u).x_range(0u).max, edge / 10.0, 1e-8);
+  const plot::f64 oldest = std::min(left.x_bounds().min, right.x_bounds().min);
+  PLOT_CHECK(figure.plot(0u).x_range(0u).min >= oldest - 1e-6);
+  PLOT_CHECK(figure.plot(0u).x_range(0u).max <= edge + 1e-6);
  for (int step = 0; step < 3; ++step) {
    left.push(0.5f);
    left.acquire();
    figure.layout();
    PLOT_CHECK_NEAR(decades_of(figure.plot(0u)), 2.0, 1e-9);
    PLOT_CHECK_NEAR(decades_of(figure.plot(1u)), 2.0, 1e-9);
+    PLOT_CHECK(figure.plot(0u).x_range(0u).min >= oldest - 1e-6);
  }
  PLOT_CHECK(figure.x_link_follow(group) == plot::XFollow::Live);
 }
@@ -868,8 +923,8 @@ namespace {

 /// The figure the crosshair cases hover: three rows at deliberately *different* sample rates on
 /// the one shared x, plus a fourth whose data does not reach the hovered x at all. Rows that
-/// sample at different rates are the point -- one x, three different interpolations -- and the
-/// last row is the case a readout must not invent a value for.
+/// sample at different rates are the point -- one x, and each row reporting a sample off its own
+/// grid -- and the last row is the case a readout must not invent a value for.
 plot::Figure crosshair_figure() {
  plot::Figure figure(4u);
  figure.set_viewport(whole_figure());
@@ -897,7 +952,7 @@ plot::Figure crosshair_figure() {

 /// Spec §15, the sync: `Figure::set_crosshair()` applies **one** data x to every row, so one
 /// hover is one instant and N readouts rather than N independent ones. Rows at different sample
-/// rates therefore report *their own* interpolations of the same x -- the shared axis is x, and
+/// rates therefore report *their own* nearest sample to the same x -- the shared axis is x, and
 /// each row's series is read on its own grid -- while a row whose series does not reach that x
 /// reports no value at all instead of a fabricated one.
 PLOT_TEST(figure_crosshair_applies_one_x_to_every_row) {
@@ -921,14 +976,15 @@ PLOT_TEST(figure_crosshair_applies_one_x_to_every_row) {
  PLOT_CHECK(first.rows[0].label == "fast");
  PLOT_CHECK_NEAR(first.rows[0].y, 30.0, 1e-9);

-  // Row 1 samples every *two* units: x = 3 is halfway between sample 1 (y = 100) and sample 2
-  // (y = 200), so it reports 150 -- a different number for the same x, which is what makes this
-  // case about the rows rather than about one series read four times.
+  // Row 1 samples every *two* units: x = 3 is halfway between sample 1 (x = 2, y = 100) and
+  // sample 2 (x = 4, y = 200), which is the tie, so it reports sample 1's 100 -- a different
+  // number for the same x, which is what makes this case about the rows rather than about one
+  // series read four times. Not 150: a readout quotes a sample, and this row has none at x = 3.
  const plot::CrosshairLayout& second = figure.plot(1u).layout().crosshair;
  PLOT_CHECK(second.rows.size() == 1u);
  PLOT_CHECK(second.rows[0].valid);
  PLOT_CHECK(second.rows[0].label == "slow");
-  PLOT_CHECK_NEAR(second.rows[0].y, 150.0, 1e-9);
+  PLOT_CHECK_NEAR(second.rows[0].y, 100.0, 1e-9);
  PLOT_CHECK(second.rows[0].value != first.rows[0].value);

  // Row 2's trace has no series yet: no row at all -- it is not a signal under the pointer.
@@ -963,7 +1019,9 @@ PLOT_TEST(figure_crosshair_applies_one_x_to_every_row) {
    PLOT_CHECK_NEAR(figure.plot(row).crosshair().x, 1.0, 1e-12);
  }
  PLOT_CHECK_NEAR(figure.plot(0u).layout().crosshair.rows[0].y, 10.0, 1e-9);
-  PLOT_CHECK_NEAR(figure.plot(1u).layout().crosshair.rows[0].y, 50.0, 1e-9);  // 0 + 100 * 0.5
+  // Not 50: x = 1 is the tie between this row's samples at x = 0 (y = 0) and x = 2 (y = 100),
+  // and a readout quotes one of them.
+  PLOT_CHECK_NEAR(figure.plot(1u).layout().crosshair.rows[0].y, 0.0, 1e-9);
  PLOT_CHECK(!figure.plot(3u).layout().crosshair.rows[0].valid);

  // On *every* row at once, and only the rows free it.
@@ -1939,11 +1939,11 @@ class CountingSeries final : public plot::data::Series {
  }
  plot::Range y_bounds() const override { return {0.0, 99.0}; }
  const plot::data::MinMaxPyramid& pyramid() const override { return pyramid_; }
-  void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out,
+  void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out,
              plot::data::GatherMode mode = plot::data::GatherMode::Envelope) const override {
    ++gather_calls_;
    samples_read_ += end - begin;
-    gather_impl(level, begin, end, out, mode);
+    gather_impl(level, begin, end, x_origin, out, mode);
  }

  u64 gather_calls() const noexcept { return gather_calls_; }
@@ -1965,20 +1965,21 @@ class CountingSeries final : public plot::data::Series {

 }  // namespace

-/// Spec §15, the lookup: a readout's y is **linear interpolation between the two samples
-/// adjacent to the crosshair's x**, and hand-computed here rather than checked against the
-/// implementation's own arithmetic. The four corners of the rule are all asserted: a query
-/// between two samples, the two exact-sample ends of the window (where the span collapses onto
-/// one sample), and a one-sample series, whose window is that sample alone.
-PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
+/// Spec §15, the lookup: a readout's y is **the nearer of the two samples adjacent to the
+/// crosshair's x**, never a value between them. Every y asserted here is therefore one of the
+/// series' own `tens` values -- a number *between* two of them, 15 or 22.5, is precisely what
+/// this refuses, and what it used to return. The corners of the rule are all covered: a query
+/// either side of the midpoint, a query exactly on it (the tie), the two exact-sample ends of
+/// the window (where the span collapses onto one sample), and a one-sample series.
+PLOT_TEST(crosshair_value_is_the_nearest_sample) {
  CrosshairScene scene;
  const u32 trace = scene.plot.add_trace(
      {&scene.series, plot::Color::hex(0x40C0FF), 1.5f, scene.ax, scene.ay});

  // The span itself, for a query halfway between sample 1 (x = 1, y = 10) and sample 2
-  // (x = 2, y = 20): the two neighbours, and the fraction between them. Asserting the span and
-  // not only the value is what pins the convention -- a nearest-sample lookup would report the
-  // span's `t` as 0 or 1, and an average of a *range* would not report a span at all.
+  // (x = 2, y = 20): the two neighbours, and the fraction between them. The span still reports
+  // both and the fraction between them -- `t` is a *selector* now, not a blend factor, so the
+  // bracketing is unchanged and only what is built from it differs.
  const plot::CrosshairSpan half = plot::crosshair_span(scene.series, 1.5);
  PLOT_CHECK(half.valid);
  PLOT_CHECK(half.begin == 1u);
@@ -1986,14 +1987,25 @@ PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
  PLOT_CHECK_NEAR(half.t, 0.5, 1e-12);

  f64 y = 0.0;
+  // Either side of the midpoint reads the sample it is nearer to, and *is* that sample: 10 and
+  // 20 are `tens` values, where an interpolation would have answered 11 and 19.
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.1, y));
+  PLOT_CHECK_NEAR(y, 10.0, 1e-9);
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.9, y));
+  PLOT_CHECK_NEAR(y, 20.0, 1e-9);
+  // Exactly halfway is the tie, and it reads the *earlier* sample -- the bias
+  // `crosshair_span()` already takes for a degenerate pair. 15.0 is the old answer.
  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.5, y));
-  PLOT_CHECK_NEAR(y, 15.0, 1e-9);
-  // A quarter of the way through another pair: 20 + (30 - 20) * 0.25.
+  PLOT_CHECK_NEAR(y, 10.0, 1e-9);
+  // A quarter of the way through another pair: sample 2, not 22.5.
  PLOT_CHECK(scene.plot.crosshair_value(trace, 2.25, y));
-  PLOT_CHECK_NEAR(y, 22.5, 1e-9);
+  PLOT_CHECK_NEAR(y, 20.0, 1e-9);
+  // Just short of the next sample is that sample, so the readout steps rather than ramps.
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 2.99, y));
+  PLOT_CHECK_NEAR(y, 30.0, 1e-9);

  // The ends of the window are samples too, so a query exactly on one reads that sample --
-  // and reads it *as* a span of one, with nothing to its left or right to interpolate with.
+  // and reads it *as* a span of one, with no neighbour on the far side.
  const plot::CrosshairSpan first = plot::crosshair_span(scene.series, 0.0);
  PLOT_CHECK(first.valid);
  PLOT_CHECK(first.begin == 0u);
@@ -2008,9 +2020,10 @@ PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
  PLOT_CHECK(scene.plot.crosshair_value(trace, 3.0, y));
  PLOT_CHECK_NEAR(y, 30.0, 1e-9);

-  // Outside the window there is no value at all -- not the nearest sample's, not the end of
-  // the window's, which are the clamped lies the header refuses -- and a series with no
-  // samples has no span at any x.
+  // Outside the window there is no value at all. The nearest-sample rule is a rule for an x the
+  // series *brackets*; extending it past the ends would answer with the first or last sample for
+  // any x whatever, which is the clamped lie the header refuses. A series with no samples has no
+  // span at any x.
  PLOT_CHECK(!plot::crosshair_span(scene.series, -1e-9).valid);
  PLOT_CHECK(!plot::crosshair_span(scene.series, 3.0 + 1e-9).valid);
  PLOT_CHECK(!scene.plot.crosshair_value(trace, 4.0, y));
@@ -2023,7 +2036,7 @@ PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
  PLOT_CHECK(!scene.plot.crosshair_value(/*trace=*/99u, 1.0, y));  // an id that names nothing

  // A one-sample series: the sample itself is the only query it answers, and it answers it
-  // without a neighbour to interpolate against.
+  // with no second sample to be nearer to.
  plot::data::ArraySeries single(std::vector<f32>{7.0f}, 5.0, 1.0);
  plot::Plot one;
  one.add_x_axis({"t", {0.0, 10.0}, false, plot::AxisPlace::Bottom, false});
@@ -2039,7 +2052,9 @@ PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
  PLOT_CHECK(!one.crosshair_value(single_trace, 5.5, y));

  // The readout's row is the same lookup: the number a user reads off the panel is the value
-  // this test computed by hand, not a second derivation of it.
+  // this test computed by hand, not a second derivation of it. x = 1.5 is the tie, so the row
+  // reads sample 1 -- and the formatted cell is `"10"`, where the interpolating readout showed
+  // `"15"`, a number the series does not contain.
  scene.plot.set_crosshair(1.5, true);
  const plot::CrosshairLayout& crosshair = scene.plot.layout().crosshair;
  PLOT_CHECK(crosshair.active);
@@ -2049,8 +2064,136 @@ PLOT_TEST(crosshair_value_is_interpolated_between_neighbours) {
  // the figure's case pins).
  PLOT_CHECK(crosshair.rows.size() == 1u);
  PLOT_CHECK(crosshair.rows[0].valid);
-  PLOT_CHECK_NEAR(crosshair.rows[0].y, 15.0, 1e-9);
-  PLOT_CHECK(crosshair.rows[0].value == "15");
+  PLOT_CHECK_NEAR(crosshair.rows[0].y, 10.0, 1e-9);
+  PLOT_CHECK(crosshair.rows[0].value == "10");
+}
+
+/// The mark is **snapped to the sample the row quotes**, which is what makes it say *which*
+/// value is being read. Placing it at the pointer's x with the sample's y put it on neither the
+/// data nor the polyline, and the further a reader zoomed in the further off it sat -- a mark on
+/// nothing.
+///
+/// The queries here are all **off** a sample on purpose, so "snapped" has something to be wrong
+/// about: the assertion is that `row.x` is a `tens` grid position (0, 1, 2, 3) and not the query,
+/// and that `row.marker` is that position mapped through the trace's own axes. The pixel column
+/// is computed from the transform the plot already exposes, so this checks the two agree rather
+/// than re-deriving the mapping.
+PLOT_TEST(the_crosshair_marker_snaps_to_the_sample_it_reports) {
+  CrosshairScene scene;
+  const u32 trace = scene.plot.add_trace(
+      {&scene.series, plot::Color::hex(0x40C0FF), 1.5f, scene.ax, scene.ay, "sine"});
+
+  // A query between samples 1 and 2, nearer 2: the point is sample 2 entire -- x = 2 as well as
+  // y = 20 -- so the mark lands on the datum and not a fifth of a division to its left.
+  f64 px = 0.0;
+  f64 py = 0.0;
+  PLOT_CHECK(scene.plot.crosshair_point(trace, 1.8, px, py));
+  PLOT_CHECK_NEAR(px, 2.0, 1e-12);
+  PLOT_CHECK_NEAR(py, 20.0, 1e-9);
+  // The tie takes the earlier sample, and takes *its* x with it: the same bias in both
+  // coordinates, so the mark and the number can never name different samples.
+  PLOT_CHECK(scene.plot.crosshair_point(trace, 1.5, px, py));
+  PLOT_CHECK_NEAR(px, 1.0, 1e-12);
+  PLOT_CHECK_NEAR(py, 10.0, 1e-9);
+  // `crosshair_value()` is the same call with the x dropped, so the two cannot disagree.
+  f64 y_only = 0.0;
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.5, y_only));
+  PLOT_CHECK_NEAR(y_only, py, 1e-12);
+  // A failing lookup leaves both outputs alone, as the value form does.
+  PLOT_CHECK(!scene.plot.crosshair_point(trace, 9.0, px, py));
+  PLOT_CHECK_NEAR(px, 1.0, 1e-12);
+
+  // And through the layout: the row carries the snapped x, and the marker is that x through the
+  // trace's own transform -- not the crosshair's column, which is where it used to be.
+  scene.plot.set_crosshair(1.8, true);
+  scene.plot.layout();
+  const plot::CrosshairRow& row = scene.plot.layout().crosshair.rows[0];
+  PLOT_CHECK(row.valid);
+  PLOT_CHECK_NEAR(row.x, 2.0, 1e-12);
+  PLOT_CHECK_NEAR(row.y, 20.0, 1e-9);
+  const f32 sample_col = static_cast<f32>(scene.plot.x_transform(scene.ax).to_screen_x(2.0));
+  const f32 pointer_col = static_cast<f32>(scene.plot.x_transform(scene.ax).to_screen_x(1.8));
+  PLOT_CHECK_NEAR(row.marker.x, sample_col, 1e-3);
+  PLOT_CHECK_NEAR(row.marker.y,
+                  static_cast<f32>(scene.plot.y_transform(scene.ay).to_screen_y(20.0)), 1e-3);
+  // The two columns are far apart at this scale, so the check above is not satisfied by both
+  // being nearly the same number.
+  PLOT_CHECK(std::abs(row.marker.x - pointer_col) > 10.0f);
+  // The vertical line stays on the *pointer*: it is where the hover is, and only the mark moved.
+  PLOT_CHECK_NEAR(scene.plot.layout().crosshair.vertical.x +
+                      0.5f * scene.plot.layout().crosshair.vertical.w,
+                  pointer_col, 1e-3);
+}
+
+/// The other mode, and the reason it exists: `CrosshairValue::Interpolated` answers "what is the
+/// signal *at* this instant" by blending the two bracketing samples, for a caller whose data is a
+/// continuous quantity sampled finely enough that the line between two samples is a model it
+/// believes. `NearestSample` is the default because that line is an artefact of plotting for most
+/// sources -- see `CrosshairValue` -- but the question is about the data, so the library offers
+/// both rather than picking for the caller.
+///
+/// Every number here is one the *other* mode refuses, so the two are pinned apart rather than
+/// merely exercised: 15 at the tie, 11 and 19 either side of it. The marker moves with the value,
+/// which is the mode's second half -- an interpolated y belongs at the pointer's x, on the
+/// polyline, and nowhere else.
+PLOT_TEST(crosshair_interpolated_mode_blends_the_two_samples) {
+  CrosshairScene scene;
+  const u32 trace = scene.plot.add_trace(
+      {&scene.series, plot::Color::hex(0x40C0FF), 1.5f, scene.ax, scene.ay, "sine"});
+  PLOT_CHECK(scene.plot.crosshair_value_mode() == plot::CrosshairValue::NearestSample);
+  scene.plot.set_crosshair_value_mode(plot::CrosshairValue::Interpolated);
+  PLOT_CHECK(scene.plot.crosshair_value_mode() == plot::CrosshairValue::Interpolated);
+
+  f64 y = 0.0;
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.5, y));
+  PLOT_CHECK_NEAR(y, 15.0, 1e-9);
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.1, y));
+  PLOT_CHECK_NEAR(y, 11.0, 1e-9);
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 1.9, y));
+  PLOT_CHECK_NEAR(y, 19.0, 1e-9);
+  // A query *on* a sample reads that sample back exactly in this mode too: the span collapses to
+  // one index, `t` is 0, and `crosshair_interpolate()`'s form returns `y_begin` unrounded.
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 2.0, y));
+  PLOT_CHECK(y == 20.0);
+  PLOT_CHECK(plot::crosshair_interpolate(10.0, 20.0, 0.0) == 10.0);
+  PLOT_CHECK(plot::crosshair_interpolate(10.0, 20.0, 1.0) == 20.0);
+  PLOT_CHECK_NEAR(plot::crosshair_interpolate(10.0, 20.0, 0.25), 12.5, 1e-12);
+  // Out of the window is still no value: interpolating needs two samples to be between.
+  PLOT_CHECK(!scene.plot.crosshair_value(trace, 4.0, y));
+
+  // The point is the *query's* x here, not a sample's, so the mark sits on the polyline where the
+  // number is -- the opposite placement from `NearestSample`, and the mode's visible half.
+  f64 px = 0.0;
+  f64 py = 0.0;
+  PLOT_CHECK(scene.plot.crosshair_point(trace, 1.8, px, py));
+  PLOT_CHECK_NEAR(px, 1.8, 1e-12);
+  PLOT_CHECK_NEAR(py, 18.0, 1e-9);
+  scene.plot.set_crosshair(1.8, true);
+  scene.plot.layout();
+  const plot::CrosshairRow& row = scene.plot.layout().crosshair.rows[0];
+  PLOT_CHECK_NEAR(row.x, 1.8, 1e-12);
+  PLOT_CHECK(row.value == "18");
+  const f32 pointer_col = static_cast<f32>(scene.plot.x_transform(scene.ax).to_screen_x(1.8));
+  PLOT_CHECK_NEAR(row.marker.x, pointer_col, 1e-3);
+
+  // Switching back is a plain state change, with no second placement to keep in step: the next
+  // layout reports the sample again.
+  scene.plot.set_crosshair_value_mode(plot::CrosshairValue::NearestSample);
+  scene.plot.layout();
+  PLOT_CHECK_NEAR(scene.plot.layout().crosshair.rows[0].x, 2.0, 1e-12);
+  PLOT_CHECK_NEAR(scene.plot.layout().crosshair.rows[0].y, 20.0, 1e-9);
+}
+
+/// The mark has to be **bigger than a trace's own sample dots**, because in the default mode it is
+/// snapped onto one of them: at the same size it reads as one more sample rather than as the one
+/// the panel is quoting. That is a property of the defaults, not of a drawing call, so it is
+/// asserted where it is decided -- a later edit that tunes `marker_px` up past the crosshair's is
+/// the regression, and nothing else in the library would notice.
+PLOT_TEST(the_crosshair_mark_is_bigger_than_a_sample_dot) {
+  const plot::render::Style style;
+  PLOT_CHECK(style.crosshair_marker_px > style.marker_px);
+  // And heavier than the crosshair's own lines, which are chrome and recede on purpose.
+  PLOT_CHECK(style.crosshair_marker_width > style.crosshair_width);
 }

 /// Spec §15, the readout's membership: **every visible trace gets a row, whether or not it is
@@ -2080,14 +2223,16 @@ PLOT_TEST(crosshair_readout_lists_every_visible_trace_including_unnamed_ones) {
  PLOT_CHECK(crosshair.rows[1].label == plot::crosshair_unnamed_label(1u));
  PLOT_CHECK(crosshair.rows[1].label == "#1");

-  // Both are listed with the value their own series has at x = 1.5, the swatch, the label's box
-  // and the value's box -- all placed by the plot, all inside the panel it measured.
+  // Both are listed with the value their own series has nearest x = 1.5, the swatch, the label's
+  // box and the value's box -- all placed by the plot, all inside the panel it measured. x = 1.5
+  // is the tie between samples 1 and 2, which reads the earlier one: 10, not the 15 an
+  // interpolating readout showed.
  PLOT_CHECK(crosshair.panel.w > 0.0f && crosshair.panel.h > 0.0f);
  for (const plot::CrosshairRow& row : crosshair.rows) {
    PLOT_CHECK(row.valid);
    PLOT_CHECK(row.listed);
-    PLOT_CHECK_NEAR(row.y, 15.0, 1e-9);
-    PLOT_CHECK(row.value == "15");
+    PLOT_CHECK_NEAR(row.y, 10.0, 1e-9);
+    PLOT_CHECK(row.value == "10");
    PLOT_CHECK(row.swatch.x >= crosshair.panel.x);
    PLOT_CHECK(row.swatch.right() <= crosshair.panel.right());
    PLOT_CHECK(row.swatch.y >= crosshair.panel.y);
@@ -2148,7 +2293,7 @@ PLOT_TEST(crosshair_readout_lists_every_visible_trace_including_unnamed_ones) {
  PLOT_CHECK(on.rows[0].listed);
  PLOT_CHECK(on.rows[1].listed);
  PLOT_CHECK(on.panel.w > 0.0f && on.panel.h > 0.0f);
-  PLOT_CHECK(on.rows[0].value == "15");
+  PLOT_CHECK(on.rows[0].value == "10");
 }

 /// Spec §15, the panel's placement: near the pointer, flipped over it where it would otherwise
@@ -2253,11 +2398,14 @@ PLOT_TEST(crosshair_lookup_does_not_scan) {
  p.add_y_axis({"v", {0.0, 99.0}, false, plot::AxisPlace::Left, false});
  const u32 trace = p.add_trace({&series, plot::Color::hex(0x40C0FF), 1.5f, 0u, 0u});

-  // A query between two samples: 1234 % 100 = 34, the next is 35, halfway between them.
+  // A query between two samples: 1234 % 100 = 34, the next is 35, and 1234.5 is the tie, which
+  // reads the earlier -- 34, where the interpolating readout answered 34.5. Both samples are
+  // still read: the bound below is on how much data the lookup touches, not on which end it
+  // then reports.
  f64 y = 0.0;
  const u64 before_reads = series.samples_read();
  PLOT_CHECK(p.crosshair_value(trace, 1234.5, y));
-  PLOT_CHECK_NEAR(y, 34.5, 1e-9);
+  PLOT_CHECK_NEAR(y, 34.0, 1e-9);
  PLOT_CHECK(series.samples_read() - before_reads <= 2u);
  PLOT_CHECK(series.gather_calls() <= 1u);

@@ -2288,7 +2436,7 @@ PLOT_TEST(crosshair_lookup_does_not_scan) {
  const plot::CrosshairLayout& crosshair = p.layout().crosshair;
  PLOT_CHECK(crosshair.rows.size() == 1u);
  PLOT_CHECK(crosshair.rows[0].valid);
-  PLOT_CHECK_NEAR(crosshair.rows[0].y, 34.5, 1e-9);
+  PLOT_CHECK_NEAR(crosshair.rows[0].y, 34.0, 1e-9);
  PLOT_CHECK(series.samples_read() - reads <= 2u);
  PLOT_CHECK(series.gather_calls() - calls <= 1u);
  // And the readout is not vacuous: the series it read two samples of really does hold a
@@ -2323,9 +2471,9 @@ class XyFixture final : public plot::data::Series {
  }
  plot::Range y_bounds() const override { return {0.0, 20.0}; }
  const plot::data::MinMaxPyramid& pyramid() const override { return pyramid_; }
-  void gather(u32 level, u64 begin, u64 end, std::vector<f32>& out,
+  void gather(u32 level, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out,
              plot::data::GatherMode mode = plot::data::GatherMode::Envelope) const override {
-    gather_impl(level, begin, end, out, mode);
+    gather_impl(level, begin, end, x_origin, out, mode);
  }

  f64 x_at(u64 i) const override { return x_[static_cast<std::size_t>(i)]; }
@@ -2511,9 +2659,12 @@ PLOT_TEST(scrolled_back_live_window_keeps_its_decades) {
 }

 /// The XY routing, crosshair half: the span brackets the samples the *array*
-/// names, and the interpolation fraction is measured on the samples' own positions
-/// -- (5-1)/(10-1) over the wide gap, where a uniform-grid guess would have read
-/// samples that do not exist at the positions it assumed.
+/// names, and `t` is measured on the samples' own positions -- (5-1)/(10-1) over the
+/// wide gap, where a uniform-grid guess would have read samples that do not exist at
+/// the positions it assumed. The gap is what makes the value worth asserting too:
+/// x = 5 sits 4 from sample 1 and 5 from sample 2, so the nearest-sample rule has a
+/// real choice to get right, and it only has that choice because `t` came from the
+/// array.
 PLOT_TEST(xy_series_crosshair_brackets_its_own_samples) {
  XyScene scene;
  const u32 trace = scene.plot.add_trace(
@@ -2526,7 +2677,11 @@ PLOT_TEST(xy_series_crosshair_brackets_its_own_samples) {
  PLOT_CHECK_NEAR(span.t, 4.0 / 9.0, 1e-12);
  f64 y = 0.0;
  PLOT_CHECK(scene.plot.crosshair_value(trace, 5.0, y));
-  PLOT_CHECK_NEAR(y, 10.0 + 10.0 * (4.0 / 9.0), 1e-9);
+  PLOT_CHECK_NEAR(y, 10.0, 1e-9);  // sample 1, the nearer end of the gap
+  // And past the gap's midpoint it is the other sample, so the choice is `t`'s and not a
+  // fixed preference for one end.
+  PLOT_CHECK(scene.plot.crosshair_value(trace, 6.0, y));
+  PLOT_CHECK_NEAR(y, 20.0, 1e-9);

  // On a sample, at both ends of the array's window, and outside it: the same
  // closed-window rule a uniform series follows, on the array's own coordinates.
@@ -2584,3 +2739,53 @@ PLOT_TEST(xy_series_measurement_uses_the_true_nearest_samples) {
  PLOT_CHECK_NEAR(stats.min, 10.0, 1e-9);
  PLOT_CHECK_NEAR(stats.max, 10.0, 1e-9);
 }
+
+// A host whose annotation is a readout -- the point where a cursor crosses a trace --
+// moves it every frame. The id has to survive that, and a stale id must be ignored
+// rather than read or written out of bounds, exactly as the cursors' setters behave.
+// A readout cursor says which readout it belongs to with its colour; the setter keeps the
+// id, and a stale one changes nothing.
+PLOT_TEST(a_cursor_can_be_recoloured_by_id) {
+  plot::Plot p;
+  const u32 id = p.add_cursor(2.0, plot::Color::hex(0x111111));
+  PLOT_CHECK(p.cursor(id).color.b == plot::Color::hex(0x111111).b);
+
+  p.set_cursor_color(id, plot::Color::hex(0x9BE8A0));
+  PLOT_CHECK(p.cursor(id).color.g == plot::Color::hex(0x9BE8A0).g);
+  PLOT_CHECK(p.cursor_count() == 1u);   // recoloured, not added
+  PLOT_CHECK_NEAR(p.cursor(id).x, 2.0, 1e-12);
+
+  p.set_cursor_color(42u, plot::Color::hex(0xFFFFFF));
+  PLOT_CHECK(p.cursor(id).color.g == plot::Color::hex(0x9BE8A0).g);
+}
+
+PLOT_TEST(an_annotation_can_be_moved_by_id) {
+  plot::Plot p;
+  const plot::Annotation pin{1.0, 2.0, "first", plot::Color::hex(0xE8E8E8), 0u, 0u, true};
+  const u32 id = p.add_annotation(pin);
+  PLOT_CHECK(p.annotation(id).x == 1.0);
+  PLOT_CHECK(p.annotation(id).text == std::string("first"));
+
+  plot::Annotation moved = pin;
+  moved.x = 3.5;
+  moved.y = -1.25;
+  moved.text = "moved";
+  p.set_annotation(id, moved);
+  PLOT_CHECK_NEAR(p.annotation(id).x, 3.5, 1e-12);
+  PLOT_CHECK_NEAR(p.annotation(id).y, -1.25, 1e-12);
+  PLOT_CHECK(p.annotation(id).text == std::string("moved"));
+  PLOT_CHECK(p.annotation_count() == 1u);  // moved, not added
+
+  // Parked rather than removed, like a cursor: the id stays valid and reads back hidden.
+  plot::Annotation parked = moved;
+  parked.visible = false;
+  p.set_annotation(id, parked);
+  PLOT_CHECK(!p.annotation(id).visible);
+  PLOT_CHECK(p.annotation_count() == 1u);
+
+  // A stale id changes nothing (and reads a default, as the accessors promise).
+  plot::Annotation other = pin;
+  other.x = 99.0;
+  p.set_annotation(42u, other);
+  PLOT_CHECK_NEAR(p.annotation(id).x, 3.5, 1e-12);
+}
@@ -24,7 +24,7 @@ PLOT_TEST(array_series_bounds_and_gather) {
  PLOT_CHECK_NEAR(s.x_bounds().max, 11.5, 1e-9);
  PLOT_CHECK_NEAR(s.y_bounds().min, -2.0, 1e-6);
  std::vector<f32> out;
-  s.gather(0, 0, 4, out);
+  s.gather(0, 0, 4, s.x0(), out);
  PLOT_CHECK(out.size() == 8);             // interleaved x,y
  // x is relative to x0(): sample 0 emits 0, not 10 (the relative-x contract).
  PLOT_CHECK_NEAR(out[0], 0.0, 1e-6);
@@ -104,7 +104,7 @@ PLOT_TEST(stream_series_exact_queries_survive_ring_wrap) {
  PLOT_CHECK_NEAR(s.sumsq(0, n), sumsq, 1e-1);

  std::vector<f32> out;
-  s.gather(0, 0, n, out);                               // level 0: raw samples
+  s.gather(0, 0, n, s.x0(), out);                               // level 0: raw samples
  PLOT_CHECK(out.size() == 2 * n);
  // x is relative to x0(): the oldest retained sample emits 0, the newest
  // (n - 1) * dx, never the absolute data coordinates (relative-x contract).
@@ -157,7 +157,7 @@ PLOT_TEST(stream_series_push_and_read_are_race_free) {
      (void)s.sum(0, n);
      (void)s.sumsq(0, n);
      std::vector<f32> out;
-      s.gather(0, 0, n, out);                           // reads the oldest edge
+      s.gather(0, 0, n, s.x0(), out);                           // reads the oldest edge
      if (out.size() != 2 * n) sizes_ok = false;
    }
    ++reads;
@@ -258,7 +258,7 @@ PLOT_TEST(stream_series_sliding_window_queries_match_bruteforce) {
  // wholly at or after window index 0, `last` one past the last wholly inside
  // the window -- so every emitted bucket's samples lie inside the window.
  std::vector<f32> out;
-  s.gather(1, 0, n, out);
+  s.gather(1, 0, n, s.x0(), out);
  const u64 first =
      std::max(base / span + (base % span == 0 ? u64{0} : u64{1}), lbase);   // ceil, then clamp
  const u64 last = std::min((base + n) / span, lbase + lsize);
@@ -374,7 +374,7 @@ PLOT_TEST(gather_at_a_lod_level_reaches_both_ends_of_the_window) {

  const auto check_ends = [&](u32 level) {
    std::vector<f32> out;
-    s.gather(level, 0, n, out);
+    s.gather(level, 0, n, s.x0(), out);
    PLOT_CHECK(out.size() >= 8u);
    // Oldest: the first emitted pair is the retained sample at index 0, not the
    // first whole bucket (which starts `lead` samples later). x is relative to
@@ -403,7 +403,7 @@ PLOT_TEST(gather_at_a_lod_level_reaches_both_ends_of_the_window) {
  PLOT_CHECK((ny % 256u) != 0u);   // 5000 = 19 * 256 + 136 at level 2
  plot::data::ArraySeries a(y, 0.0, 1e-6);
  std::vector<f32> out;
-  a.gather(2, 0, ny, out);
+  a.gather(2, 0, ny, a.x0(), out);
  PLOT_CHECK(out.size() >= 8u);
  PLOT_CHECK_NEAR(out[0], 0.0, 1e-9);                       // level 2 starts on the grid
  PLOT_CHECK_NEAR(out[out.size() - 2], f32(f64(ny - 1) * 1e-6), 1e-9);
@@ -469,7 +469,7 @@ PLOT_TEST(gather_envelope_stays_inside_an_unaligned_range) {

  const auto check_range = [&](u32 level) {
    std::vector<f32> out;
-    s.gather(level, b, e, out);
+    s.gather(level, b, e, s.x0(), out);
    PLOT_CHECK(out.size() >= 4u);
    for (plot::usize i = 0; i + 1 < out.size(); i += 2) {
      PLOT_CHECK(f64(out[i]) >= f64(b));    // emitted x inside [begin, end)
@@ -499,7 +499,7 @@ PLOT_TEST(gather_envelope_stays_inside_an_unaligned_range) {
  const u64 buckets = last - first;
  PLOT_CHECK(lead > b && last * span < e);   // both edge spans really are partial
  std::vector<f32> out;
-  s.gather(level, b, e, out);
+  s.gather(level, b, e, s.x0(), out);
  PLOT_CHECK(out.size() == 2 * ((lead - b) + 2 * buckets + (e - last * span)));
  plot::usize o = 0;
  for (u64 i = b; i < lead; ++i, o += 2) {   // the partial leading bucket, raw
@@ -544,7 +544,7 @@ PLOT_TEST(stream_gather_envelope_stays_inside_an_unaligned_range) {
  const plot::Range exact = s.reduce(b, e);
  PLOT_CHECK(exact.max < 1.0 && exact.min > -1.0);
  std::vector<f32> out;
-  s.gather(1, b, e, out);
+  s.gather(1, b, e, s.x0(), out);
  PLOT_CHECK(out.size() >= 4u);
  for (plot::usize i = 0; i + 1 < out.size(); i += 2) {
    PLOT_CHECK(f64(out[i]) >= f64(b));              // relative x inside [begin, end)
@@ -614,11 +614,11 @@ PLOT_TEST(gather_level_beyond_the_pyramid_clamps) {
  for (u64 i = 0; i < y.size(); ++i) y[i] = f32(i % 13) - 6.0f;
  plot::data::ArraySeries s(std::move(y), 0.0, 1.0);
  std::vector<f32> deepest;
-  s.gather(plot::data::kMaxPyramidLevel, 0, s.size(), deepest);
+  s.gather(plot::data::kMaxPyramidLevel, 0, s.size(), s.x0(), deepest);
  PLOT_CHECK(!deepest.empty());
  for (const u32 level : {u32{58}, u32{200}, u32{1000}, ~u32{0}}) {
    std::vector<f32> out;
-    s.gather(level, 0, s.size(), out);
+    s.gather(level, 0, s.size(), s.x0(), out);
    PLOT_CHECK(out == deepest);   // clamped to the same deepest geometry
  }
  // The cap is where the span shift still fits: level 57 spans exactly 2^63.
@@ -657,9 +657,9 @@ PLOT_TEST(gather_modes_envelope_nearest_mean) {
  PLOT_CHECK(buckets == 16);

  std::vector<f32> env, near, mean;
-  s.gather(level, 0, kN, env, plot::data::GatherMode::Envelope);
-  s.gather(level, 0, kN, near, plot::data::GatherMode::Nearest);
-  s.gather(level, 0, kN, mean, plot::data::GatherMode::Mean);
+  s.gather(level, 0, kN, s.x0(), env, plot::data::GatherMode::Envelope);
+  s.gather(level, 0, kN, s.x0(), near, plot::data::GatherMode::Nearest);
+  s.gather(level, 0, kN, s.x0(), mean, plot::data::GatherMode::Mean);

  // Envelope: two points per bucket, min at the bucket's first sample, max at
  // its last (this sawtooth's per-bucket min is its first sample's value and
@@ -692,7 +692,7 @@ PLOT_TEST(gather_modes_envelope_nearest_mean) {

  // Level 0 and sub-bucket ranges are the raw samples for every mode.
  std::vector<f32> raw;
-  s.gather(0, 5, 300, raw, plot::data::GatherMode::Mean);
+  s.gather(0, 5, 300, s.x0(), raw, plot::data::GatherMode::Mean);
  PLOT_CHECK(raw.size() == 2 * (300 - 5));
  PLOT_CHECK_NEAR(raw[0], 5.0, 1e-9);
 }
@@ -712,17 +712,17 @@ PLOT_TEST(gather_skips_all_nan_buckets) {

  // first = 0, last = 256/128 = 2: buckets 0 and 1, no lead/trail raw spans.
  std::vector<f32> env, mean, near;
-  s.gather(1, 0, 256, env, plot::data::GatherMode::Envelope);
+  s.gather(1, 0, 256, s.x0(), env, plot::data::GatherMode::Envelope);
  PLOT_CHECK(env.size() == 4);              // bucket 0's two pairs only
  PLOT_CHECK_NEAR(env[0], 0.0, 1e-9);
  PLOT_CHECK_NEAR(env[1], 1.0, 1e-9);
  PLOT_CHECK_NEAR(env[2], 127.0, 1e-9);
  PLOT_CHECK_NEAR(env[3], 1.0, 1e-9);
-  s.gather(1, 0, 256, mean, plot::data::GatherMode::Mean);
+  s.gather(1, 0, 256, s.x0(), mean, plot::data::GatherMode::Mean);
  PLOT_CHECK(mean.size() == 2);             // bucket 1 has no finite mean: skipped
  PLOT_CHECK_NEAR(mean[0], 64.0, 1e-9);
  PLOT_CHECK_NEAR(mean[1], 1.0, 1e-9);
-  s.gather(1, 0, 256, near, plot::data::GatherMode::Nearest);
+  s.gather(1, 0, 256, s.x0(), near, plot::data::GatherMode::Nearest);
  PLOT_CHECK(near.size() == 4);             // every bucket still has a centre sample
  PLOT_CHECK_NEAR(near[0], 64.0, 1e-9);
  PLOT_CHECK_NEAR(near[1], 1.0, 1e-9);
@@ -739,7 +739,7 @@ PLOT_TEST(stream_series_freeze_copies_the_last_acquire_window) {
  const u64 n = s.size();
  const plot::Range bounds = s.y_bounds();
  std::vector<f32> gathered;
-  s.gather(1, 0, n, gathered);
+  s.gather(1, 0, n, s.x0(), gathered);
  const plot::Range reduced = s.reduce(0, n);

  // Freeze now, while the ring still holds exactly the published window.
@@ -754,7 +754,7 @@ PLOT_TEST(stream_series_freeze_copies_the_last_acquire_window) {
  PLOT_CHECK_NEAR(fr.max, reduced.max, 1e-6);
  PLOT_CHECK_NEAR(frozen.sum(0, n), s.sum(0, n), 1e-3);
  std::vector<f32> frozen_gathered;
-  frozen.gather(1, 0, n, frozen_gathered);
+  frozen.gather(1, 0, n, frozen.x0(), frozen_gathered);
  PLOT_CHECK(frozen_gathered == gathered);   // same geometry, byte for byte

  // The producer now laps the ring (700 more pushes overwrite the oldest
@@ -769,6 +769,46 @@ PLOT_TEST(stream_series_freeze_copies_the_last_acquire_window) {
  PLOT_CHECK(frozen.reduce(0, n).max == reduced.max);
 }

+// --- The gather origin: f32 precision against the view, not the window -------
+
+PLOT_TEST(a_gather_origin_at_the_view_keeps_a_deep_zoom_on_the_sample_it_quotes) {
+  // 20 s of retained data at 1 kS/s examined through a 10 us window -- the shape of
+  // a scope zoomed in on a long ring. gather() stages x as f32, so what the origin
+  // decides is the span that f32 has to resolve: the whole retained window (which
+  // is what `x0()`, the old implicit origin, names) or the part of it on screen. A
+  // readout quotes `x_at()` in exact f64, so the difference between the two is the
+  // distance between where a sample is *drawn* and the x reported for it.
+  constexpr u64 kN = 20001;
+  std::vector<f32> y(static_cast<plot::usize>(kN));
+  for (u64 i = 0; i < kN; ++i) y[static_cast<plot::usize>(i)] = f32(i % 71);
+  const plot::data::ArraySeries s(std::move(y), /*x0=*/0.0, /*dx=*/1e-3);
+  PLOT_CHECK_NEAR(s.x_bounds().max, 20.0, 1e-9);
+
+  const f64 centre = s.x_at(kN - 2u);                      // 19.999 s, near the far end
+  const plot::Range view{centre - 5e-6, centre + 5e-6};    // 10 us across
+  const f64 px_per_x = 700.0 / (view.max - view.min);      // a typical axis width
+
+  const auto worst_error_px = [&](f64 origin) {
+    std::vector<f32> out;
+    s.gather(0, kN - 3u, kN, origin, out);
+    PLOT_CHECK(out.size() == 6u);
+    f64 worst = 0.0;
+    for (u64 k = 0; k < 3u; ++k) {
+      // Exactly the renderer's reconstruction: the origin added back in f64.
+      const f64 drawn = origin + f64(out[static_cast<plot::usize>(2u * k)]);
+      worst = std::max(worst, std::abs(drawn - s.x_at(kN - 3u + k)) * px_per_x);
+    }
+    return worst;
+  };
+
+  // The visible range's minimum: the f32 resolves 2^-24 of what is on screen, so
+  // the error is a fixed fraction of a pixel at every zoom.
+  PLOT_CHECK(worst_error_px(view.min) < 0.05);
+  // The start of the retained window -- what every caller used to get -- resolves
+  // 2^-24 of 20 s instead, which at this zoom is most of the axis.
+  PLOT_CHECK(worst_error_px(s.x0()) > 10.0);
+}
+
 // --- Incremental append: ArraySeries::push() ----------------------------------

 PLOT_TEST(array_series_push_matches_commit) {
@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: 2026 Martino Ferrari

 #include "harness.hpp"
+#include <plot/plot.hpp>
 #include <plot/plot/ticks.hpp>
 #include <cmath>
 #include <cstdlib>
@@ -158,6 +159,52 @@ PLOT_TEST(epoch_window_yields_labelled_majors) {
  PLOT_CHECK(deep_majors >= 9);
 }

+/// The tick that *means* zero reads `0`. The walk starts at `ceil(lo/stride)*stride`,
+/// inexact for every stride that is not a power of two, so a range straddling the
+/// origin used to reach a few e-16 there and label it from the far end of the SI
+/// table: `-1 -500m -139a 500m 1`. The tolerance is relative to the stride, which is
+/// also the smallest magnitude a non-zero tick can have, so a range whose ticks are
+/// *legitimately* that small keeps them.
+PLOT_TEST(the_tick_at_the_origin_reads_zero) {
+  std::vector<plot::Tick> t;
+  const float widths[] = {80.0f, 40.0f, 10.0f};
+  for (const float min_px : widths) {
+    for (const bool minors : {false, true}) {
+      plot::generate_ticks({-1.0, 1.0}, 400.0f, min_px, t, minors);
+      plot::usize zeros = 0;
+      for (const plot::Tick& tick : t) {
+        if (!tick.major) continue;
+        PLOT_CHECK(!tick.label.empty());
+        // Nothing between -500m and 500m but the origin itself, so no major may
+        // carry a prefix from below `m`.
+        PLOT_CHECK(tick.label.find('a') == std::string::npos);
+        PLOT_CHECK(tick.label.find('f') == std::string::npos);
+        if (tick.label == "0") {
+          ++zeros;
+          PLOT_CHECK(tick.value == 0.0);  // exact, so a Time axis relabels it as 0 too
+        }
+      }
+      PLOT_CHECK(zeros == 1u);
+    }
+  }
+
+  // A range whose ticks really are atto-scale is untouched: only the origin folds.
+  plot::generate_ticks({-2e-16, 2e-16}, 400.0f, 80.0f, t, /*include_minors=*/true);
+  plot::usize tiny = 0;
+  plot::usize tiny_zeros = 0;
+  for (const plot::Tick& tick : t) {
+    if (!tick.major) continue;
+    if (tick.value == 0.0) {
+      ++tiny_zeros;
+    } else {
+      ++tiny;
+      PLOT_CHECK(tick.label.find('a') != std::string::npos);
+    }
+  }
+  PLOT_CHECK(tiny_zeros == 1u);
+  PLOT_CHECK(tiny >= 2u);
+}
+
 PLOT_TEST(si_labels_are_utf8_and_never_overrun) {
  char b[32];
  plot::format_si(0.0000015, b, sizeof b);
@@ -189,6 +236,11 @@ PLOT_TEST(si_labels_are_utf8_and_never_overrun) {
 PLOT_TEST(format_time_shapes) {
  char b[32];
  plot::format_time(0.5, b, sizeof b);      PLOT_CHECK(std::string(b) == "500ms");
+  plot::format_time(0.005, b, sizeof b);    PLOT_CHECK(std::string(b) == "5ms");
+  plot::format_time(0.0005, b, sizeof b);   PLOT_CHECK(std::string(b) == "500\u00b5s");
+  plot::format_time(5.0e-6, b, sizeof b);   PLOT_CHECK(std::string(b) == "5\u00b5s");
+  plot::format_time(5.0e-9, b, sizeof b);   PLOT_CHECK(std::string(b) == "5ns");
+  plot::format_time(5.0e-12, b, sizeof b);  PLOT_CHECK(std::string(b) == "5ps");
  plot::format_time(1.5, b, sizeof b);      PLOT_CHECK(std::string(b) == "1.5s");
  plot::format_time(90.0, b, sizeof b);     PLOT_CHECK(std::string(b) == "1:30");
  plot::format_time(3661.0, b, sizeof b);   PLOT_CHECK(std::string(b) == "1:01:01");
@@ -211,6 +263,18 @@ PLOT_TEST(format_time_never_lets_a_field_reach_its_radix) {
  plot::format_time(86399.5, b, sizeof b);  PLOT_CHECK(std::string(b) == "1d");
  plot::format_time(86400.0, b, sizeof b);  PLOT_CHECK(std::string(b) == "1d");

+  // A mantissa may not reach its own radix either: three significant figures of a value a
+  // hair under a rung's top round up to 1000, and `%.3g` writes that `1e+03`. A one-second
+  // tick computed as 0.9999999 s read `1e+03ms` on a live axis, which is where this was seen.
+  plot::format_time(0.9999999, b, sizeof b);  PLOT_CHECK(std::string(b) == "1s");
+  plot::format_time(0.9995, b, sizeof b);     PLOT_CHECK(std::string(b) == "1s");
+  plot::format_time(0.9994, b, sizeof b);     PLOT_CHECK(std::string(b) == "999ms");
+  plot::format_time(0.9999999e-3, b, sizeof b); PLOT_CHECK(std::string(b) == "1ms");
+  plot::format_time(0.9994e-3, b, sizeof b);  PLOT_CHECK(std::string(b) == "999\u00b5s");
+  plot::format_time(0.9999999e-6, b, sizeof b); PLOT_CHECK(std::string(b) == "1\u00b5s");
+  plot::format_time(0.9999999e-9, b, sizeof b); PLOT_CHECK(std::string(b) == "1ns");
+  plot::format_time(-0.9999999, b, sizeof b); PLOT_CHECK(std::string(b) == "-1s");
+
  // Sweep the boundary neighbourhoods and check every emitted field.
  const double values[] = {0.4, 0.9995, 1.0, 59.4, 59.4999, 59.5, 59.9, 60.0, 90.0, 119.5, 3599.4,
                           3599.5, 3599.9, 86399.4, 86399.5, 86399.9, 86400.0, 172800.0, -119.5,
@@ -222,3 +286,79 @@ PLOT_TEST(format_time_never_lets_a_field_reach_its_radix) {
    check_no_field_reaches_its_radix(label);
  }
 }
+
+// An axis origin shifts what the labels *say* and which grid the ticks sit on: a window
+// zoomed into 12.345 s must read `0, 0.5ms, 1ms` against its own left edge, because three
+// significant digits cannot tell 12.345671 s from 12.345672 s. A host prints the origin once
+// beside the axis and the user adds.
+PLOT_TEST(ticks_are_written_relative_to_an_axis_origin) {
+  // The same window twice: absolute, and relative to its own start.
+  const plot::Range window{12.345, 12.346};
+  std::vector<plot::Tick> absolute;
+  plot::generate_ticks(window, 400.0f, 80.0f, absolute, /*include_minors=*/false, 0.0);
+  PLOT_CHECK(!absolute.empty());
+  PLOT_CHECK(absolute.front().value >= window.min);
+
+  std::vector<plot::Tick> relative;
+  plot::generate_ticks(window, 400.0f, 80.0f, relative, /*include_minors=*/false, window.min);
+  PLOT_CHECK(!relative.empty());
+  // The walk starts on the origin's grid: the first major is the origin itself, and every
+  // major is an exact multiple of the step away from it.
+  PLOT_CHECK_NEAR(relative.front().value, window.min, 1e-12);
+  PLOT_CHECK_NEAR(relative[1].value - relative[0].value,
+                  (absolute[1].value - absolute[0].value), 1e-12);
+  for (const plot::Tick& t : relative) {
+    PLOT_CHECK(t.value >= window.min - 1e-12);
+    PLOT_CHECK(t.value <= window.max + 1e-12);
+  }
+
+  // And through an axis: the *labels* are the relative values, the positions the absolute
+  // ones. That is the whole contract -- `format_value()` is where the origin is applied.
+  plot::Plot p;
+  p.set_viewport({0, 0, 800, 400});
+  const u32 ax = p.add_x_axis({"time", window, false, plot::AxisPlace::Bottom, false,
+                               plot::TickFormat::Time});
+  p.x_axis(ax);
+  PLOT_CHECK_NEAR(p.x_axis_origin(ax), 0.0, 1e-12);
+  p.set_x_axis_origin(ax, window.min);
+  PLOT_CHECK_NEAR(p.x_axis_origin(ax), window.min, 1e-12);
+  char buf[64];
+  p.x_axis(ax).format_value(window.min, buf, sizeof buf);
+  PLOT_CHECK(std::string(buf) == "0");            // the window's start reads zero
+  p.x_axis(ax).format_value(window.min + 0.0005, buf, sizeof buf);
+  PLOT_CHECK(std::string(buf) == "500\u00b5s");    // half a millisecond reads in microseconds
+  // An id that names no axis is ignored; the axis that exists is untouched by it.
+  p.set_x_axis_origin(7u, 1234.0);
+  PLOT_CHECK_NEAR(p.x_axis_origin(ax), window.min, 1e-12);
+}
+
+// The moving-window case, which is why the mode exists: the origin is re-taken from the range
+// at refresh, so the tick on the left edge reads exactly zero however far the window has
+// scrolled since the host last looked. A host cannot predict the edge (the follow places it
+// from the newest sample), and a value it wrote a frame earlier is a frame of scroll stale --
+// at 1 MS/s that is more than a millisecond-scale window shows.
+PLOT_TEST(a_range_origin_puts_the_zero_tick_on_the_left_edge) {
+  plot::Plot p;
+  p.set_viewport({0, 0, 800, 400});
+  const plot::Range window{12.345, 12.347};
+  const u32 ax = p.add_x_axis({"time", window, false, plot::AxisPlace::Bottom, false,
+                               plot::TickFormat::Time});
+  p.set_x_axis_origin_from_range(ax, true);
+
+  // `layout()` is the library's own path to the ticks (it ends in `refresh_ticks()`), so this
+  // is the order a frame really runs in.
+  p.layout();
+  PLOT_CHECK(!p.x_axis(ax).ticks.empty());
+  const plot::Tick& first = p.x_axis(ax).ticks.front();
+  PLOT_CHECK(first.major);
+  PLOT_CHECK_NEAR(f64(first.value), window.min, 1e-12);   // exactly the left edge ...
+  PLOT_CHECK(first.label == "0");                          // ... and it reads zero
+
+  // The window slides: the origin follows it, so the zero tick is on the *new* edge.
+  const plot::Range moved{12.6, 12.602};
+  p.set_x_range(ax, moved);
+  p.layout();
+  PLOT_CHECK_NEAR(f64(p.x_axis(ax).ticks.front().value), moved.min, 1e-12);
+  PLOT_CHECK(p.x_axis(ax).ticks.front().label == "0");
+  PLOT_CHECK_NEAR(p.x_axis_origin(ax), moved.min, 1e-12);  // and the host reads it back
+}
@@ -52,7 +52,8 @@ PLOT_TEST(xy_series_reports_its_own_grid) {
  PLOT_CHECK_NEAR(s.y_bounds().max, 48.0, 1e-6);

  // Epoch-style offset: the same shape shifted by 1.7e9 keeps exact bounds, and
-  // gather() emits x relative to x0() -- small numbers, not quantised epochs.
+  // gather() emits x relative to the origin the caller names -- x0() here, so
+  // small numbers, not quantised epochs.
  std::vector<f64> epoch = spread_x(500);
  const std::vector<f64> es = epoch;   // un-moved copy for the expectations
  for (auto& v : epoch) v += 1.7e9;
@@ -60,7 +61,7 @@ PLOT_TEST(xy_series_reports_its_own_grid) {
  PLOT_CHECK_NEAR(e.x_bounds().min, 1.7e9, 1e-3);
  PLOT_CHECK_NEAR(e.x_bounds().max, 1.7e9 + (xs.back() - xs.front()), 1e-3);
  std::vector<f32> out;
-  e.gather(0, 0, 500, out);
+  e.gather(0, 0, 500, e.x0(), out);
  PLOT_CHECK(out.size() == 1000);
  // x is relative to x0(): x_at(i) - x0(), the array's own offsets -- small
  // values even though the absolute epoch is 1.7e9. The expectations come from
@@ -72,9 +73,9 @@ PLOT_TEST(xy_series_reports_its_own_grid) {
 }

 PLOT_TEST(xy_series_neighbour_lookups_crosshair_style) {
-  // The crosshair asks neighbours() at an arbitrary x and interpolates between
-  // the two samples it gets back. On a non-uniform grid that needs real
-  // searches: a uniform-grid formula would land megabytes off here.
+  // The crosshair asks neighbours() at an arbitrary x and reports whichever of
+  // the two samples it gets back is nearer. On a non-uniform grid that needs
+  // real searches: a uniform-grid formula would land megabytes off here.
  auto x = spread_x(1000);
  const std::vector<f64> xs = x;
  plot::data::XYSeries s(std::move(x), saw_y(1000));
@@ -186,7 +187,7 @@ PLOT_TEST(xy_series_gather_envelope_matches_exact_reduces) {
  const u64 span = u64{kBucket} << level;
  const u64 b = 500 + 33, e = 3500 - 57;   // unaligned on the bucket grid
  std::vector<f32> out;
-  s.gather(level, b, e, out, plot::data::GatherMode::Envelope);
+  s.gather(level, b, e, s.x0(), out, plot::data::GatherMode::Envelope);
  PLOT_CHECK(out.size() >= 8u);
  // Emitted x stays inside [x_at(begin), x_at(end)) and the geometry reaches
  // both the range's extremes (the lead/trail raw spans carry them).