@pond-ts/charts 0.62.0 → 0.64.0

package/API.md

@@ -164,7 +164,7 @@ Deliberately small — the ordering-based slice of the algebra, no calendar ops
 | Operation schemas | `RollingSchema`, `RollingAlignment`, `AlignSchema`, `DiffSchema`, `SmoothSchema`, `SmoothMethod`, `FillStrategy`, `FillMapping`                    | `packages/core/src/schema/index.ts`                                |
 | Column/data kinds | `Column`, `KeyColumn`, `ColumnKind`, `ScalarKind`, `ScalarValue`, `ColumnValue`, `ArrayValue`, `ValidityBitmap`                                    | `packages/core/src/columnar/`                                      |
 | JSON wire format  | `JsonRowFormat`, `JsonRowForSchema`, `JsonObjectRowForSchema`, `JsonValueForKind`, `JsonTimestampInput`, `JsonTimeRangeInput`, `JsonIntervalInput` | `packages/core/src/schema/index.ts`                                |
-| Temporal utility  | `TemporalLike`, `DurationInput`, `CalendarUnit`, `TimeZoneOptions`, `KeyLike`, `BatchSampleStrategy`                                               | `packages/core/src/core/`, `packages/core/src/sequence/`           |
+| Temporal utility  | `TemporalLike`, `DurationInput`, `CalendarUnit`, `TimeZoneOptions`, `KeyLike`, `BatchSampleStrategy`, `SequenceSample`, `SequenceCoverage`         | `packages/core/src/core/`, `packages/core/src/sequence/`           |
 
 The `pond-ts/types` subpath re-exports the schema-as-contract types with zero
 runtime (`packages/core/src/schema/public.ts`).

package/CHANGELOG.md

@@ -8,7 +8,9 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 under a single `v*` tag, so this file covers them all. Pre-1.0: minor bumps may
 include new features and type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pond-ts/pond/compare/v0.62.0...HEAD
+[Unreleased]: https://github.com/pond-ts/pond/compare/v0.64.0...HEAD
+[0.64.0]: https://github.com/pond-ts/pond/compare/v0.63.0...v0.64.0
+[0.63.0]: https://github.com/pond-ts/pond/compare/v0.62.0...v0.63.0
 [0.62.0]: https://github.com/pond-ts/pond/compare/v0.61.0...v0.62.0
 [0.61.0]: https://github.com/pond-ts/pond/compare/v0.60.0...v0.61.0
 [0.60.0]: https://github.com/pond-ts/pond/compare/v0.59.0...v0.60.0
