@pond-ts/charts 0.69.0 → 0.71.0

package/dist/AreaChart.js

@@ -16,8 +16,9 @@ import { useBandLadder } from './use-band-ladder.js';
  *  it to the call signature, so this reads the bound through a localized,
  *  documented shape rather than widening `drawArea`'s contract to d3-scale. */
 /**
- * The area's baseline in **data** units: the caller's `baseline` when it has a
- * finite position on this axis, else the axis floor.
+ * The area's baseline in **data** units: the caller's `baseline`, clamped into
+ * the axis domain, when it has a finite position on this axis; else the axis
+ * floor.
  *
  * The fallback is not defensive padding — it's the log case. `baseline={0}` is
  * the natural thing to write and is correct on a linear axis; on a log axis
@@ -28,14 +29,20 @@ import { useBandLadder } from './use-band-ladder.js';
  * layer's meaning ("fill from the bottom") on both scale kinds.
  */
 export function resolveAreaBaseline(baseline, yScale) {
-    const floor = domainFloor(yScale);
+    const d = yScale.domain?.();
+    const floor = d && d.length > 0 ? d[0] : 0;
     if (baseline === undefined)
         return floor;
-    return Number.isFinite(yScale(baseline)) ? baseline : floor;
-}
-function domainFloor(yScale) {
-    const d = yScale.domain?.();
-    return d && d.length > 0 ? d[0] : 0;
+    if (!Number.isFinite(yScale(baseline)))
+        return floor;
+    if (!d || d.length === 0)
+        return baseline;
+    // Clamped into the domain, as a bar's baseline is: under an explicit
+    // `<YAxis min={40}>` the default 0 is off the plot, and a fill resting
+    // there would anchor its fade (and a gap's `'fade'` connector) off-plot.
+    const lo = Math.min(d[0], d[d.length - 1]);
+    const hi = Math.max(d[0], d[d.length - 1]);
+    return Math.min(hi, Math.max(lo, baseline));
 }
 /**
  * An area draw layer: fills between a value `column` and a `baseline`, with a
@@ -45,15 +52,15 @@ function domainFloor(yScale) {
  * against its `axis`), and renders nothing to the DOM — the row draws it. The
  * fill + outline break at gaps rather than spanning them.
  *
- * Two forms via `baseline` (see {@link AreaChartProps.baseline}): omit it for
- * the **elevation** form (rest on the axis floor) or pass `0` for the
- * **above/below-axis** form (positive up, negative down). The esnet two-colour
- * traffic look composes two layers, each with its own `as` role:
+ * The fill rests on `baseline` (see {@link AreaChartProps.baseline}): **`0`
+ * by default** (positive up, negative down), any other number for a different
+ * reference level, or `'floor'` for the bottom of the plot. The esnet
+ * two-colour traffic look composes two layers, each with its own `as` role:
  *
  * ```tsx
  * <Layers>
- *   <AreaChart series={s} column="in"  baseline={0} as="in" />
- *   <AreaChart series={s} column="out" baseline={0} as="out" />
+ *   <AreaChart series={s} column="in"  as="in" />
+ *   <AreaChart series={s} column="out" as="out" />
  * </Layers>
  * ```
  */
