feat(render): a reduced column can be graded by dwell, not drawn as one flat band

A pixel column reduced from a dense envelope is honest about where the signal
went and silent about how long it was there: its min and max are identical
whether its samples fill the span or pile at its two ends, so a ramp and a pulse
are one band. Style::intensity_grading grades it instead -- bright where the
signal sits, faint where it only passes through -- by asking the gather for a
level finer than the pixel grid and reading the distribution from those
sub-buckets. Off by default: a change of look, not a correction of one.

The measure is dwell per row, each segment depositing one unit spread over the
rows it spans; counting +1 per row instead grades a sine's fast middle as
brightly as its rails, which is the pattern inverted. The accumulator is one
column wide (a full w*h density image is 33 MB at 4K) with each span written as
two delta writes, and normalisation is against the column's own peak -- a
frame-wide scale fades the trace out exactly where it moves fastest. Alpha is
quantised into tiers, one LineBatch and one draw call each, because the line
pipeline's colour is a uniform and a per-segment alpha is inexpressible.

The finer ask is floored at level 1 whenever the flat path would have used the
pyramid: level_for() answers 0 -- raw samples -- as soon as a sub-column falls
under one bucket, so an unfloored ask turns a moderately dense frame into an
O(visible) gather (measured at 172 samples a pixel: raw=1154 lod=0 and 6.4 ms a
frame against raw=710 lod=453 and 2.3 ms). Grading is a way of drawing a
reduction and may not undo it.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

README.md

@@ -29,10 +29,26 @@ 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);
+- a trace whose gathered window is denser than the axis is reduced **onto the pixel grid** --
+  one snapped vertical segment per integer column, lit from that column's own extremes --
+  because an LOD envelope staged as a polyline puts three or four near-vertical hairlines per
+  column at as many sub-pixel phases, and the beat between the bucket pitch and the pixel pitch
+  is a crawling moiré; one segment per column leaves one phase, so there is nothing to beat
+  (`FrameStats::column_traces`, and `docs/data-and-performance.md` for the four rules it keeps);
+- and such a column can be drawn **graded by dwell** instead of as one flat band
+  (`Style::intensity_grading`, off by default, `FrameStats::graded_traces`): bright where the
+  signal sits, faint where it only passes through, the way a digital-phosphor scope reads. It is
+  what puts back the information the reduction throws away — a column's min and max are the same
+  whether its samples fill the span or pile at its two ends — so the gather is asked at a level
+  finer than the pixel grid and the distribution read from those sub-buckets;
 - 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`,
@@ -43,7 +59,9 @@ run touched a GPU, so read it as an upper bound and a record of the software pat
 - 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

docs/data-and-performance.md

@@ -166,10 +166,120 @@ 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
+## Dense traces are reduced onto the pixel grid
 
-The library deliberately holds two conventions next to each other, and they do **not**
-agree:
+A gathered window denser than the axis is **not** staged as a polyline. For each integer
+column of `layout.axes`, `Renderer::draw_traces` emits one exactly vertical segment from the
+lowest to the highest screen y any gathered point put in that column, flushed in framebuffer
+pixels with `u_snap` on. `FrameStats::column_traces` counts the traces that took this path.
+
+It exists because a polyline over such a window **moirés**, and three things compound to make
+it. `MinMaxPyramid::level_for()` picks the level whose buckets hold about
+`samples_per_pixel` samples, so a bucket spans **one to two pixel columns**;
+`GatherMode::Envelope` emits two points per bucket, so each bucket contributes a near-vertical
+min→max hairline *and* a near-vertical connector to the next — about 3.6 near-vertical
+hairlines per column; and each of those lands at a **fractional** x, so with ordinary
+src-alpha compositing a column's brightness is a non-linear function of the sub-pixel phases
+overlapping it. The phase pattern repeats at the beat between the bucket pitch and the pixel
+pitch, which is a visible banding, and panning sweeps the beat so it crawls. Reducing to one
+segment per column leaves the trace **one** sub-pixel phase, so there is nothing left to beat,
+and the snap then puts that one phase on the grid.
+
+Four properties of the reduction are load-bearing:
+
+- **It is gated on the gathered *density*, not on the level.** It runs when the window is
+  `GatherMode::Envelope` and carries at least two gathered points per column of the axes —
+  the raw path at 1.5–64 samples per pixel has the same beat and the same cure. The density
+  term is also what keeps it away from a *sparse* window, whose trace is drawn by the two
+  segments that enter and leave the frame (`a_sparse_window_between_samples_still_inks_both_margins`);
+  `Nearest` and `Mean` are excluded because they are one-point-per-bucket modes a band defeats.
+- **A hole stays a hole.** A column no gathered point landed in emits nothing. Bridging it
+  would draw a vertical line over x the series says nothing about.
+- **Disjoint columns are joined.** Two neighbouring columns' extremes need not overlap — a
+  fast edge rises through a whole column — and two disjoint vertical segments read as a broken
+  trace, which is what the polyline's connector prevented. The later column is extended to
+  meet the earlier one's nearest bound, so the join is made inside the column that moved.
+- **A span shorter than the stroke is drawn *as* the stroke.** The line fragment shader ramps
+  on the distance to the segment's axis and does not cap its ends, so a vertical segment
+  shorter than its own width rasterises a sliver of itself, and a flat trace's column, where
+  the two bounds are equal, nothing at all.
+
+This is the **one carve-out** in `u_snap`'s rule that chrome may be snapped and data may not
+(see `LineProgram::set_snap()`): a column *is* a pixel column and its x is already a screen
+coordinate, so there is no data position to move it off, and the y bounds the segment reports
+are untouched by the snap.
+
+`a_dense_trace_is_drawn_as_whole_pixel_columns` is the guard, and what it measures is the
+**number of distinct coverage levels** in the ink: 4 with the reduction against 126 with the
+polyline, over one sine period across 60 000 samples. A count of *partially covered pixels* is
+**not** the reading and was tried first — a 1.5 px stroke with a 1 px anti-aliasing fringe
+always spills into its neighbour column, so the two renderings measure 577 and 652, which
+separates nothing. The frame's whole geometry collapses with it: 627 segments against 60 054.
+
+## A reduced column can be graded by dwell
+
+`Style::intensity_grading` draws each of those columns **graded** rather than as one flat band:
+bright where the signal sits, faint where it only passes through, the way a digital-phosphor
+scope reads. It is off by default — a change of look, not a correction of one — and
+`FrameStats::graded_traces` counts the traces that took it, a subset of `column_traces`, since
+grading is a way of drawing the reduction and not a third path.
+
+What it puts back is the information the reduction throws away: a column's min and max are the
+**same** whether its samples fill the span evenly or pile at its two ends, so a ramp and a pulse
+are one band. The distribution cannot be recovered from the band, which is why the gather is
+asked at a level **finer than the pixel grid** (`intensity_sub_columns` sub-buckets per column)
+and the dwell read from those sub-buckets.
+
+Five things carry it, and each was arrived at by being wrong first:
+
+- **The measure is dwell per row, each segment depositing one unit spread over the rows it
+  spans** (`1 / height`). Counting +1 per row instead grades a sine's fast middle as brightly as
+  its rails, which is the pattern inverted — the middle is where the signal spends the *least*
+  time.
+- **The accumulator is one column wide.** Gathered x is monotonic, so points arrive column by
+  column: accumulate, read, clear. A full `axes.w × axes.h` density image is 33 MB at 4K; one
+  column of `axes.h` floats is L1-resident. A span is written as a `+1/height` delta at its first
+  row and the negation one past its last, so it costs two writes whatever its height, and the
+  running sum over the column is the per-row dwell.
+- **Normalisation is per column, against the column's own peak.** A frame-wide scale needs the
+  whole image to exist before anything can be drawn, *and* reads worse: a column the signal flew
+  through uniformly comes out faint at every row, so the trace fades out exactly where it moves
+  fastest. The cost of the local scale is one extra non-clearing walk of the accumulator to find
+  the peak.
+- **Alpha is quantised into `intensity_steps` tiers, one `LineBatch` and one draw call each.**
+  The line pipeline's colour is a **uniform**, not per-instance (`LineInstance` is four floats of
+  geometry; only `TextInstance` carries `a_colour`), so a per-segment alpha is inexpressible and
+  the tiers are what make the gradient drawable at all. `intensity_floor` keeps the faintest tier
+  visible — a fast riser is one sub-bucket deep everywhere and must not be dimmed out of
+  existence — and `intensity_gamma` lifts the faint end. A connector between two disjoint columns
+  is emitted at the **faintest** tier: it is inferred geometry, not a place the signal was
+  measured to dwell.
+- **Grading may not undo the reduction.** `level_for()` answers 0 — raw samples — as soon as the
+  asked-for fraction of a column falls under one bucket (`kBucket` is 64), so the finer ask is
+  **floored at level 1** whenever the flat path would have used the pyramid. Without the floor
+  every moderately dense frame became an O(visible) gather: measured in udpscope at 1.3 MS/s over
+  a 2 s window, 172 samples a pixel, the flat path sat on the pyramid and grading dropped the
+  whole figure to raw (`raw=1154 lod=0` against `raw=710 lod=453`) and cost 2.3 → 6.4 ms of draw
+  mean. The floor degrades the *look* instead — fewer sub-columns than asked for, down to what the
+  coarsest buckets give, which at 64 samples a bucket is still two or three per column. That is
+  also why raising `intensity_sub_columns` past about 8 buys nothing: the bucket size is the
+  limit, not the number.
+
+`a_dense_trace_can_be_graded_by_dwell` is the guard, and it draws the same frame both ways. It
+profiles the mean peak coverage over the band's two outer fifths against its middle fifth: the
+flat band is flat (**191 and 191**, one ink) and the graded one is **191 against 131**, a middle
+at 0.69 of the edge. That ratio is a *tier* ratio and not the dwell ratio — the default gamma
+0.45 and floor 0.3 compress it on purpose. The geometry stays bounded by the axis and not by its
+area: **8303 segments over a 572 px axis**, 14.5 runs a column, against the flat path's 627 at
+one end and `572 × 156` rows at the other. A fourth frame over a window wide enough that the
+flat path is on the pyramid is what exercises the floor (`raw=0 lod=1 … seg=634
+visible=200001`); the test's first window sits at 105 samples a pixel, where both paths are raw
+and the floor is never reached.
+
+## One sample or a statistic of many
+
+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 +289,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

docs/interaction.md

@@ -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)
 

include/plot/data/array_series.hpp

@@ -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:

include/plot/data/series.hpp

@@ -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

include/plot/data/stream_series.hpp

@@ -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.

include/plot/data/xy_series.hpp

@@ -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.

include/plot/plot/crosshair.hpp

@@ -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`.