@@ -65,6 +67,226 @@ include new features and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.64.0] — 2026-08-28
+
+### Added
+
+- `pond-ts`: **`Sequence.bounded(range, { coverage })`** — chooses whether a
+  range selects buckets by their sample point (`'sample'`, the default and the
+  existing behaviour) or by their extent (`'overlap'`, every bucket the range
+  touches, including the one containing `range.begin()`). `aggregate` realizes
+  its grid with `'overlap'`; alignment keeps `'sample'`. As a side benefit
+  `bounded({ start: t, end: t }, { coverage: 'overlap' })` is a flooring
+  primitive — it returns exactly the bucket containing `t` — so consumers no
+  longer have to re-derive pond's calendar anchoring by hand to floor a
+  timestamp. New exported type `SequenceCoverage`.
+
+- `@pond-ts/charts`: **`<YAxis zeroAnchored>`** — pins a y-axis's zoom to the
+  value-`0` gridline instead of the pointer, and drops drag-to-pan entirely.
+  For a bar chart, whose baseline must never move: a bar rests on `0` (at the
+  plot floor for all-positive data, or somewhere mid-plot for data that
+  straddles positive and negative), and an ordinary pointer-pivoted gesture
+  would slide that baseline around the plot as you scroll. With
+  `zeroAnchored`, every wheel notch scales the axis around wherever `0`
+  currently renders, so the baseline holds however far in or out you zoom.
+  One qualification: the pivot is clamped into the axis's pixel range, so once
+  `0` has been scrolled off the plot the zoom pivots about the nearer edge and
+  the baseline does creep — benign for bars, where that clamp coincides with
+  the declared floor, but not an unconditional guarantee. Still gated by the
+  container's own `axisPanZoom` opt-in — this changes what the gesture does,
+  not whether it's on.
+
+### Changed
+
+- `pond-ts`: **`aggregate` now emits the bucket containing the first event**,
+  where before it started at the first grid boundary _at or after_ it — so
+  every event between the two aggregated into nothing, silently. 60 daily bars
+  rolled to a calendar month came back holding 38 of them: no error, no
+  warning, no `undefined`, just a well-formed series with a third of the input
+  gone. It contradicted `aggregate`'s own documented membership rule ("point
+  events contribute to the bucket containing their timestamp") and was
+  asymmetric — the trailing partial bucket _was_ emitted. **This changes
+  results for any caller whose first event did not land exactly on a grid
+  boundary**: expect an extra leading bucket, and sums/counts that now account
+  for the previously-dropped events. Callers who worked around it by passing a
+  pre-floored explicit `range` are unaffected — the floor is now what the
+  default does. **Note what `range` does and does not bound:** it selects the
+  grid, not the event scan, so the leading bucket is filled from every event it
+  contains — including events _before_ `range.begin()` when the series has
+  them. On a window narrower than the series (a chart viewport, say) the edge
+  bucket is therefore a complete bucket rather than a clipped one, which is
+  what keeps bar heights stable under a pan; if you need the window to bound
+  the events too, narrow the series rather than the grid. `align(...)` and
+  `materialize(...)` are deliberately unchanged: their grids are _sampled_,
+  and the sample point becomes the output key. A pre-realized
+  `BoundedSequence` argument is an explicit bucket list, used as given and
+  unaffected by any of this. Reported by Tidal (#672).
+
+- `@pond-ts/charts`: **y gutter drag now pans instead of zooming** — matching
+  the x strip's own gesture (drag pans, wheel zooms) instead of the
+  drag-to-zoom behavior it shipped with in `axisPanZoom="y"`/`"xy"`. Wheel
+  still zooms the grabbed axis about the pointer, and double-click still
+  releases it back to its fit; only the drag's own effect changed.
+
+### Fixed
+
+- `@pond-ts/charts`: **a trading-time date band clamped onto a labelled tick
+  keeps its segment boundary.** The F-charts-21 collision fix dropped the whole
+  `{ start, label, shaded }` entry, but `<XAxis>` spans each band
+  `[its start, the next band's start)` and takes its zebra parity from
+  `shaded` — so removing an entry deleted the _period_, not a duplicate label,
+  and the preceding band ran on to the next surviving boundary under its own
+  name and shading. (Aug 1 2026 is a Saturday, so the August band clamps onto
+  Mon Aug 3, already a day tick — August vanished and July painted across it.)
+  `bands()` entries now carry **`showLabel`**, and only the text is suppressed.
+  Found by Codex reviewing the v0.64.0 range.
+- `@pond-ts/charts`: **a controlled y-gutter wheel zoom no longer pivots about
+  the wrong point under a plot-level y zoom.** The `zeroAnchored` pivot was
+  corrected above, but the ordinary (non-anchored) controlled wheel still fed
+  the pointer's _screen_ pixel into the pre-transform scale's pixel space, so
+  the value under the pointer slid out from under it — ~0.14 units per notch at
+  `k = 1.198`. Third and last face of one root cause: a screen-space pixel used
+  where `base`'s pixel space is meant.
+- `@pond-ts/charts`: **a controlled y-gutter pan no longer overshoots the
+  cursor under a plot-level y zoom.** With `onBoundsChange` set, the drag
+  translated the axis's pre-transform scale by a _screen_ pixel delta. Those
+  two pixel spaces differ by the container's `yTransform`, so with the plot's
+  own y pan/zoom engaged (`panZoom="panZoomY"` / `"panZoomXY"`) the axis
+  panned `k`× too far and the grabbed value outran the pointer. Both
+  transforms are applied in pixel space, so the base↔screen relation is
+  exactly affine and the correction is a division, on `log` and `symlog` as
+  well. (The division is exact on all three; end-to-end tracking on `symlog`
+  still drifts, because its knee is re-derived from the panned domain — a
+  pre-existing property the sibling zoom test already documents.) Invisible at
+  `k === 1`.
+- `@pond-ts/charts`: **`<YAxis zeroAnchored>` no longer lets the baseline drift
+  in the controlled path.** With `onBoundsChange` set, the zoom read `0`'s
+  pixel off the axis's _live_ scale but inverted it through `baseYScales`.
+  Those two pixel spaces differ by the container's own `yTransform`, so with
+  the plot's y pan/zoom active (`panZoom="panZoomY"` / `"panZoomXY"`) the
+  baseline crept a few pixels per wheel notch — monotonically, in exactly the
+  gesture whose purpose is to hold it still. It was invisible without a
+  plot-level y zoom, where the two spaces coincide. Found by a post-merge
+  adversarial review of #676.
+- `@pond-ts/charts`: **a `BarChart`'s baseline no longer relocates under a y
+  gutter pan/zoom.** `resolveBarBaseline` decided whether bars rest on zero or
+  on the axis floor by reading the axis's _live, transformed_ domain — the
+  same read a pan/zoom keeps moving — so once a gesture scrolled zero out of
+  view, every bar's rendered top silently snapped to the moving floor instead
+  of its actual value. It now reads the axis's declared (pre-transform)
+  domain for that decision, so a pan/zoom can move the viewport without ever
+  relocating a bar's own baseline.
+- `@pond-ts/charts`: **[F-charts-21] a trading-time axis's stacked date-band
+  row no longer draws a second, colliding label over a collapsed-gap seam.**
+  `scale.bands()` picked its anchors from the raw calendar (a month or day
+  start) without checking whether that instant was live, so a period
+  beginning on a collapsed weekend or holiday clamped its label onto the same
+  seam a tick (or another band) already occupied — rendering as two
+  overlapping labels (`"Aug"` over `"Aug 3"`, or worse at tight zoom, fully
+  interleaved). Bands whose raw start needed clamping now dedupe against a
+  run of other clamped starts landing on the same live instant (picking the
+  genuinely-live member as the representative when one exists) and against
+  an already-labelled tick, so a seam carries exactly one label.
+
+## [0.63.0] — 2026-08-18
+
+### Added
+
+- `@pond-ts/charts`: **axis pan/zoom**, behind a new
+  **`<ChartContainer axisPanZoom>`** (`'none'` — the default — / `'x'` / `'y'` /
+  `'xy'`). Opted in, the `<XAxis>` strip and each `<YAxis>` gutter become
+  grabbable, and **double-click** puts one back (the declared `range` on x, its
+  fit on y). The cursor stays an ordinary arrow at rest and becomes directional
+  (`↕` / `↔`) only while a gesture is running.
+
+  **The opt-in is deliberately separate from `panZoom`, in both directions.** An
+  already-interactive chart does not grow axis gestures on upgrade — nothing
+  changes for any existing chart — and a chart can scale its y axes with
+  `panZoom` off entirely, which is what you want when the plot's drag belongs to
+  a selection sweep.
+
+  **The x strip is the canvas gesture, moved to the axis** — drag pans, wheel
+  zooms about the pointer — reusing the plot's own domain-space maths, so
+  `bounds` and `minDuration` still fence the view and a trading-time axis still
+  pans and floors in _trading_ time. A category axis has no continuous domain and
+  stays inert.
+
+  **A y gutter zooms, and only the axis you grabbed** — its sibling and every
+  other row hold still. That needed a new per-axis pixel transform
+  (`RowFrame.axisTransforms`, layered under the container's uniform
+  `yTransform`), since the uniform one exists precisely so a _plot_ gesture never
+  has to pick an axis; unlike it, this is not floored at `k ≥ 1`, because
+  squashing an axis you grabbed is the point.
+
+- `@pond-ts/charts`: **`<YAxis onBoundsChange>`** — the auto-vs-manual hand-off
+  for a scaled y axis. Fires with the `[min, max]` a gutter gesture reached, and
+  with `null` when the axis is released back to auto-fit, so a UI can show the
+  bounds, badge the scale "manual", and offer a toggle back. Providing it makes
+  the axis **controlled** (the gesture only reports; `min`/`max` fed back are
+  what it draws), exactly as `onTimeRangeChange` does for the x view; omit it and
+  the axis holds the zoom itself. `ContainerFrame` also gains `seedRange` — the
+  declared view, as against the gestured `timeRange` — which is the x reset's
+  target.
+
+- **charts: `<ChartContainer height>` + `<ChartRow flex>` — container-owned
+  vertical layout** ([PND-HEIGHT]). `height` takes a pixel number or `'auto'`
+  (measured by the same `ResizeObserver` as `width="auto"`); omitted stays the
+  classic mode where rows declare pixels. A managed container renders as a
+  **flex column** — the rows block flexes, the x-axis strip keeps its natural
+  height — and flex rows (a bare `<ChartRow>` is `flex={1}`) divide what the
+  browser says is left, then read that height back for their y-scales.
+
+  The design constraint was that **CSS does the subtraction**: the axis
+  strip's height depends on its `label`, the theme font size, the tick
+  ladder's calendar band row at the current grain, and stacked marker pills —
+  it is not a constant a caller can subtract, and every consumer who tried
+  carried a wrong one (`20` and `24` in one codebase; this site's own
+  resizable-panels recipe said `22`). It also means non-row children between
+  rows — the recipe's draggable splitter — keep taking their natural space,
+  so that recipe reduces to its drag handler: one flex row absorbing slack
+  over one fixed row the drag resizes, no `AXIS_H`, no measuring hook.
+
+  A flex row paints nothing until its first measurement, latches its last
+  non-zero height while hidden (a `display: none` tab switch keeps its
+  scales), and warns in dev when mounted in a container that never sizes it.
+  The container **warns in dev when a measured dimension stays 0** — the
+  unconstrained-parent deadlock, which for height is the _default_ (a
+  flex-column child's height is its content) rather than an edge case.
+
+  Fixed-`height` rows keep their pixels everywhere, managed or not; a
+  container with no `height` behaves exactly as before.
+
+### Fixed
+
+- **charts: the crosshair's value pill lands on the axis that measured the
+  value, in that axis's colour.** With two y-axes on one side, the pill was
+  placed by side alone — always against the plot edge — so a reading taken off
+  the **outer** axis appeared over the **inner** axis's ticks, in the cursor's
+  grey: a number pinned to a ruler that never measured it. The reticle picks one
+  series, so the resolved sample now carries its axis's gutter **offset** (the
+  reserved widths of the columns between it and the plot) and its
+  `<YAxis color>`, and the pill uses both — position _and_ ink say which of two
+  stacked scales the number is on. A single axis per side is unchanged (offset
+  `0`), as is an axis that sets no colour (the theme's cursor ink).
+
+  A pill placed further out is now **bridged back to the plot edge** by a 1px
+  connector in its own colour — the y-side twin of the crosshair's x-axis time
+  connector, without which a pill a column out reads as a value floating in a
+  gutter. It draws at half opacity because, unlike the time connector's empty
+  strip, it crosses another axis's tick labels; nothing is drawn on the innermost
+  axis, where the pill already meets the line.
+
+  `<YAxis color>` is now part of the axis's registered spec rather than
+  presentation-only, because the pill is drawn by the row's cursor overlay, not
+  by `<YAxis>`. `<Baseline indicator>` — the other on-axis value pill — got the
+  same placement fix and the same connector. New `Cursors/Crosshair` stories fan
+  the states out (`AxisColor`, `StackedAxes`, `StackedAxesColored`,
+  `StackedAxesLeft`, `StackedAxesBothSides`).
+
+  Not covered: `<YAxisIndicator>` still takes an explicit `side` alongside its
+  `axis`, so it can be pointed at a gutter its axis isn't in; reconciling those
+  two props is a public-API question, left for its own change.
+
 ## [0.62.0] — 2026-08-16
 
 ### Added

package/dist/BarChart.js

@@ -448,8 +448,8 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                     ...(id === undefined
                         ? {}
                         : {
-                            hitTest: (px, py, xScale, yScale, mode) => {
-                                const baseline = resolveBarBaseline(yScale);
+                            hitTest: (px, py, xScale, yScale, mode, baseYScale) => {
+                                const baseline = resolveBarBaseline(yScale, baseYScale);
                                 // No `gapPx` — the hit region is the bar's whole slot (its
                                 // interval width, full plot height), not the inset rect the
                                 // gap draws. See barSlotRect.
@@ -525,7 +525,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                                     },
                                 }),
                         }),
-                    draw: (ctx, xScale, yScale) => drawBars(ctx, bs, xScale, yScale, singleDrawStyle, resolveBarBaseline(yScale), gapPx, id, selection, hover, decimate, binColors, bandLadder, layerSpans),
+                    draw: (ctx, xScale, yScale, baseYScale) => drawBars(ctx, bs, xScale, yScale, singleDrawStyle, resolveBarBaseline(yScale, baseYScale), gapPx, id, selection, hover, decimate, binColors, bandLadder, layerSpans),
                 },
                 axisId: axis,
                 index,