@@ -66,6 +73,8 @@ export function AreaChart({ series, column, readout, as: semantic, axis, id, bas
     if (layers === null) {
         throw new Error('<AreaChart> must be rendered inside a <Layers>');
     }
+    // `undefined` below means "the axis floor" — the internal helpers' spelling.
+    const baseValue = baseline === 'floor' ? undefined : (baseline ?? 0);
     const cs = useMemo(() => series instanceof ValueSeries
         ? fromValueSeries(series, column)
         : fromTimeSeries(series, column), [series, column]);
@@ -141,7 +150,13 @@ export function AreaChart({ series, column, readout, as: semantic, axis, id, bas
     const entry = useMemo(() => ({
         layer: {
             as: semantic,
-            yExtent: () => areaExtent(cs, baseline),
+            // A baseline with no position on a log axis (zero, the default) is
+            // left out of the fit: the draw rests it on the floor anyway, and an
+            // extent of `[0, max]` gives the log fit no positive low end, so it
+            // would collapse the domain onto the max and clip the series.
+            yExtent: (scale) => areaExtent(cs, scale === 'log' && baseValue !== undefined && baseValue <= 0
+                ? undefined
+                : baseValue),
             // The container infers the shared x scale's kind from its layers — a
             // ValueSeries plots on a value axis, a TimeSeries on time.
             xKind: series instanceof ValueSeries ? 'value' : 'time',
@@ -155,7 +170,7 @@ export function AreaChart({ series, column, readout, as: semantic, axis, id, bas
                     sweepAxis: 'x',
                     sweepSpanOnly: true,
                     hitTest: (px, py, xScale, yScale) => {
-                        const i = areaHitIndex(cs, baseline, px, py, xScale, yScale);
+                        const i = areaHitIndex(cs, baseValue, px, py, xScale, yScale);
                         if (i === null)
                             return null;
                         return {
@@ -266,15 +281,15 @@ export function AreaChart({ series, column, readout, as: semantic, axis, id, bas
                     : { ...inStyle, color: style.spanColor, fill: style.spanColor }, 1), true, 0, plotExtentOf(ctx, xScale, yScale).width);
                 function drawAreaWith(st) {
                     return drawArea(ctx, cs, xScale, yScale, st, 
-                    // Omitted baseline rests on the axis floor (resolved late from the
-                    // scale, so it tracks the auto-fit domain); a fixed baseline is used
-                    // verbatim.
+                    // `'floor'` rests on the axis floor (resolved late from the
+                    // scale, so it tracks the auto-fit domain); a number (default 0)
+                    // is used verbatim.
                     // A log axis has no position for zero — or anything at or below
                     // it — so an explicit out-of-domain `baseline` would scale to
                     // `NaN` and poison every coordinate in the fill path. Fall back
-                    // to the axis floor, which is exactly what an omitted baseline
+                    // to the axis floor, which is exactly what `'floor'`
                     // already resolves to.
-                    resolveAreaBaseline(baseline, yScale), curveFactory, gaps, gapConnectorOpacity, decimate, bandLadder);
+                    resolveAreaBaseline(baseValue, yScale), curveFactory, gaps, gapConnectorOpacity, decimate, bandLadder);
                 }
             },
         },
@@ -288,7 +303,7 @@ export function AreaChart({ series, column, readout, as: semantic, axis, id, bas
         readoutY,
         style,
         label,
-        baseline,
+        baseValue,
         curveFactory,
         gaps,
         gapConnectorOpacity,

package/dist/BandChart.d.ts

@@ -27,6 +27,23 @@ export interface BandChartCommon<S extends SeriesSchema = SeriesSchema, VS exten
      * Denoise the underlying values with `smooth()`, not this.
      */
     curve?: Curve;
+    /**
+     * Break the envelope at each **trading-axis discontinuity** (a session / day /
+     * lunch close→open) when the container renders on a trading-time axis (a
+     * `discontinuities` / `calendar` provider). **Omitted ⇒ `false`**: the fill
+     * connects the last pre-close sample straight to the next open across the
+     * collapsed gap (a near-vertical sliver). `true` ends the fill at the close
+     * and re-starts it at the open — the intraday look, where one session's
+     * envelope shouldn't visually flow into the next. Same semantics as
+     * {@link LineChart}'s `sessionBreaks`, so a band and its centre line break in
+     * step.
+     *
+     * This is a **scale** break (driven by the axis's collapsed gaps), orthogonal
+     * to a **data** break (a NaN run on either edge, which a band always breaks
+     * at). A no-op on a continuous axis (no provider) or a provider without
+     * `boundaries`.
+     */
+    sessionBreaks?: boolean;
     /**
      * **M4 viewport decimation** (charts decimator wave). **Omitted ⇒ `true`**:
      * once the visible envelope is denser than ~2 samples per device pixel, it is
@@ -34,6 +51,8 @@ export interface BandChartCommon<S extends SeriesSchema = SeriesSchema, VS exten
      * the samples span, so it covers the same pixels from O(plot width) points.
      * Applies with a linear `curve`; pass `false` to always fill every sample, or
      * `{ threshold }` to tune. Shares {@link LineChart}'s `DecimateOption`.
+     * Composes with {@link sessionBreaks}: the break instants are folded into the
+     * pixel-column edges so no column merges two sessions' envelopes.
      */
     decimate?: DecimateOption;
     /**
@@ -92,6 +111,6 @@ export type BandChartProps<S extends SeriesSchema = SeriesSchema, VS extends Val
  * </Layers>
  * ```
  */
-export declare function BandChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, lower, upper, as: semantic, axis, curve, decimate, legend, index, }: BandChartProps<S, VS>): null;
+export declare function BandChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, lower, upper, as: semantic, axis, curve, sessionBreaks, decimate, legend, index, }: BandChartProps<S, VS>): null;
 export {};
 //# sourceMappingURL=BandChart.d.ts.map

package/dist/BandChart.js

@@ -6,6 +6,9 @@ import { resolveCurve } from './curve.js';
 import { ContainerContext, LayersContext } from './context.js';
 import { legendLabelFor, useLegendItems, } from './swatch.js';
 import { useSlotKey } from './use-slot-key.js';
+/** Stable empty boundary list — so `sessionBreaks={false}` keeps a referentially
+ *  constant array and the layer entry isn't rebuilt every render. */
+const NO_BREAKS = [];
 /**
  * A variance-band draw layer: fills the envelope between the `lower` and `upper`
  * columns of `series` (typically `rollingByColumn` percentiles), gap-aware, and
@@ -23,7 +26,7 @@ import { useSlotKey } from './use-slot-key.js';
  * </Layers>
  * ```
  */
-export function BandChart({ series, lower, upper, as: semantic, axis, curve, decimate = true, legend, index = 0, }) {
+export function BandChart({ series, lower, upper, as: semantic, axis, curve, sessionBreaks = false, decimate = true, legend, index = 0, }) {
     const container = useContext(ContainerContext);
     if (container === null) {
         throw new Error('<BandChart> must be rendered inside a <ChartContainer>');
@@ -35,6 +38,18 @@ export function BandChart({ series, lower, upper, as: semantic, axis, curve, dec
     const bs = useMemo(() => series instanceof ValueSeries
         ? bandFromValueSeries(series, lower, upper)
         : bandFromTimeSeries(series, lower, upper), [series, lower, upper]);
+    // Trading-axis session breaks: the collapse instants inside this band's span
+    // (session/day/lunch opens the axis skips). Data instants, not pixels — so the
+    // set is view-independent (pan/zoom reuse it). Only computed when opted in and
+    // the container carries a boundary-reporting discontinuity provider. The same
+    // lookup `<LineChart>` does, so a band and its centre line break identically.
+    const sessionBreakInstants = useMemo(() => {
+        const provider = container.discontinuities;
+        if (!sessionBreaks || provider?.boundaries === undefined || bs.length < 2) {
+            return NO_BREAKS;
+        }
+        return provider.boundaries(bs.x[0], bs.x[bs.length - 1]);
+    }, [sessionBreaks, container.discontinuities, bs]);
     // Styling: semantic identifier → theme band style. The single styling channel.
     const { band } = container.theme;
     const style = (semantic !== undefined ? band[semantic] : undefined) ?? band.default;
@@ -118,7 +133,7 @@ export function BandChart({ series, lower, upper, as: semantic, axis, curve, dec
                     },
                 ];
             },
-            draw: (ctx, xScale, yScale) => drawBand(ctx, bs, xScale, yScale, style, curveFactory, decimate),
+            draw: (ctx, xScale, yScale) => drawBand(ctx, bs, xScale, yScale, style, curveFactory, sessionBreakInstants, decimate),
         },
         axisId: axis,
         index,
@@ -129,6 +144,7 @@ export function BandChart({ series, lower, upper, as: semantic, axis, curve, dec
         upper,
         style,
         curveFactory,
+        sessionBreakInstants,
         decimate,
         axis,
         index,

package/dist/BoxPlot.js

@@ -139,9 +139,11 @@ export function BoxPlot({ series, lower, q1, median, q3, upper, as: semantic, ax
                 // The readout reads the box **under the cursor** (boxIndexAtTime — span
                 // containment, not nearest-by-begin which flips past a wide box's
                 // midpoint), anchored at the box **centre** `(x + xEnd) / 2`. Outside
-                // every box → no readout. Off-chart fan-in only; the in-chart flag is
-                // `cursorFlag`. `push` skips a non-finite quantile, so an absent
-                // (range-only) q1/q3/median simply doesn't read out.
+                // every box → no readout. Feeds the off-chart readout and the
+                // crosshair (its x-snap lands mid-box, its y-snap on the nearest
+                // quantile); the in-chart flag is `cursorFlag`. `push` skips a
+                // non-finite quantile, so an absent (range-only) q1/q3/median simply
+                // doesn't read out.
                 if (bx.length === 0)
                     return [];
                 const i = boxIndexAtTime(bx, x);

package/dist/Candlestick.d.ts

@@ -111,9 +111,9 @@ export interface CandlestickProps<S extends SeriesSchema> {
  * supersedes `BoxPlot shape='solid'` for OHLC (which needed a quantile remap, a
  * body precompute, two overlaid layers for green/red, and a column-name tracker).
  *
- * **Cursor.** Unlike `BoxPlot`, a candle **participates in the crosshair x-snap**
- * (it exposes plain `sampleAt`, not a consolidated `cursorFlag`), so the reticle
- * lands on candles. The readout keys on `as` and shows `close` by default; pass
+ * **Cursor.** A candle **participates in the crosshair snap** (as a box plot
+ * does), so the reticle lands on candles; unlike a box plot it has no
+ * consolidated `cursorFlag`, so the flag cursor shows a chip per value. The readout keys on `as` and shows `close` by default; pass
  * `showOHLC` for the full four-pill quote.
  *
  * ```tsx

package/dist/Candlestick.js

@@ -37,9 +37,9 @@ import { spansForLayer } from './span.js';
  * supersedes `BoxPlot shape='solid'` for OHLC (which needed a quantile remap, a
  * body precompute, two overlaid layers for green/red, and a column-name tracker).
  *
- * **Cursor.** Unlike `BoxPlot`, a candle **participates in the crosshair x-snap**
- * (it exposes plain `sampleAt`, not a consolidated `cursorFlag`), so the reticle
- * lands on candles. The readout keys on `as` and shows `close` by default; pass
+ * **Cursor.** A candle **participates in the crosshair snap** (as a box plot
+ * does), so the reticle lands on candles; unlike a box plot it has no
+ * consolidated `cursorFlag`, so the flag cursor shows a chip per value. The readout keys on `as` and shows `close` by default; pass
  * `showOHLC` for the full four-pill quote.
  *
  * ```tsx
@@ -94,8 +94,8 @@ export function Candlestick({ series, open = 'open', high = 'high', low = 'low',
                 // The readout reads the candle **under the cursor** (containment span,
                 // not nearest-by-begin), anchored at the slot centre. Outside every
                 // candle → no readout. No `cursorFlag`: the samples flow through the
-                // normal per-series tracker path, which is also what keeps the candle
-                // in the crosshair x-snap (BoxPlot's cursorFlag opts out of both).
+                // normal per-series tracker path (BoxPlot's cursorFlag takes its
+                // values out of the per-series dots and chips).
                 if (ohlc.length === 0)
                     return [];
                 const i = ohlcIndexAtTime(ohlc, time);

package/dist/ChartContainer.d.ts

@@ -1,9 +1,8 @@
 import { type ReactNode } from 'react';
 import { type DiscontinuityProvider, type TradingCalendarLike } from './tradingTimeScale.js';
-import { Sequence, BoundedSequence } from 'pond-ts';
 import type { TimeRange } from 'pond-ts';
-import { type AnnotationKind, type CreateSpec, type CursorMode, type TrackerInfo, type DrawStatsFrame } from './context.js';
-import { type AxisFormat, type CursorFormat } from './format.js';
+import { type AnnotationKind, type CreateSpec, type TrackerInfo, type DrawStatsFrame } from './context.js';
+import { type AxisFormat } from './format.js';
 import { type ChartTheme } from './theme.js';
 export interface ChartContainerProps {
     /**
@@ -210,7 +209,7 @@ export interface ChartContainerProps {
      * (`TimeZone`) places these ticks and cuts `Sequence.calendar` buckets, so
      * `Sequence.calendar('day', { timeZone })` and `<ChartContainer timeZone>`
      * given the same zone put a bucket edge and its tick on one instant.
-     * Function formatters (`timeFormat`, `cursorFormat`) still receive epoch ms;
+     * Function formatters (`timeFormat`, a cursor's `format`) still receive epoch ms;
      * read the resolved zone from the chart context. An unknown id throws
      * `RangeError`. Only affects a **time** axis.
      */
@@ -387,93 +386,10 @@ export interface ChartContainerProps {
      *
      * **Omit or pass `null`** (equivalent) for no controlled position — a hovered
      * chart still tracks its pointer, a non-hovered one shows nothing. To force a
-     * chart to *never* show a cursor, use `cursor="none"`, not `trackerPosition`.
-     * See {@link onTrackerChanged}.
+     * chart to *never* show a cursor, mount no cursor component, rather than
+     * clearing `trackerPosition`. See {@link onTrackerChanged}.
      */
     trackerPosition?: number | null;
-    /**
-     * In-chart cursor presentation — the default for all rows (a row may override
-     * via `<ChartRow cursor>`). **Default `'line'`** — the synced vertical line,
-     * with values surfaced *outside* the chart via {@link onTrackerChanged}.
-     * `'point'` / `'inline'` / `'flag'` add per-series marks; `'none'` hides it.
-     * `'region'` shades the bucket under the pointer (needs {@link cursorSequence}).
-     * See {@link CursorMode}.
-     *
-     * @deprecated Mount a **cursor component** instead — `<LineCursor>` /
-     * `<PointCursor>` / `<InlineCursor>` / `<FlagCursor>` / `<CrosshairCursor>` /
-     * `<RangeCursor>` as a child of the container (or inside a `<ChartRow>` for
-     * the per-row override); mount nothing for `'none'`. This prop keeps working
-     * for one more minor by synthesizing the equivalent preset internally; a
-     * mounted cursor component overrides it. See `docs/rfcs/interaction.md` §9.
-     */
-    cursor?: CursorMode;
-    /**
-     * The bucketing for `cursor="region"` — the interval highlighted under the
-     * pointer. A pond {@link Sequence} (duration or calendar-aware —
-     * `Sequence.every('1d')`, `Sequence.calendar('month')`) is realized over the
-     * current view; a {@link BoundedSequence} (e.g. a `TradingCalendar`'s
-     * `sessionSequence()` / `barSequence()`) is used as-is, so the band can track
-     * whole **sessions**. Either way the band maps through `xScale`, so on a
-     * trading-time axis the closed part of the bucket collapses. Ignored unless
-     * `cursor="region"`.
-     *
-     * **Time axis only.** A bucket is a *time* interval, so the region cursor is
-     * gated to a **time** x-axis — on a **value** axis (a horizontal histogram, a
-     * value-keyed chart) it's a no-op (highlighting a value *band* on a horizontal
-     * histogram would be a different, y-oriented cursor).
-     *
-     * **Pass a stable reference.** The buckets are memoized on this value + the
-     * view range; a `Sequence`/`BoundedSequence` rebuilt inline every render
-     * re-realizes the buckets on each pointer move (harmless for a coarse
-     * day/session sequence, wasteful for a fine one over a wide view) — hoist it or
-     * `useMemo` it.
-     *
-     * @deprecated Use `<RangeCursor sequence={…}>` — the prop moved onto the
-     * component that uses it, where it is no longer mode-conditional. Works for
-     * one more minor; a mounted `<RangeCursor>`'s sequence wins over this.
-     */
-    cursorSequence?: Sequence | BoundedSequence;
-    /**
-     * Makes the `region` cursor **draggable**: drag across the plot and the band
-     * extends **bucket by bucket** (snapping to `cursorSequence` points); on
-     * release this fires **once** with the selected `[lo, hi]` span, and the cursor
-     * reverts to the single-bucket highlight (it does not keep the range). Typical
-     * use — zoom the view to the returned span (the container doesn't zoom itself;
-     * that's the consumer's call), or map it onto a data subscription's range params.
-     *
-     * The span is a **neutral numeric pair in axis units** — epoch ms on a **time**
-     * axis, the axis value (strike, distance, …) on a **value** axis — mirroring the
-     * polymorphic `range` input. A time consumer that wants a `TimeRange` builds one
-     * from the pair.
-     *
-     * With **no `cursorSequence`** the region cursor is the degenerate case — it
-     * renders as a **line** on hover and the drag is **freeform** (raw `[lo, hi]`, no
-     * bucket snapping); the same callback fires on release. Bucket snapping needs a
-     * `cursorSequence`, which is **time-axis only** (a time interval over a value
-     * domain is meaningless), so a **value** axis is always freeform. No-op unless
-     * `cursor="region"` on a **time** or **value** x-axis (a **category** axis is
-     * excluded — an ordinal-slot select is a different gesture).
-     *
-     * @deprecated Use `<RangeCursor onDragRelease>` — the drag moved onto the
-     * component, and the payload becomes `{ x: [lo, hi] }` (a {@link RangeSpan},
-     * forward-compatible with the 2-D drag's optional `y`) instead of the bare
-     * pair. Works for one more minor; a mounted `<RangeCursor onDragRelease>`
-     * takes over the gesture.
-     */
-    onRegionSelect?: (range: readonly [number, number]) => void;
-    /**
-     * Which modifier a region-drag needs — set `'shift'` when you also enable
-     * **pan** (`panZoom="pan"` or `"panZoom"`) and want **plain drag to pan,
-     * shift-drag to select**. It's only enforced while pan is enabled (with pan
-     * off there's no gesture conflict, so shift is optional — either drag
-     * selects). **Omitted** ⇒ a region-drag
-     * **preempts** pan (drag always selects; document that precedence for users).
-     * Wheel-zoom is unaffected in every case.
-     *
-     * @deprecated Use `<RangeCursor dragModifier>` — the prop moved onto the
-     * component alongside `onDragRelease`. Works for one more minor.
-     */
-    regionSelectModifier?: 'shift';
     /**
      * Fires on pointer move with the hovered time + every series' value there (so
      * you can render a readout outside the chart), and `null` on leave.
@@ -561,30 +477,6 @@ export interface ChartContainerProps {
     onTimeRangeChange?: (range: [number, number]) => void;
     /** Zoom-in floor — the minimum visible duration in ms. Default `1`. */
     minDuration?: number;
-    /**
-     * Show the cursor's time atop the in-chart readout (when a row's `cursor` draws
-     * one). **Default `false`.** Formatted by {@link timeFormat} to match the time
-     * axis.
-     *
-     * @deprecated Use `showTime` on the mounted cursor component
-     * (`<LineCursor showTime>` / `<FlagCursor showTime>` / …). Works for one
-     * more minor via the shim.
-     */
-    cursorTime?: boolean;
-    /**
-     * `cursor="crosshair"` reticle **y** snapping. **Default `true`** — the
-     * crosshair centres on the nearest **data point** (the horizontal line snaps to
-     * that sample's value). `false` — the horizontal line + centre follow the
-     * pointer **y** freely, the value read as `yScale.invert(pointerY)`. Either way
-     * the vertical line snaps its **x** to the data grid (so the time readout is
-     * clean), and both draw a full-height dashed vertical + full-width dashed
-     * horizontal line.
-     *
-     * @deprecated Use `<CrosshairCursor snap={…}>` — the prop moved onto the
-     * component, where it is no longer mode-conditional. Works for one more
-     * minor via the shim.
-     */
-    crosshairSnap?: boolean;
     /**
      * Enter **annotation-edit mode**: suppresses the data cursor and makes editable
      * annotations (those given an `onChange`) interactive — hovering one reveals its
@@ -634,43 +526,10 @@ export interface ChartContainerProps {
      * **owns the labels**, so it opts the axis out of the `dateStyle` ladder
      * (flat / stacked) by design. **Omitted ⇒ the flat/stacked date style.** To
      * shape only the cursor readout while keeping a date style, use
-     * {@link cursorFormat} instead. (For back-compat this also shapes the readout
-     * when `cursorFormat` is absent.)
+     * a mounted cursor's `format` (e.g. `<CrosshairCursor format>`) instead. (For
+     * back-compat this also shapes the readout when no cursor `format` is set.)
      */
     timeFormat?: AxisFormat;
-    /**
-     * The **cursor / marker readout** format — the crosshair x pill, marker
-     * axis indicators, and annotation auto-labels — **independent of the tick
-     * labels** on both axis kinds: it does **not** disqualify the `dateStyle`
-     * ladder (time), and it never moves the tick labels (value). It beats an
-     * explicit `<XAxis format>` for the **readout only** — pill precedence is
-     * `cursorFormat → axis format → container` — so terse ticks can pair with a
-     * precise readout (`+2.0σ` labels, `+1.83σ` pill).
-     *
-     * **Omitted ⇒ the axis's own formatter.** On a time axis that default is
-     * grain-aware: the readout formats at the axis's granularity, so a
-     * day-or-coarser axis reads a **date** (never a time-of-day) and a sub-day
-     * axis reads date + clock — a daily bar at a foreign-tz midnight no longer
-     * renders as `02 AM`. On a value axis it is the tick formatter
-     * ({@link timeFormat}-shaped, else the d3 default).
-     *
-     * A d3 specifier **string** formats uniformly (time specifier on a time
-     * axis, number specifier on a value axis); a **function**
-     * `(value, { grain, defaultText }) => string` receives the axis's resolved
-     * coarse {@link TimeGrain} (`undefined` on a value axis) and the default
-     * readout text, so it can branch on the zoom level and pass `defaultText`
-     * through for grains it doesn't override (no re-deriving the grain from the
-     * range). See {@link CursorFormat}. This is the independent readout channel;
-     * {@link timeFormat} owns the labels. (A category axis reads names, and a
-     * `transform`ed axis's pill speaks its derived unit — neither consults
-     * `cursorFormat`.)
-     *
-     * @deprecated Use `format` on the mounted cursor (`<CrosshairCursor
-     * format={…}>`) — it feeds the same shared readout channel (marker
-     * indicators and annotation auto-labels included). Works for one more
-     * minor; a mounted cursor's `format` wins over this.
-     */
-    cursorFormat?: CursorFormat;
     /**
      * Label the x axis as **offsets from a zero point** instead of absolute
      * values — the *duration* (elapsed-time) axis. A time axis reads
@@ -690,7 +549,7 @@ export interface ChartContainerProps {
      * and so does the cursor pill (one grain finer, as ever: `00:05:12`).
      *
      * This is a **labelling** mode, not a data transform: `range`, an annotation's
-     * `at`, an `onRegionSelect` span, `trackerPosition` are all still absolute
+     * `at`, a `<RangeCursor onDragRelease>` span, `trackerPosition` are all still absolute
      * axis units. Ignored on a category axis. An explicit `timeFormat` /
      * `<XAxis format>` still wins — on a time axis a d3 *time* specifier can only
      * describe an instant, so it labels the underlying wall clock (the lever for