include/plot/plot/figure.hpp

@@ -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;
 };
 

include/plot/plot/plot.hpp

@@ -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.
@@ -508,6 +513,18 @@ class Plot {
   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
   /// series, a longer one, or a sliding window whose sample count stayed the same
@@ -628,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_; }
 
@@ -688,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
@@ -709,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
@@ -816,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.
@@ -826,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_{};
 

include/plot/render/renderer.hpp

@@ -29,6 +29,15 @@ namespace plot {
 struct FrameStats {
   u32 raw_traces = 0;        ///< traces drawn from raw samples (level 0)
   u32 lod_traces = 0;        ///< traces drawn from a min/max pyramid level
+  /// Traces whose geometry was reduced onto the pixel grid: one vertical segment
+  /// per column, lit from that column's own extremes. Counts a trace from either
+  /// path above -- the reduction is about the *density* of the gathered points,
+  /// not about which level produced them.
+  u32 column_traces = 0;
+  /// Traces whose columns were graded by dwell rather than drawn as one flat band
+  /// (`Style::intensity_grading`). A subset of `column_traces`: grading is a way of
+  /// drawing the reduction, not a third path.
+  u32 graded_traces = 0;
   u64 visible_samples = 0;   ///< samples the gathered windows covered, summed
   u32 staged_segments = 0;   ///< line segments staged, all colour groups
   u32 staged_markers = 0;    ///< marker shapes staged over the traces
@@ -404,6 +413,13 @@ class Renderer {
   /// 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;
+  /// The same, for a batch other than the renderer's own `lines_`. The graded trace
+  /// pass stages one batch per alpha step, and a step has to be a draw call of its
+  /// own because the line pipeline takes its colour from a uniform -- so it needs to
+  /// flush a batch it chose rather than the member one. Every other caller flushes
+  /// `lines_` and uses the overload above.
+  void flush_lines(render::LineBatch& batch, 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.
@@ -445,11 +461,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.
@@ -499,6 +516,29 @@ class Renderer {
   /// The data helpers take it too; they read the axes rect and the transforms it
   /// pins.
   void draw_traces(const Plot& plot, const PlotLayout& layout);
+  /// One gathered window reduced onto the pixel grid and staged in framebuffer
+  /// pixels: for each integer column of `layout.axes`, one exactly vertical
+  /// segment from the lowest to the highest screen y any gathered point put in
+  /// it. Returns how many columns were staged (0 stages nothing); the caller
+  /// flushes with `pixel_mapping()` and `snap = true`.
+  ///
+  /// `gather_` is the input, read with the same origin `draw_traces` asked the
+  /// series for. See `draw_traces` for when this path is taken and why.
+  u32 stage_trace_columns(const Plot& plot, const PlotLayout& layout, const Trace& trace,
+                          f64 x_origin, u32 points);
+  /// The same reduction, graded by **dwell**: a column is drawn as a stack of runs,
+  /// each at the alpha step its own share of the column's samples earns, so a flat
+  /// top is bright and the edge leading to it is faint (`Style::intensity_grading`).
+  ///
+  /// Stages into `steps_`, one `LineBatch` per alpha step, which the caller flushes
+  /// in turn -- the line pipeline's colour is a uniform, so a step is a draw call.
+  /// Returns the segments staged across all steps (0 stages nothing).
+  ///
+  /// `gather_` is the input and must have been asked for at the *finer* level
+  /// `Style::intensity_sub_columns` implies; a column's dwell is not recoverable
+  /// from its own min and max (see `Style::intensity_grading`).
+  u32 stage_trace_density(const Plot& plot, const PlotLayout& layout, const Trace& trace,
+                          f64 x_origin, u32 points);
   /// The cursors, both orientations: one stroke per cursor, placed at the coordinate its own
   /// orientation owns (`Plot::cursor_screen_coordinate()`) and spanning the other axis' whole
   /// range, in its own colour -- or in the accent at handle width while it is hovered or
@@ -534,6 +574,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
@@ -604,7 +650,25 @@ class Renderer {
   render::TextBatch glyphs_under_;
   render::TextBatch glyphs_over_;
   std::vector<f32> gather_;   ///< scratch for one gathered window, re-used
-  std::vector<f32> staged_;   ///< scratch for one staged window, re-used
+  /// One (lowest y, highest y) pair per pixel column of the axes, re-used:
+  /// `stage_trace_columns()`'s working set. Two floats per column, so an 8K-wide
+  /// axis is 64 kB -- bounded by the *screen*, where `gather_` is bounded by the
+  /// window.
+  std::vector<f32> columns_;
+  /// `stage_trace_density()`'s working set, and deliberately **one column wide**: the
+  /// gathered points arrive in x order, so a column can be accumulated, read and
+  /// cleared before the next one starts. A full-axes density image would be
+  /// `axes.w * axes.h` (33 MB at 4K); this is `axes.h` (a few kB) and stays in L1.
+  ///
+  /// Each sub-bucket's span is written as a +1 at its first row and a -1 one past
+  /// its last, so accumulating a span costs two writes whatever its height; the
+  /// running sum over the column is then how many sub-buckets cover each row, which
+  /// is the dwell.
+  std::vector<f32> column_rows_;
+  /// One batch per alpha step of the grading (`Style::intensity_steps`), re-used
+  /// across frames: the line pipeline takes its colour from a uniform, so segments
+  /// at different alphas cannot share a draw call and must be staged apart.
+  std::vector<render::LineBatch> steps_;
   mutable std::vector<u8> readback_;  ///< dump_frame_ppm's row buffer
 
   /// The host's `GL_COLOR_CLEAR_VALUE`, queried on the first `begin_frame()` (GL

include/plot/render/style.hpp

@@ -86,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 ----------------------------------------------------------
 
@@ -162,6 +177,82 @@ struct Style {
                                    ///< sides draw through the one instanced
                                    ///< anti-aliased quad path.
 
+  // --- intensity grading: counts and ratios, never sizes -------------------
+
+  /// Draw a dense trace's pixel columns **graded by how long the signal dwells at
+  /// each height**, the way a digital-phosphor scope does, instead of as one flat
+  /// band per column: bright where samples pile up (a flat top, a peak), faint
+  /// where they only pass through (an edge, a noise excursion).
+  ///
+  /// Off by default, because it is a change of *look* and not a correction: the
+  /// flat band is the honest answer to "what did this column reach", and a host
+  /// that wants that -- or that draws few enough samples never to take the column
+  /// path at all -- should not have its traces restyled by an upgrade. A scope-like
+  /// host turns it on.
+  ///
+  /// It is not derivable from the flat band. A column's min and max are the same
+  /// whether its samples fill the span or sit piled at its two ends, which is
+  /// exactly the difference between a ramp and a pulse -- so grading needs the
+  /// gather asked at a *finer* level than the pixel grid (`intensity_sub_columns`)
+  /// and reads the distribution from those sub-buckets.
+  ///
+  /// The measure is *dwell per row*, and the weighting is the whole of it: each
+  /// sub-column segment deposits **one unit spread over the rows it spans**, so a
+  /// tall crossing leaves a thin smear and a short one at a turning point leaves a
+  /// bright mark. Counting a row at +1 per segment that touches it instead -- the
+  /// obvious thing -- grades a sine's fast middle as brightly as its rails, which
+  /// is the pattern inverted.
+  bool intensity_grading = false;
+
+  /// Sub-buckets per pixel column the gather is asked for when grading: the level
+  /// is chosen for `samples_per_pixel / intensity_sub_columns`, so a column's
+  /// density is read from this many envelopes instead of from one.
+  ///
+  /// It buys resolution in *dwell*, linearly, for the same factor in gathered
+  /// points -- and the points stay bounded by the screen, which is the property
+  /// that matters (8 of them over a 1000 px axis is 16 000 points whatever the
+  /// window holds). Below about 4 a pulse's flat levels and its edge are too few
+  /// samples apart to separate.
+  ///
+  /// It is a *want*, not a promise: the renderer floors the level it asks for at the
+  /// pyramid's coarsest bucket level, so a window too sparse to hold this many buckets
+  /// a column is graded from however many it does hold. Without that floor `level_for`
+  /// answers 0 -- raw samples -- the moment a sub-column falls under one bucket, which
+  /// turns a frame the flat path draws off the pyramid into an O(visible) gather. So
+  /// raising this past about 8 costs resolution nothing and buys it nothing either: the
+  /// bucket size is the limit, not this number.
+  u32 intensity_sub_columns = 8;
+
+  /// Quantisation of the grading, in alpha steps. Each step is one draw call (the
+  /// line pipeline's colour is a uniform, so a per-segment alpha would mean a
+  /// per-instance one), and the segments are bounded by the columns, so the cost
+  /// of a step is a draw call over a few hundred instances.
+  ///
+  /// Four is enough to read a waveform's structure and few enough that a step is a
+  /// visible tier rather than a gradient -- the point is to separate "dwelt here"
+  /// from "passed through", not to measure.
+  u32 intensity_steps = 4;
+
+  /// Alpha the faintest graded step is drawn at, as a fraction of the trace's own.
+  ///
+  /// Not 0: a column the signal merely passed through is still a column the signal
+  /// *reached*, and a riser dimmed out of existence is a square wave drawn as two
+  /// disconnected lines. This is the floor that keeps the trace continuous.
+  f32 intensity_floor = 0.3f;
+
+  /// Exponent the normalised dwell is raised to before it is quantised. Below 1 it
+  /// lifts the faint end, which is what makes a fast edge visible beside a flat top
+  /// whose dwell is three orders of magnitude greater.
+  ///
+  /// The dwell is normalised **against the column's own peak**, not against a scale
+  /// for the whole frame, so the steps spend their range on the structure *inside*
+  /// each column. One scale for the frame needs the whole `w * h` density image
+  /// (33 MB at 4K, which is why the accumulator is one column wide) and reads
+  /// worse: a column the signal flew straight through holds little dwell at any
+  /// height, so it would grade uniformly faint -- a trace that fades out exactly
+  /// where it moves fastest.
+  f32 intensity_gamma = 0.45f;
+
   /// `logical` in device pixels: the single conversion point for every logical
   /// metric above, so the arithmetic appears once per consumer instead of a `*
   /// ui_scale` scattered over the renderer and the layout.

src/data/array_series.cpp

@@ -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 {

src/data/series.cpp

@@ -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

src/data/stream_series.cpp

@@ -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 {

src/data/xy_series.cpp

@@ -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);

src/input/controller.cpp

@@ -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();

src/plot/figure.cpp

@@ -451,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

src/plot/plot.cpp

@@ -342,6 +342,8 @@ void Plot::set_y_axis_origin_from_range(u32 axis, bool on) {
   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;
 }
@@ -1037,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 =
@@ -1082,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_;
@@ -1352,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
@@ -1371,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;
@@ -1387,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;
@@ -1410,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));
@@ -1439,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;
@@ -1450,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;
 }
 
@@ -1524,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
@@ -1543,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);

src/plot/ticks.cpp

@@ -98,7 +98,10 @@ 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) {
+  // `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
@@ -119,8 +122,12 @@ void format_time(f64 seconds, char* buf, usize n) {
         {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) continue;
+      if (t < u.scale * 0.9995) continue;
       std::snprintf(buf, n, "%s%.3g%s", sign, t / u.scale, u.unit);
       return;
     }

src/render/primitives.cpp

@@ -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

src/render/renderer.cpp

@@ -9,6 +9,7 @@
 #include <plot/render/detail/text_scale.hpp>
 
 #include <algorithm>
+#include <cstring>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
@@ -532,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.
@@ -614,9 +616,14 @@ void Renderer::upload_text_vertices(std::span<const f32> interleaved) noexcept {
 
 void Renderer::flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash,
                            bool snap) noexcept {
-  const u32 segments = lines_.segment_count();
+  flush_lines(lines_, map, color, width, dash, snap);
+}
+
+void Renderer::flush_lines(render::LineBatch& batch, const Mapping& map, Color color, f32 width,
+                           Vec2 dash, bool snap) noexcept {
+  const u32 segments = batch.segment_count();
   if (segments != 0 && ready_) {
-    upload_vertices(lines_.data());
+    upload_vertices(batch.data());
     line_program_.bind();
     line_program_.set_scale(map.scale);
     line_program_.set_offset(map.offset);
@@ -641,7 +648,7 @@ void Renderer::flush_lines(const Mapping& map, Color color, f32 width, Vec2 dash
     stats_.staged_segments += segments;
     ++stats_.draw_calls;
   }
-  lines_.clear();  // keeps the capacity, so the next group re-uses the store
+  batch.clear();  // keeps the capacity, so the next group re-uses the store
 }
 
 void Renderer::flush_text(render::TextBatch& batch) noexcept {
@@ -734,24 +741,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);
   }
 }
@@ -978,6 +977,304 @@ void Renderer::draw_titles(const Plot& plot, const PlotLayout& layout) {
 
 // ------------------------------------------------------------------- data
 
+u32 Renderer::stage_trace_columns(const Plot& plot, const PlotLayout& layout, const Trace& trace,
+                                  f64 x_origin, u32 points) {
+  const Transform xt = plot.x_transform(trace.axis_x);
+  const Transform yt = plot.y_transform(trace.axis_y);
+  const f32 left = layout.axes.x;
+  // One column per whole pixel of the axes, plus the partial one at the right-hand
+  // edge: `axes.w` is fractional, and the samples that land in that last fraction
+  // are inside the frame.
+  const u32 count = static_cast<u32>(layout.axes.w) + 1u;
+  constexpr f32 kInf = std::numeric_limits<f32>::infinity();
+  columns_.resize(2u * static_cast<usize>(count));
+  for (u32 c = 0; c < count; ++c) {
+    columns_[2u * c] = kInf;         // the lowest screen y seen in this column
+    columns_[2u * c + 1u] = -kInf;   // and the highest; `lo <= hi` is "present"
+  }
+
+  for (u32 k = 0; k < points; ++k) {
+    const f64 x_abs = x_origin + static_cast<f64>(gather_[2u * k]);
+    const f64 sx = xt.to_screen_x(x_abs);
+    const f64 sy = yt.to_screen_y(static_cast<f64>(gather_[2u * k + 1u]));
+    // A NaN sample, and a non-positive one on a log axis, have no position: both
+    // arrive here as a non-finite screen coordinate.
+    if (!std::isfinite(sx) || !std::isfinite(sy)) continue;
+    const f64 column = std::floor(sx - static_cast<f64>(left));
+    // Clamped, not dropped. The gathered window carries one sample of slack on each
+    // side, and that sample's ink belongs to the edge column -- it is what the
+    // polyline drew there, under the same clip. Nothing further out can arrive: the
+    // window is the visible range's.
+    const u32 c = !(column > 0.0)                           ? 0u
+                  : column >= static_cast<f64>(count - 1u)   ? count - 1u
+                                                            : static_cast<u32>(column);
+    const f32 y = static_cast<f32>(sy);
+    if (y < columns_[2u * c]) columns_[2u * c] = y;
+    if (y > columns_[2u * c + 1u]) columns_[2u * c + 1u] = y;
+  }
+
+  const f32 width = style_.device(trace.width);
+  u32 staged = 0;
+  f32 prev_lo = 0.0f;
+  f32 prev_hi = 0.0f;
+  bool joined = false;   // the column before this one is present, so there is a join to make
+  for (u32 c = 0; c < count; ++c) {
+    f32 lo = columns_[2u * c];
+    f32 hi = columns_[2u * c + 1u];
+    if (!(lo <= hi)) {
+      // No sample landed here. A hole in the data stays a hole: bridging it would
+      // draw a vertical line over x the series says nothing about, where the
+      // polyline drew a diagonal across the gap at most one pixel wide.
+      joined = false;
+      continue;
+    }
+    // Connectivity. Two columns' extremes need not overlap -- a fast edge rises
+    // through a whole column -- and two disjoint vertical segments read as a broken
+    // trace, which is exactly what the polyline's connecting segment prevented. The
+    // later column is extended to meet the earlier one's nearest bound, so the join
+    // is made inside the column that moved and no ink appears left of it.
+    if (joined) {
+      if (hi < prev_lo) {
+        hi = prev_lo;
+      } else if (lo > prev_hi) {
+        lo = prev_hi;
+      }
+    }
+    prev_lo = lo;
+    prev_hi = hi;
+    joined = true;
+    // A span shorter than the stroke is drawn *as* the stroke: the fragment shader
+    // ramps on the distance to the segment's axis and does not cap its ends, so a
+    // vertical segment shorter than its own width rasterises a sliver of itself --
+    // and a column of a flat trace, where `lo == hi`, nothing at all.
+    if (hi - lo < width) {
+      const f32 mid = 0.5f * (lo + hi);
+      lo = mid - 0.5f * width;
+      hi = mid + 0.5f * width;
+    }
+    // The column's centre, in framebuffer pixels. Every segment therefore shares one
+    // sub-pixel phase, which is the whole point (see `draw_traces`), and the flush's
+    // snap puts that one phase on the grid.
+    const f32 x = left + static_cast<f32>(c) + 0.5f;
+    lines_.add_segment({x, lo}, {x, hi});
+    ++staged;
+  }
+  return staged;
+}
+
+u32 Renderer::stage_trace_density(const Plot& plot, const PlotLayout& layout, const Trace& trace,
+                                  f64 x_origin, u32 points) {
+  if (points < 2u) return 0u;
+  // At least two steps, or there is nothing to grade and the faintest step is also
+  // the brightest -- a one-step grading is the flat band drawn dimmer, which is not
+  // what any host asking for this wants.
+  const u32 steps = std::max(2u, style_.intensity_steps);
+  // Exactly `steps`, never merely at least: the flush loop reads `steps_.size()` as the
+  // step count and divides by it, so a batch left over from a larger setting would be
+  // flushed at the wrong alpha -- or, being uncleared, at all.
+  steps_.resize(steps);
+  for (u32 t = 0; t < steps; ++t) steps_[t].clear();
+
+  const Transform xt = plot.x_transform(trace.axis_x);
+  const Transform yt = plot.y_transform(trace.axis_y);
+  const f32 left = layout.axes.x;
+  const f32 top = layout.axes.y;
+  const u32 columns = static_cast<u32>(layout.axes.w) + 1u;
+  // One accumulator row per whole pixel of the axes, plus the partial one at the
+  // bottom edge, plus one past the end for a span's closing delta.
+  const u32 rows = static_cast<u32>(layout.axes.h) + 1u;
+  column_rows_.assign(static_cast<usize>(rows) + 1u, 0.0f);
+
+  const f32 width = style_.device(trace.width);
+  const f32 gamma = style_.intensity_gamma > 0.0f ? style_.intensity_gamma : 1.0f;
+  const f32 bottom = top + layout.axes.h;
+
+  u32 staged = 0;
+  u32 column = 0;        // the column being accumulated
+  bool open = false;     // it has at least one segment
+  u32 prev_column = 0;   // the last column that emitted anything, for the join below
+  f32 prev_lo = 0.0f;
+  f32 prev_hi = 0.0f;
+  bool joined = false;
+
+  // Reads one column's accumulator out as graded runs and clears it, so the next column
+  // starts empty. Two walks of it, which is nothing -- it is one column wide and in L1 --
+  // and the first is what makes the second's grading *relative to this column*:
+  //
+  // the brightest row of a column is always the top tier. That is deliberate and it is
+  // the difference between grading and dimming. The alternative, one scale for the whole
+  // frame, needs a pass over every column before any of them can be drawn (an
+  // `axes.w * axes.h` image, 33 MB at 4K) and makes a column the signal flew through
+  // *uniformly* faint -- a trace that fades out where it moves fastest, which is where a
+  // reader is most often looking. Per column, the dwell structure *inside* each one is
+  // what the tiers spend their range on: the rails of a sine are bright and its fast
+  // middle is faint, in every column.
+  //
+  // The runs are maximal stretches of equal tier, so this is O(rows) segments per column
+  // at worst and a handful in practice: a column of a clean waveform is a bright ridge
+  // and a faint tail.
+  const auto emit_column = [&]() {
+    const f32 x = left + static_cast<f32>(column) + 0.5f;
+    f32 peak = 0.0f;
+    {
+      f32 cover = 0.0f;
+      for (u32 r = 0; r < rows; ++r) {
+        cover += column_rows_[r];
+        if (cover > peak) peak = cover;
+      }
+    }
+    const f32 inv = peak > 0.0f ? 1.0f / peak : 0.0f;
+    // What counts as covered at all. The deposits are fractions, so this cannot be an
+    // integer test: it is a share of the column's own peak, small enough to keep a row a
+    // single thin segment grazed and large enough not to light a row on rounding alone.
+    const f32 lit_floor = 0.01f * peak;
+    f32 cover = 0.0f;
+    bool in_run = false;
+    u32 run_tier = 0;
+    u32 run_start = 0;
+    f32 band_lo = 0.0f;
+    f32 band_hi = 0.0f;
+    bool any = false;
+    // One past the last row too: it closes a run that reaches the bottom edge.
+    for (u32 r = 0; r <= rows; ++r) {
+      cover += column_rows_[r];
+      column_rows_[r] = 0.0f;
+      const bool lit = r < rows && cover > lit_floor;
+      u32 tier = 0;
+      if (lit) {
+        const f32 share = std::min(1.0f, cover * inv);
+        const u32 t = static_cast<u32>(std::pow(share, gamma) * static_cast<f32>(steps));
+        tier = std::min(steps - 1u, t);
+      }
+      if (in_run && (!lit || tier != run_tier)) {
+        f32 lo = top + static_cast<f32>(run_start);
+        f32 hi = top + static_cast<f32>(r);
+        // A run shorter than the stroke is drawn *as* the stroke, for the reason
+        // `stage_trace_columns()` gives: the fragment shader ramps on the distance to
+        // the segment's axis and does not cap its ends.
+        if (hi - lo < width) {
+          const f32 mid = 0.5f * (lo + hi);
+          lo = mid - 0.5f * width;
+          hi = mid + 0.5f * width;
+        }
+        steps_[run_tier].add_segment({x, lo}, {x, hi});
+        ++staged;
+        in_run = false;
+      }
+      if (lit && !in_run) {
+        run_start = r;
+        run_tier = tier;
+        in_run = true;
+      }
+      if (lit) {
+        if (!any) {
+          band_lo = top + static_cast<f32>(r);
+          any = true;
+        }
+        band_hi = top + static_cast<f32>(r) + 1.0f;
+      }
+    }
+    open = false;
+    if (!any) {
+      joined = false;   // nothing visible here: a hole, like an uncovered column
+      return;
+    }
+    // Connectivity, the same rule as the flat path: two columns' bands need not
+    // overlap -- a fast edge rises through a whole column -- and two disjoint
+    // verticals read as a broken trace. The gap is bridged by a segment of its own at
+    // the **faintest** tier rather than by extending a run, because a connector is
+    // inferred geometry and not a place the signal was measured to dwell: grading it
+    // bright would claim the opposite of what it is.
+    if (joined && column == prev_column + 1u) {
+      if (band_hi < prev_lo) {
+        steps_[0].add_segment({x, band_hi}, {x, prev_lo});
+        ++staged;
+      } else if (band_lo > prev_hi) {
+        steps_[0].add_segment({x, prev_hi}, {x, band_lo});
+        ++staged;
+      }
+    }
+    prev_lo = band_lo;
+    prev_hi = band_hi;
+    prev_column = column;
+    joined = true;
+  };
+
+  f64 px = 0.0;
+  f64 py = 0.0;
+  bool have_prev = false;
+  for (u32 k = 0; k < points; ++k) {
+    const f64 x_abs = x_origin + static_cast<f64>(gather_[2u * k]);
+    const f64 sx = xt.to_screen_x(x_abs);
+    const f64 sy = yt.to_screen_y(static_cast<f64>(gather_[2u * k + 1u]));
+    // A NaN sample, and a non-positive one on a log axis, have no position -- and it
+    // breaks the chain as well as skipping the point: a segment from the sample
+    // before it to the one after would cross x the series says nothing about.
+    if (!std::isfinite(sx) || !std::isfinite(sy)) {
+      have_prev = false;
+      continue;
+    }
+    if (have_prev) {
+      // The *segment*, not the point, is what carries dwell: it is a stretch of the
+      // waveform, and where it went slowly it covers few rows and where it went fast it
+      // covers many. This is where a height-based heuristic cannot reach -- a column's
+      // min and max cannot tell a ramp from a pulse, and a column's segments can (see
+      // `Style::intensity_grading`).
+      //
+      // It is charged to the column its earlier end falls in. The gather is asked at
+      // `intensity_sub_columns` buckets per column, so a segment is a fraction of a
+      // column wide and splitting one across a boundary would buy a fraction of one
+      // sub-bucket's dwell.
+      const f64 c = std::floor(px - static_cast<f64>(left));
+      // Clamped, not dropped, for the reason `stage_trace_columns()` gives: the
+      // gathered window carries one sample of slack on each side and that sample's
+      // ink belongs to the edge column.
+      const u32 ci = !(c > 0.0)                                 ? 0u
+                     : c >= static_cast<f64>(columns - 1u)      ? columns - 1u
+                                                               : static_cast<u32>(c);
+      if (open && ci != column) emit_column();   // x is increasing, so ci > column
+      if (!open) {
+        column = ci;
+        open = true;
+      }
+      const f64 lo = std::min(py, sy);
+      const f64 hi = std::max(py, sy);
+      // Wholly outside the axes is wholly clipped, and a clamp would move its ink to
+      // the edge and invent a ridge there. A segment that *crosses* the edge is
+      // clamped instead, which is the coverage the clip leaves -- so a column's shares
+      // are shares of what is visible in it, which is what is being graded.
+      if (hi >= static_cast<f64>(top) && lo <= static_cast<f64>(bottom)) {
+        const f64 ra = std::floor(lo - static_cast<f64>(top));
+        const f64 rb = std::floor(hi - static_cast<f64>(top));
+        const u32 r0 = !(ra > 0.0) ? 0u
+                       : ra >= static_cast<f64>(rows - 1u) ? rows - 1u
+                                                          : static_cast<u32>(ra);
+        const u32 r1 = !(rb > 0.0) ? 0u
+                       : rb >= static_cast<f64>(rows - 1u) ? rows - 1u
+                                                          : static_cast<u32>(rb);
+        // A segment deposits one unit of dwell, **spread over the rows it covers** --
+        // which is the whole measurement, and counting the rows instead was wrong in a
+        // way worth recording: a sub-bucket holds about as many samples as any other, so
+        // a segment crossing a hundred rows is those samples *passing through* each of
+        // them, while one covering two rows is the same samples *sitting* in them. Giving
+        // each crossed row a full unit makes a sine's fast middle as bright as its rails,
+        // which is the pattern grading exists to show.
+        //
+        // Two writes whatever the height: the running sum over the column is then the
+        // dwell at each row.
+        const f32 w = 1.0f / static_cast<f32>(r1 - r0 + 1u);
+        column_rows_[r0] += w;
+        column_rows_[r1 + 1u] -= w;
+      }
+    }
+    px = sx;
+    py = sy;
+    have_prev = true;
+  }
+  if (open) emit_column();
+  return staged;
+}
+
 void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
   // Both dimensions: a zero-width rect selects no level, and a zero-height one
   // would flatten every trace onto a single row -- a frame that looks like a
@@ -1019,12 +1316,38 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
     // This is the whole performance contract: the window, never the series.
     const u64 visible = last - first;
     const f64 samples_per_pixel = static_cast<f64>(visible) / static_cast<f64>(layout.axes.w);
-    const u32 level = samples_per_pixel >= static_cast<f64>(style_.dense_threshold_spp)
-                          ? series.pyramid().level_for(n, samples_per_pixel)
-                          : 0u;
+    // Grading reads a column's *distribution*, which one envelope per column cannot
+    // carry (`Style::intensity_grading`), so the gather is asked for the level a
+    // fraction of a column implies. The *gate* is still the pixel grid's density: a
+    // window sparse enough to be drawn as a polyline is drawn as one, graded or not.
+    const bool grade = style_.intensity_grading && trace.mode == data::GatherMode::Envelope &&
+                       style_.intensity_sub_columns > 1u && style_.intensity_steps > 1u;
+    const u32 flat_level = samples_per_pixel >= static_cast<f64>(style_.dense_threshold_spp)
+                               ? series.pyramid().level_for(n, samples_per_pixel)
+                               : 0u;
+    // The finer level, floored at the pyramid's coarsest bucket level. Grading asks for a
+    // fraction of a column and `level_for` answers 0 -- raw samples -- as soon as that
+    // fraction falls under one bucket, so an unfloored ask turns every moderately dense
+    // frame into an O(visible) gather: measured at 1.3 MS/s over a 2 s window, 172 samples
+    // a pixel, where the flat path sits on the pyramid and grading dropped the whole figure
+    // to raw (`raw=1154 lod=0` against `raw=710 lod=453`) and cost 2.3 -> 6.4 ms a frame.
+    // The floor degrades the *look* instead: fewer sub-columns than asked for, down to
+    // whatever the coarsest buckets give, which at 64 samples a bucket is still two or three
+    // per column. Grading is a way of drawing a reduction and may not undo it.
+    const u32 level =
+        grade && flat_level > 0u
+            ? std::max(1u, series.pyramid().level_for(
+                               n, samples_per_pixel /
+                                      static_cast<f64>(style_.intensity_sub_columns)))
+            : flat_level;
 
     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;
@@ -1039,11 +1362,11 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
       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 = series.x0() + static_cast<f64>(gather_[k]);
+        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 = xt.to_screen_x(x_abs);
-        const f32 sy = yt.to_screen_y(y_abs);
+        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;
@@ -1057,14 +1380,47 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
       ++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
@@ -1079,8 +1435,72 @@ 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);
-      flush_lines(map, trace.color, style_.device(trace.width), dash);
+      // A window denser than two gathered points per pixel column is drawn as *columns*
+      // rather than as a polyline: one exactly vertical, pixel-snapped segment per column,
+      // spanning what that column's own points reach.
+      //
+      // The polyline's geometry at this density is a stack of near-vertical hairlines at
+      // *fractional* x -- an envelope bucket spans (spp/2, spp] samples, so there are one to
+      // two buckets per column, each emitting its own min->max hairline plus a connector to
+      // the next, about three and a half per column. Each is composited with its own
+      // sub-pixel coverage, so a column's brightness is a non-linear function of those
+      // phases; the phases repeat at the beat between the bucket pitch and the pixel pitch,
+      // which is a **moire** across the trace, and panning sweeps the beat so the pattern
+      // crawls. It is strongest exactly where a scope is used hardest: a high sample rate, a
+      // high signal frequency, or a noisy signal, all of which make the ribbon thin enough
+      // for its per-column coverage to be visible as texture.
+      //
+      // Reducing to one segment per column removes the cause rather than the symptom: there
+      // is one phase on the whole trace (and the snap puts it on the grid), so there is
+      // nothing left to beat. It is also O(axes.w) geometry instead of O(buckets), and it
+      // loses nothing a reader could have seen -- a column cannot show more than the extremes
+      // of what it covers, which is what the band is.
+      //
+      // Two conditions, and each refuses a case this would damage.
+      // - `Envelope` only. `Nearest` and `Mean` are one-point-per-bucket modes chosen so the
+      //   trace reads as *samples* or as a smoothed line; a min/max band would answer a
+      //   different question from the one the host asked.
+      // - Two points per column. Below that the gather is sparser than the grid, and the
+      //   polyline's segments are the shape: `Series::gather()` also falls back to raw samples
+      //   when no complete bucket fits the range, and that window's trace is drawn by the two
+      //   segments that enter and leave the frame (see
+      //   `a_sparse_window_between_samples_still_inks_both_margins`). The real envelope path
+      //   emits two to four points per column by construction, so the test holds exactly when
+      //   it ran.
+      const bool columns = trace.mode == data::GatherMode::Envelope &&
+                           static_cast<f64>(points) >= 2.0 * static_cast<f64>(layout.axes.w);
+      // `snap = true` on geometry that is not chrome, which is the one carve-out in that
+      // uniform's rule ("a line that reports a data position may not be moved off it"): a
+      // column *is* a pixel column, and its x is already a screen coordinate derived from
+      // one -- there is no data position to move it off. The y bounds, which are what the
+      // segment reports, are untouched by the snap. It holds for both staging paths.
+      const u32 staged =
+          !columns ? 0u
+          : grade  ? stage_trace_density(plot, layout, trace, x_range.min, points)
+                   : stage_trace_columns(plot, layout, trace, x_range.min, points);
+      if (staged != 0u && grade) {
+        // One draw call per alpha step, faintest first: the line pipeline's colour is a
+        // uniform, so a per-segment alpha is not expressible and a step is a batch. They
+        // are flushed in order so the bright ridge composites over the faint tail rather
+        // than under it -- the runs within a column do not overlap, but their AA fringes
+        // do, and that is the order a phosphor display puts them in.
+        for (u32 t = 0; t < steps_.size(); ++t) {
+          if (steps_[t].segment_count() == 0u) continue;
+          Color color = trace.color;
+          color.a *= style_.intensity_floor +
+                     (1.0f - style_.intensity_floor) * static_cast<f32>(t) /
+                         static_cast<f32>(steps_.size() - 1u);
+          flush_lines(steps_[t], pixel_mapping(), color, style_.device(trace.width), dash, true);
+        }
+        ++stats_.column_traces;
+        ++stats_.graded_traces;
+      } else if (staged != 0u) {
+        flush_lines(pixel_mapping(), trace.color, style_.device(trace.width), dash, true);
+        ++stats_.column_traces;
+      } else {
+        stage_xy(gather_.data(), points, x_range.min, log_x, log_y);
+        flush_lines(map, trace.color, style_.device(trace.width), dash);
+      }
     }
 
     // Markers, staged as line segments through this same batch in *pixel* space
@@ -1097,7 +1517,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};
@@ -1369,6 +1789,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
@@ -1488,19 +1930,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);
+    }
   }
 }
 