@@ -562,7 +562,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                 ...(id === undefined
                     ? {}
                     : {
-                        hitTest: (px, py, xScale, yScale) => {
+                        hitTest: (px, py, xScale, yScale, _mode, baseYScale) => {
                             // The cap reaches the hit rect ONLY for a real stack, where the
                             // rect is what resolves *which segment* was hit and so must be
                             // the drawn one. A single-series chart has one segment per slot
@@ -576,7 +576,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                             // the fix is to make the guarantee orientation-independent rather
                             // than to narrow the claim, since the reason for the split is
                             // segment disambiguation and that is a property of the *stack*.
-                            const hit = stackAt(ss, px, py, orientation, xScale, yScale, gapPx, stackMinWidth, ss.groups.length > 1 ? maxWidthPx : undefined);
+                            const hit = stackAt(ss, px, py, orientation, xScale, yScale, gapPx, stackMinWidth, ss.groups.length > 1 ? maxWidthPx : undefined, baseYScale);
                             if (hit === null)
                                 return null;
                             const [bi, g, begin, name, value] = hit;
@@ -657,7 +657,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                             });
                         },
                     }),
-                draw: (ctx, xScale, yScale) => drawStacks(ctx, ss, orientation, xScale, yScale, stackStyle, gapPx, stackMinWidth, id, selection, hover, bandLadder, layerSpans),
+                draw: (ctx, xScale, yScale, baseYScale) => drawStacks(ctx, ss, orientation, xScale, yScale, stackStyle, gapPx, stackMinWidth, id, selection, hover, bandLadder, layerSpans, baseYScale),
             },
             axisId: axis,
             index,