tests/test_controller.cpp

@@ -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

tests/test_figure.cpp

@@ -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.
@@ -877,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());
@@ -906,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) {
@@ -930,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.
@@ -972,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.

tests/test_plot.cpp

@@ -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.

tests/test_render_smoke.cpp

@@ -38,6 +38,23 @@ constexpr plot::u32 kH = 360;
 /// 1M-wide window holds ~16 of them (the dense envelope spans the full height in
 /// every column) while a 640-wide one is a nearly flat line (the sparse path's
 /// polyline crosses every column exactly once).
+/// A sine of **one period per pixel column** for the window
+/// `a_dense_trace_can_be_graded_by_dwell` draws (60 000 x-units over a 572 px axis, so
+/// 104.9 samples a column). That is the one density at which a column *has* a dwell
+/// structure to grade: its envelope spans the full amplitude, so the band is tall, and
+/// the sub-buckets inside it are a fraction of a period each, so the ones at the sine's
+/// turning points are short and the ones crossing its middle are long. A period of many
+/// columns leaves every band a thin ribbon with nothing to distinguish, and a period of a
+/// fraction of a column fills every sub-bucket to the full amplitude -- also nothing.
+std::vector<plot::f32> fast_sine_samples() {
+  std::vector<plot::f32> y(1'000'000);
+  const double w = 2.0 * 3.14159265358979323846 / 104.9;
+  for (plot::u64 i = 0; i < y.size(); ++i) {
+    y[i] = static_cast<plot::f32>(std::sin(static_cast<double>(i) * w));
+  }
+  return y;
+}
+
 std::vector<plot::f32> sine_samples() {
   std::vector<plot::f32> y(1'000'000);
   for (plot::u64 i = 0; i < y.size(); ++i) {
@@ -723,11 +740,11 @@ class LyingGridSeries final : public plot::data::Series {
     if (x_at(i0) != x && i0 + 1u < kN) i1 = i0 + 1u;
     return true;
   }
-  void gather(u32, u64 begin, u64 end, std::vector<f32>& out,
+  void gather(u32, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out,
               plot::data::GatherMode) const override {
     ++gather_calls_;
     for (u64 i = begin; i < end; ++i) {
-      out.push_back(static_cast<f32>(x_at(i) - x0()));
+      out.push_back(static_cast<f32>(x_at(i) - x_origin));
       out.push_back(kY);
     }
   }
@@ -868,6 +885,260 @@ PLOT_TEST(dense_and_sparse_paths_agree_on_extent) {
   ctx.destroy();
 }
 
+/// A window denser than the pixel grid inks **whole columns**, which is what kills the moire.
+///
+/// Reported as "strong moire patterns due to a large number of vertical lines" on a high rate,
+/// a high frequency or a noisy signal. The polyline at this density is a stack of near-vertical
+/// hairlines at *fractional* x -- one to two envelope buckets per column, each a min->max
+/// hairline plus a connector -- so a column's brightness is a non-linear function of those
+/// sub-pixel phases, and the phases repeat at the beat between the bucket pitch and the pixel
+/// pitch. That beat is the pattern, and panning sweeps it, so it crawls.
+///
+/// The observable is the beat's own cause, measured: how many **distinct coverage levels** the
+/// trace's ink takes. One segment per column puts every column's ink at one sub-pixel phase, so
+/// the AA ramp is evaluated at the same few distances everywhere and the ink lands on **4**
+/// levels; the polyline's hairlines sit at arbitrary phases and its ink spreads over **126** of
+/// them. That spread *is* the texture, and it is what beats against the pixel pitch.
+///
+/// A count of partially covered pixels is *not* the reading, which is worth knowing before
+/// adding one: both renderings put about the same amount of ink in the fringe (577 against 652
+/// here, of 1400-odd inked pixels), because a 1.5 px stroke with a 1 px fringe always spills
+/// into its neighbour. The fix is not that the fringe is gone, it is that it is the *same*
+/// fringe in every column.
+///
+/// The window is one period of the sine over 107 samples per pixel: dense enough for the
+/// reduction and slow enough that the band is a *thin ribbon*, which is where the beat shows.
+/// A window whose buckets each span several periods paints a solid block and hides it.
+PLOT_TEST(a_dense_trace_is_drawn_as_whole_pixel_columns) {
+  plottest::HeadlessContext ctx(kW, kH);
+  plot::Status st;
+  PLOT_CHECK(ctx.create(&st));
+  PLOT_CHECK(plot::gl::load(nullptr));
+  plot::Renderer r;
+  PLOT_CHECK(r.init(&st));
+
+  plot::data::ArraySeries s(sine_samples(), 0.0, 1.0);
+  plot::Plot p;
+  p.set_viewport({0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  const plot::u32 ax = p.add_x_axis({"t", {0.0, 60'000.0}, false, plot::AxisPlace::Bottom, false});
+  const plot::u32 ay = p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  p.add_trace({&s, plot::Color::hex(0x40C0FF), 1.5f, ax, ay});
+
+  r.begin_frame(kW, kH, {0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  r.draw(p);
+  r.end_frame();
+  dump_if_requested(r, "columns.ppm");
+
+  const plot::Rect a = p.layout().axes;
+  // Blue over the background minus red is the trace's coverage, linearly: 8 at no coverage
+  // and 199 at full (0x40C0FF over 0x101418). Nothing else in this frame is blue-dominant --
+  // the grid and the axis line are grey -- so the two bands below are the trace's own ink,
+  // split at three quarters covered.
+  plot::u32 inked = 0;
+  plot::u32 histogram[256] = {};
+  for (plot::u32 row = 0; row < static_cast<plot::u32>(a.h); ++row) {
+    for (plot::u32 col = 0; col < static_cast<plot::u32>(a.w); ++col) {
+      plot::u8 px[4] = {};
+      const plot::u32 x = static_cast<plot::u32>(a.x) + col;
+      PLOT_CHECK(ctx.read_pixel(x, ctx.height - 1u - (static_cast<plot::u32>(a.y) + row), px));
+      const int cover = static_cast<int>(px[2]) - static_cast<int>(px[0]);
+      if (cover > 40) {   // the trace's ink, at a quarter covered or better
+        ++inked;
+        ++histogram[cover];
+      }
+    }
+  }
+  // How many *distinct* coverages the ink takes is the beat, measured. A column's ink is
+  // placed at one sub-pixel phase, so the AA ramp is evaluated at the same few distances in
+  // every column and the ink lands on a handful of levels; a polyline's hairlines sit at
+  // arbitrary phases, so its ink spreads over the whole range of them. The floor of 4 pixels
+  // per level ignores the stragglers at the ribbon's turning points.
+  plot::u32 levels = 0;
+  for (plot::u32 c = 0; c < 256u; ++c) {
+    if (histogram[c] >= 4u) ++levels;
+  }
+  std::printf("[columns] axes=[%.1f %.1f %.1f %.1f] raw=%u lod=%u columns=%u segments=%u "
+              "visible=%llu inked=%u levels=%u\n",
+              a.x, a.y, a.w, a.h, r.stats().raw_traces, r.stats().lod_traces,
+              r.stats().column_traces, r.stats().staged_segments,
+              static_cast<unsigned long long>(r.stats().visible_samples), inked, levels);
+
+  // The reduction ran, and on the *raw* path: the gate is the gathered density, not the level.
+  PLOT_CHECK(r.stats().column_traces == 1);
+  PLOT_CHECK(r.stats().visible_samples > 50'000u);
+  // One segment per column, so the frame's whole geometry -- grid and axis lines included --
+  // is bounded by the axis' width: 627 against the polyline's 60 054.
+  PLOT_CHECK(r.stats().staged_segments < static_cast<plot::u32>(a.w) + 64u);
+  // The ribbon is there, and its ink sits on a handful of coverage levels (4) rather than on a
+  // continuum of them (126).
+  PLOT_CHECK(inked > static_cast<plot::u32>(a.w));
+  PLOT_CHECK(levels <= 8u);
+
+  PLOT_CHECK(!r.last_frame_had_gl_error());
+  ctx.destroy();
+}
+
+/// `Style::intensity_grading`: a reduced column is drawn **graded by dwell** -- bright
+/// where the signal sits, faint where it only passes through -- which is the second half
+/// of the moire answer. The columns alone removed the beat; this is what puts back the
+/// information a flat band throws away, the way a phosphor display does.
+///
+/// The observable is the thing the feature claims and nothing weaker: within one column,
+/// the rows at the **edges** of the band are brighter than the rows in its **middle**.
+/// For a sine of one period per column that is exactly right -- it dwells at its turning
+/// points and crosses its middle at full speed -- and it is a property of the *rendering*
+/// rather than of the waveform, because the same frame drawn ungraded puts the band's
+/// edge and its middle at the same coverage. Both frames are measured here, so what is
+/// asserted is the difference between them.
+///
+/// It also pins what grading may *not* cost. The reduction still runs (`column_traces`),
+/// so the beat is still gone; the geometry is still bounded by the axis' width times a
+/// small factor, because a run is a stretch of equal tier and not a row; and the draw
+/// calls are bounded by the steps, since the line pipeline's colour is a uniform.
+PLOT_TEST(a_dense_trace_can_be_graded_by_dwell) {
+  plottest::HeadlessContext ctx(kW, kH);
+  plot::Status st;
+  PLOT_CHECK(ctx.create(&st));
+  PLOT_CHECK(plot::gl::load(nullptr));
+  plot::Renderer r;
+  PLOT_CHECK(r.init(&st));
+
+  plot::data::ArraySeries s(fast_sine_samples(), 0.0, 1.0);
+  plot::Plot p;
+  p.set_viewport({0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  const plot::u32 ax = p.add_x_axis({"t", {0.0, 60'000.0}, false, plot::AxisPlace::Bottom, false});
+  const plot::u32 ay = p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  p.add_trace({&s, plot::Color::hex(0x40C0FF), 1.5f, ax, ay});
+
+  // The band's edges against its middle, averaged over columns across the axis. The
+  // shares are of the band's own height, so the reading does not depend on where the
+  // band happens to sit or on how tall it is: the outer fifth at each end against the
+  // middle fifth.
+  struct Profile {
+    plot::u32 edge = 0;     ///< mean peak coverage over the band's two outer fifths
+    plot::u32 middle = 0;   ///< mean peak coverage over its middle fifth
+    plot::u32 columns = 0;  ///< columns that held a band at all
+  };
+  auto profile = [&](const plot::Rect& a) -> Profile {
+    const plot::u32 rows = static_cast<plot::u32>(a.h);
+    std::vector<int> cover(rows, 0);
+    plot::u64 edge_sum = 0;
+    plot::u64 middle_sum = 0;
+    Profile out;
+    for (plot::u32 col = 8; col + 8 < static_cast<plot::u32>(a.w); col += 16) {
+      plot::u32 lo = rows;
+      plot::u32 hi = 0;
+      for (plot::u32 row = 0; row < rows; ++row) {
+        plot::u8 px[4] = {};
+        const plot::u32 x = static_cast<plot::u32>(a.x) + col;
+        PLOT_CHECK(ctx.read_pixel(x, ctx.height - 1u - (static_cast<plot::u32>(a.y) + row), px));
+        cover[row] = static_cast<int>(px[2]) - static_cast<int>(px[0]);
+        if (cover[row] > 20) {   // the faintest step is 0.3 of 191, so this is under it
+          if (row < lo) lo = row;
+          hi = row;
+        }
+      }
+      // A band of fewer than 15 rows has no middle fifth to speak of; at this density
+      // there is none, but the reading would be meaningless if there were.
+      if (lo >= hi || hi - lo < 15u) continue;
+      const plot::u32 h = hi - lo + 1u;
+      const plot::u32 fifth = h / 5u;
+      int edge = 0;
+      int middle = 0;
+      for (plot::u32 row = lo; row <= hi; ++row) {
+        const plot::u32 d = row - lo;
+        if (d < fifth || d >= h - fifth) {
+          if (cover[row] > edge) edge = cover[row];
+        } else if (d >= 2u * fifth && d < 3u * fifth) {
+          if (cover[row] > middle) middle = cover[row];
+        }
+      }
+      edge_sum += static_cast<plot::u64>(edge);
+      middle_sum += static_cast<plot::u64>(middle);
+      ++out.columns;
+    }
+    if (out.columns != 0) {
+      out.edge = static_cast<plot::u32>(edge_sum / out.columns);
+      out.middle = static_cast<plot::u32>(middle_sum / out.columns);
+    }
+    return out;
+  };
+
+  // Ungraded first: the reference the grading is read against.
+  r.begin_frame(kW, kH, {0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  r.draw(p);
+  r.end_frame();
+  dump_if_requested(r, "ungraded.ppm");
+  const plot::Rect a = p.layout().axes;
+  const Profile flat = profile(a);
+  const plot::u32 flat_segments = r.stats().staged_segments;
+  const plot::u32 flat_draws = r.stats().draw_calls;
+  PLOT_CHECK(r.stats().column_traces == 1 && r.stats().graded_traces == 0);
+  PLOT_CHECK(!r.last_frame_had_gl_error());
+
+  r.style().intensity_grading = true;
+  r.begin_frame(kW, kH, {0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  r.draw(p);
+  r.end_frame();
+  dump_if_requested(r, "graded.ppm");
+  const Profile lit = profile(a);
+
+  std::printf("[graded] axes=[%.1f %.1f %.1f %.1f] flat edge=%u middle=%u cols=%u seg=%u "
+              "draws=%u | graded edge=%u middle=%u cols=%u seg=%u draws=%u columns=%u "
+              "graded_traces=%u\n",
+              a.x, a.y, a.w, a.h, flat.edge, flat.middle, flat.columns, flat_segments,
+              flat_draws, lit.edge, lit.middle, lit.columns, r.stats().staged_segments,
+              r.stats().draw_calls, r.stats().column_traces, r.stats().graded_traces);
+
+  // Both frames measured a band in most of the columns they sampled, or the two
+  // profiles are not comparable and everything below is vacuous.
+  PLOT_CHECK(flat.columns > 20u && lit.columns == flat.columns);
+  // The flat band is flat: its edge and its middle are one ink (191 and 191).
+  PLOT_CHECK(flat.middle > 0u && flat.edge * 100u < flat.middle * 115u);
+  // The graded one is not, and in the direction a sine dwells in: 191 against 131, a
+  // middle at 0.69 of the edge. The figure is a *tier* ratio and not the dwell ratio --
+  // the per-row dwell at the rails is several times the crossing's, and
+  // `intensity_gamma` (0.45) and `intensity_floor` (0.3) are there to compress exactly
+  // that into a range an eye reads as shading rather than as a gap. So the threshold is
+  // what the quantised ink does, with room for a step either way.
+  PLOT_CHECK(lit.middle > 0u && lit.middle * 100u < lit.edge * 80u);
+  // The reduction still ran, so the beat the columns removed is still gone.
+  PLOT_CHECK(r.stats().column_traces == 1 && r.stats().graded_traces == 1);
+  // A run is a stretch of equal tier, not a row: the geometry stays bounded by the
+  // axis' width times a small factor, nothing like `w * h`. Measured 8303 over a 572 px
+  // axis, 14.5 runs a column -- the dwell profile's own structure (four tiers from the
+  // dim middle out to each rail) plus the quantiser's dither at each boundary. The flat
+  // path's 627 is the other end of the scale, and 572 * 156 rows is what this is not.
+  PLOT_CHECK(r.stats().staged_segments < 24u * static_cast<plot::u32>(a.w));
+  // And the draw calls by the steps: one per tier that staged anything, over the flat
+  // frame's single trace draw.
+  PLOT_CHECK(r.stats().draw_calls <= flat_draws + r.style().intensity_steps);
+
+  // And the level floor, which the window above cannot see: at 105 samples a pixel the
+  // flat path is already on raw samples, so grading asks for nothing finer. A wider
+  // window puts the flat path on the pyramid, and there a sub-column is `spp / 8` -- which
+  // falls under one bucket long before the column does, so an unfloored ask answers level
+  // 0 and gathers the whole visible window. That is a real cost and it was measured: at
+  // 1.3 MS/s over a 2 s window udpscope's own frame report went from `raw=710 lod=453` to
+  // `raw=1154 lod=0` and 2.3 -> 6.4 ms a frame. The floor is one bucket level, so the
+  // reading is simply that a graded frame stays on the pyramid.
+  p.set_x_range(ax, {0.0, 200'000.0});
+  r.begin_frame(kW, kH, {0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  r.draw(p);
+  r.end_frame();
+  std::printf("[graded] wide: raw=%u lod=%u columns=%u graded=%u seg=%u visible=%llu\n",
+              r.stats().raw_traces, r.stats().lod_traces, r.stats().column_traces,
+              r.stats().graded_traces, r.stats().staged_segments,
+              static_cast<unsigned long long>(r.stats().visible_samples));
+  PLOT_CHECK(r.stats().visible_samples > 100'000u);
+  PLOT_CHECK(r.stats().lod_traces == 1 && r.stats().raw_traces == 0);
+  PLOT_CHECK(r.stats().column_traces == 1 && r.stats().graded_traces == 1);
+  PLOT_CHECK(r.stats().staged_segments < 24u * static_cast<plot::u32>(a.w));
+
+  PLOT_CHECK(!r.last_frame_had_gl_error());
+  ctx.destroy();
+}
+
 // Resolution #1 of the brief: the renderer draws into whatever framebuffer is
 // bound and clears only its viewport, so a host that embeds the plot in a
 // sub-rect (Qt/GTK/ImGui) keeps the rest of its surface. Coordinates are given
@@ -1470,6 +1741,103 @@ PLOT_TEST(a_sparse_window_marks_its_samples) {
   ctx.destroy();
 }
 
+/// A ring-backed series whose oldest slots read a *clamped* stamp gets no segment across the panel.
+///
+/// `ChannelBuffer`'s documented bargain: the published window is pinned while both rings slide under
+/// it, so the oldest few slots of a saturated window point at time slots the producer has
+/// overwritten and have to be clamped to the oldest *readable* one -- the alternative, a sentinel,
+/// collapsed the whole index mapping. The effect on the polyline is that the stamps do not increase
+/// at the *front*: the first points carry the newest stamp and everything behind them is older. Drawn
+/// as they come, that is a segment from the newest sample back to the oldest: a line across the whole
+/// panel, which is what "it connects the newest point with the oldest" looks like.
+///
+/// The trace here is flat at +1 except for those two unreadable points, which carry -1. Any ink in the
+/// lower half of the axes is therefore the bad segment, and nothing else in the frame is that colour.
+PLOT_TEST(a_clamped_front_does_not_draw_a_segment_across_the_panel) {
+  plottest::HeadlessContext ctx(kW, kH);
+  plot::Status st;
+  PLOT_CHECK(ctx.create(&st));
+  PLOT_CHECK(plot::gl::load(nullptr));
+  plot::Renderer r;
+  PLOT_CHECK(r.init(&st));
+
+  /// Eight samples: indices 0 and 1 are the clamped front (newest stamp, low value), 2..7 walk 0..50
+  /// at +1.
+  struct ClampedFront final : plot::data::Series {
+    ClampedFront() {
+      pyramid_.reserve(8u);
+      for (u64 i = 0; i < 8u; ++i) pyramid_.append(i < 2u ? -1.0f : 1.0f);
+    }
+    u64 size() const override { return 8u; }
+    f64 x0() const override { return 0.0; }
+    f64 dx() const override { return 1.0; }
+    plot::Range x_bounds() const override { return {0.0, 60.0}; }
+    plot::Range y_bounds() const override { return {-1.0, 1.0}; }
+    const plot::data::MinMaxPyramid& pyramid() const override { return pyramid_; }
+    f64 x_at(u64 i) const override { return i < 2u ? 60.0 : 10.0 * static_cast<f64>(i - 2u); }
+    bool neighbours(f64 x, u64& i0, u64& i1) const override {
+      if (x < 0.0 || x > 60.0) return false;
+      const u64 k = std::min<u64>(2u + static_cast<u64>(x / 10.0), 7u);
+      i0 = k;
+      i1 = k;
+      if (x_at(k) != x && k + 1u < 8u) i1 = k + 1u;
+      return true;
+    }
+    void gather(u32, u64 begin, u64 end, f64 x_origin, std::vector<f32>& out,
+                plot::data::GatherMode) const override {
+      for (u64 i = begin; i < end; ++i) {
+        out.push_back(static_cast<f32>(x_at(i) - x_origin));
+        out.push_back(i < 2u ? -1.0f : 1.0f);
+      }
+    }
+
+   protected:
+    void copy_raw(u64 begin, u64 end, f32* out) const override {
+      for (u64 i = begin; i < end; ++i) out[i - begin] = i < 2u ? -1.0f : 1.0f;
+    }
+
+   private:
+    plot::data::MinMaxPyramid pyramid_;
+  } series;
+
+  plot::Plot p;
+  p.set_viewport({0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  const plot::u32 ax = p.add_x_axis({"t", {-5.0, 55.0}, false, plot::AxisPlace::Bottom, false});
+  const plot::u32 ay = p.add_y_axis({"v", {-2.0, 2.0}, false, plot::AxisPlace::Left, false});
+  p.add_trace({&series, plot::Color::hex(0x00FF00), 1.5f, ax, ay});
+
+  r.begin_frame(kW, kH, {0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  r.draw(p);
+  r.end_frame();
+  PLOT_CHECK(!r.last_frame_had_gl_error());
+
+  const plot::Rect& a = p.layout().axes;
+  plot::u32 below = 0;
+  plot::u32 on_the_line = 0;
+  for (plot::u32 cx = static_cast<plot::u32>(a.x) + 3u; cx + 3u < static_cast<plot::u32>(a.x + a.w);
+       ++cx) {
+    for (plot::u32 row = static_cast<plot::u32>(a.h / 2u) + 2u;
+         row + 2u < static_cast<plot::u32>(a.h); ++row) {
+      plot::u8 px[4] = {};
+      PLOT_CHECK(ctx.read_pixel(cx, ctx.height - 1u - (static_cast<plot::u32>(a.y) + row), px));
+      if (green_pixel(px)) ++below;
+    }
+  }
+  for (plot::u32 cx = static_cast<plot::u32>(a.x) + 3u; cx + 3u < static_cast<plot::u32>(a.x + a.w);
+       ++cx) {
+    for (plot::u32 row = static_cast<plot::u32>(a.h / 2u) - 2u;
+         row > 1u; --row) {
+      plot::u8 px[4] = {};
+      PLOT_CHECK(ctx.read_pixel(cx, ctx.height - 1u - (static_cast<plot::u32>(a.y) + row), px));
+      if (green_pixel(px)) ++on_the_line;
+    }
+  }
+  std::printf("[clamped-front] ink below the middle: %u, above: %u\n", below, on_the_line);
+  PLOT_CHECK(below == 0u);    // the two clamped points' segments are nowhere
+  PLOT_CHECK(on_the_line > 100u);  // and the real trace is still drawn
+  ctx.destroy();
+}
+
 PLOT_TEST(grid_hairlines_land_on_whole_pixels) {
   plottest::HeadlessContext ctx(kW, kH);
   plot::Status st;
@@ -3075,6 +3443,111 @@ PLOT_TEST(legend_does_not_cover_the_plot_when_placed_bottom_left) {
   ctx.destroy();
 }
 
+/// `Plot::set_x_note()`'s caption is *chrome*: it sits in the bottom-left corner of the
+/// axes on the legend's own backplate, and panning or zooming the x range does not move
+/// it by a pixel. That is the whole reason it exists rather than an `Annotation`, whose
+/// anchor is a data coordinate and so crawls under a pan and drifts under a zoom.
+///
+/// The caption's rect is deliberately not readable back -- it reserves no space and
+/// nothing can be picked on it -- so the test measures it the only way a reader can see
+/// it: the pixels a frame *with* the note differs from the same frame without one. The
+/// bounding box of that difference is the caption's footprint, and the assertion is that
+/// two completely different x ranges produce the *same* box.
+PLOT_TEST(the_x_note_is_chrome_that_a_pan_or_a_zoom_does_not_move) {
+  plottest::HeadlessContext ctx(kW, kH);
+  plot::Status st;
+  PLOT_CHECK(ctx.create(&st));
+  PLOT_CHECK(plot::gl::load(nullptr));
+  plot::Renderer r;
+  PLOT_CHECK(r.init(&st));
+
+  plot::data::ArraySeries s(sine_samples(), 0.0, 1.0);
+  plot::Plot p;
+  p.set_viewport({0, 0, static_cast<plot::f32>(kW), static_cast<plot::f32>(kH)});
+  const plot::u32 ax = p.add_x_axis({"t", s.x_bounds(), true, plot::AxisPlace::Bottom, false});
+  const plot::u32 ay = p.add_y_axis({"v", {-1.0, 1.0}, false, plot::AxisPlace::Left, false});
+  PLOT_CHECK(p.add_trace({&s, plot::Color::hex(0x00E070, 1.0f), 1.5f, ax, ay, "signal"}) == 0u);
+
+  // The footprint of the note at one x range: the bounding box of the pixels that the
+  // caption, and only the caption, is responsible for.
+  const auto footprint = [&](const plot::Range& view, const char* dump) {
+    plot::Rect box{0.0f, 0.0f, 0.0f, 0.0f};
+    p.set_x_range(ax, view);
+    p.set_x_note("t0 = 1.23457e+06 s");
+    r.begin_frame(kW, kH, kFrameRect);
+    r.draw(p);
+    r.end_frame();
+    PLOT_CHECK(!r.last_frame_had_gl_error());
+    dump_if_requested(r, dump);
+    const std::vector<plot::u8> with = read_frame(ctx);
+    p.set_x_note("");
+    r.begin_frame(kW, kH, kFrameRect);
+    r.draw(p);
+    r.end_frame();
+    PLOT_CHECK(!r.last_frame_had_gl_error());
+    const std::vector<plot::u8> without = read_frame(ctx);
+    plot::u32 lo_x = kW, lo_y = kH, hi_x = 0, hi_y = 0, differing = 0;
+    for (plot::u32 y = 0; y < kH; ++y) {
+      for (plot::u32 x = 0; x < kW; ++x) {
+        const plot::usize at = (plot::usize(y) * kW + x) * 4u;
+        if (with[at] == without[at] && with[at + 1u] == without[at + 1u] &&
+            with[at + 2u] == without[at + 2u] && with[at + 3u] == without[at + 3u]) {
+          continue;
+        }
+        ++differing;
+        lo_x = std::min(lo_x, x);
+        lo_y = std::min(lo_y, y);
+        hi_x = std::max(hi_x, x);
+        hi_y = std::max(hi_y, y);
+      }
+    }
+    // A comparison of two frames is only evidence if the caption was in one of them.
+    PLOT_CHECK(differing > 0u);
+    box = plot::Rect{static_cast<plot::f32>(lo_x), static_cast<plot::f32>(lo_y),
+                     static_cast<plot::f32>(hi_x - lo_x + 1u),
+                     static_cast<plot::f32>(hi_y - lo_y + 1u)};
+    return box;
+  };
+
+  const plot::Rect wide = footprint({0.0, 640.0}, "x_note.ppm");
+  // The corner: inside the axes, held off the left and bottom edges by a pad of a few
+  // pixels, and nowhere near the right-hand side or the top.
+  const plot::Rect axes = p.layout().axes;
+  PLOT_CHECK(wide.x > axes.x && wide.x < axes.x + 16.0f);
+  PLOT_CHECK(wide.bottom() <= axes.bottom() && wide.bottom() > axes.bottom() - 16.0f);
+  PLOT_CHECK(wide.right() < axes.x + 0.5f * axes.w);  // a caption, not a banner
+  PLOT_CHECK(wide.h >= 8.0f && wide.h < 0.5f * axes.h);
+  // Real glyph ink on the backplate, so the box is a caption and not an empty panel. The
+  // frame has to be re-drawn *with* the note first: the measurement above left the
+  // note-less frame in the buffer, and `scan_rect_ink` reads the live one.
+  p.set_x_range(ax, {0.0, 640.0});
+  p.set_x_note("t0 = 1.23457e+06 s");
+  r.begin_frame(kW, kH, kFrameRect);
+  r.draw(p);
+  r.end_frame();
+  PLOT_CHECK(!r.last_frame_had_gl_error());
+  PLOT_CHECK(scan_rect_ink(ctx, wide, r.style().axis_text).pixels >= 16u);
+
+  // The same caption under a pan to a different decade and a 64x zoom: an annotation
+  // anchored in data would have left the frame entirely, and the one here has not moved
+  // a pixel. The text is fixed across the three, since this case is about the position.
+  const plot::Rect panned = footprint({320.0, 960.0}, "x_note_panned.ppm");
+  const plot::Rect zoomed = footprint({300.0, 310.0}, "x_note_zoomed.ppm");
+  PLOT_CHECK_NEAR(panned.x, wide.x, 1e-4);
+  PLOT_CHECK_NEAR(panned.y, wide.y, 1e-4);
+  PLOT_CHECK_NEAR(panned.w, wide.w, 1e-4);
+  PLOT_CHECK_NEAR(panned.h, wide.h, 1e-4);
+  PLOT_CHECK_NEAR(zoomed.x, wide.x, 1e-4);
+  PLOT_CHECK_NEAR(zoomed.y, wide.y, 1e-4);
+  PLOT_CHECK_NEAR(zoomed.w, wide.w, 1e-4);
+  PLOT_CHECK_NEAR(zoomed.h, wide.h, 1e-4);
+  std::printf("[x note] footprint %.0f,%.0f %.0fx%.0f in axes %.0f,%.0f %.0fx%.0f; panned "
+              "%.0f,%.0f %.0fx%.0f, zoomed %.0f,%.0f %.0fx%.0f\n",
+              wide.x, wide.y, wide.w, wide.h, axes.x, axes.y, axes.w, axes.h, panned.x, panned.y,
+              panned.w, panned.h, zoomed.x, zoomed.y, zoomed.w, zoomed.h);
+  ctx.destroy();
+}
+
 // --- one physical size at any DPI --------------------------------------------
 
 namespace {

tests/test_series.cpp

@@ -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) {

tests/test_ticks.cpp

@@ -263,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,

tests/test_xy_series.cpp

@@ -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).