package/dist/ChartContainer.d.ts

@@ -294,6 +294,48 @@ export interface ChartContainerProps {
      * render.
      */
     width?: number | 'auto';
+    /**
+     * Total height in CSS pixels, or `'auto'` to fill the available height —
+     * **the container-owned vertical layout** ([PND-HEIGHT]). Omitted means the
+     * classic mode: rows declare pixel heights and the container's height is
+     * their sum.
+     *
+     * With a height, the container renders as a **flex column** — the rows
+     * block flexes, the x-axis strip keeps its natural height at the bottom —
+     * and `<ChartRow flex>` rows (a bare `<ChartRow>` is `flex={1}`) divide
+     * whatever the browser says is left. That "whatever the browser says" is
+     * the point: the axis strip's height depends on its `label`, the theme's
+     * font size, whether the tick ladder is showing its calendar band row at
+     * the current grain, and how many marker pills stack — it is not a constant
+     * a caller could subtract, and every consumer who tried carried a wrong
+     * number (20, 24, and the recipe's 22 were all in the wild for one strip).
+     * CSS does the subtraction, so there is no number to know.
+     *
+     * A single full-bleed chart is therefore zero arithmetic:
+     *
+     * ```tsx
+     * <ChartContainer width="auto" height="auto">
+     *   <ChartRow>
+     *     <YAxis id="v" />
+     *     <Layers>…</Layers>
+     *   </ChartRow>
+     * </ChartContainer>
+     * ```
+     *
+     * Fixed-`height` rows keep their pixels inside a managed container, and
+     * non-row children (a draggable splitter between two rows) take their
+     * natural space — so the resizable-panels shape becomes one `flex` row
+     * absorbing slack over one fixed row the drag resizes, with no reserved
+     * strip constant and no measuring hook.
+     *
+     * `'auto'` measures with the same `ResizeObserver` as `width="auto"`, gates
+     * the first paint until both needed dimensions exist, latches the last
+     * non-zero size while hidden, and — because a flex-**column** child's
+     * height defaults to its content — **warns in dev when a measured dimension
+     * stays 0**: the parent needs a definite height, or the deadlock is the
+     * default.
+     */
+    height?: number | 'auto';
     /** Vertical space between rows in CSS pixels (not under the axis). Default 0. */
     rowGap?: number;
     /**
@@ -438,8 +480,38 @@ export interface ChartContainerProps {
      * The boolean form is the back-compat shorthand (`true` ⇒ `'panZoom'`,
      * `false` ⇒ `'none'`). Bound the reachable range with {@link bounds}
      * (zoom-out / pan extent) and {@link minDuration} (zoom-in floor).
+     *
+     * **This prop is about the plot only.** Gestures on the axis strips are a
+     * separate opt-in — see {@link axisPanZoom} — so turning pan/zoom on here does
+     * not silently make the axes grabbable.
      */
     panZoom?: boolean | 'none' | 'pan' | 'panZoom' | 'panZoomX' | 'panZoomY' | 'panZoomXY';
+    /**
+     * Which **axis strips** take gestures — the opt-in for grabbing an axis, and
+     * **`'none'` by default** so no existing chart changes behaviour:
+     *
+     * - `'none'` (or `false`, the **default**) — the strips are inert chrome.
+     * - `'x'` — the `<XAxis>` strip **pans on drag and zooms on wheel**, exactly as
+     *   the plot's own gestures do (same maths, same sign, same {@link bounds} /
+     *   {@link minDuration} fences). Double-click returns to the declared
+     *   {@link range}. A category axis has no continuous domain and stays inert.
+     * - `'y'` — each `<YAxis>` gutter **zooms that one axis** on drag or wheel,
+     *   double-click releasing it back to its fit. Report it to a scale UI with
+     *   {@link YAxisProps.onBoundsChange}.
+     * - `'xy'` (or `true`) — both.
+     *
+     * **Deliberately independent of {@link panZoom}**, in both directions. A chart
+     * can scale its y axes without letting the plot capture vertical drags (which
+     * would fight a selection sweep), and an interactive plot does not hand its
+     * axes gestures nobody asked for. The one thing they share is the view itself:
+     * the x strip moves the same range the plot's pan does, and reports through
+     * {@link onTimeRangeChange} the same way.
+     *
+     * The pairing to reach for on a time-series chart is
+     * `panZoom="panZoom" axisPanZoom="xy"` — drag the plot to pan, drag the x strip
+     * to pan, wheel either to zoom, and drag a y gutter to override its fit.
+     */
+    axisPanZoom?: boolean | 'none' | 'x' | 'y' | 'xy';
     /**
      * **Outer pan/zoom extent** — `[min, max]` (same units as {@link range}) the
      * view can never move outside. Panning into an edge stops there (the window