@pond-ts/charts 0.70.0 → 0.71.0

package/dist/HeatMap.d.ts

@@ -161,9 +161,9 @@ export interface HeatMapProps<S extends SeriesSchema = SeriesSchema, VS extends
  * theme, and the M5 "theme tokens optional-with-default" gate has to land
  * first. Borrowing defers that decision instead of pre-empting it.
  *
- * **Pair it with `<ChartContainer cursor="none">`.** The container's default is
- * the shared vertical line, and on a grid that is a *second, weaker* cursor
- * competing with the one that already works: the cell under the pointer takes an
+ * **Mount no cursor component with it.** A `<LineCursor>` draws the shared
+ * vertical line, and on a grid that is a *second, weaker* cursor competing
+ * with the one that already works: the cell under the pointer takes an
  * outline, which says both axes at once. The line says only x, and a heat map's
  * x position is rarely the question. The pointer's own crosshair shape plus the
  * cell outline is the whole affordance.

package/dist/HeatMap.js

@@ -61,9 +61,9 @@ function marksOf(set) {
  * theme, and the M5 "theme tokens optional-with-default" gate has to land
  * first. Borrowing defers that decision instead of pre-empting it.
  *
- * **Pair it with `<ChartContainer cursor="none">`.** The container's default is
- * the shared vertical line, and on a grid that is a *second, weaker* cursor
- * competing with the one that already works: the cell under the pointer takes an
+ * **Mount no cursor component with it.** A `<LineCursor>` draws the shared
+ * vertical line, and on a grid that is a *second, weaker* cursor competing
+ * with the one that already works: the cell under the pointer takes an
  * outline, which says both axes at once. The line says only x, and a heat map's
  * x position is rarely the question. The pointer's own crosshair shape plus the
  * cell outline is the whole affordance.

package/dist/Layers.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { Children, Fragment, isValidElement, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
 import { Canvas } from './Canvas.js';
 import { drawGrid, drawDividers, dividerAlphas, thinPixels } from './grid.js';
-import { bandRect, regionSpan } from './tracker.js';
+import { bandRect, categorySlots, regionSpan } from './tracker.js';
 import { effectiveCursorEntries, gestureOwner } from './cursors.js';
 import { renderBrushBand, renderBrushRect, resolveBrushClaim, resolveRangeDrag, warnSweepShadowsRangeDrag, } from './brush.js';
 import { resolveSelection } from './select.js';
@@ -443,12 +443,10 @@ export function Layers({ children }) {
     //
     // - `blockPreview` — the fact ("this row previews blocks"). It also scopes
     //   the resting hover to the snap block (handlePointerMove).
-    // - `restingBand` — the brush band is this row's resting CURSOR, replacing
-    //   the shim's un-asked-for `'line'` default. Any *explicitly chosen*
-    //   cursor still wins: a mounted component, or a legacy `cursor` string the
-    //   consumer actually set — both register non-`implicit` entries and keep
-    //   their own slots (a mounted `<RangeCursor>` already draws this same
-    //   band; a `<CrosshairCursor>` keeps its crosshair).
+    // - `restingBand` — the brush band is this row's resting CURSOR when no
+    //   cursor component is mounted for the row. A mounted cursor still wins
+    //   and keeps its own slots (a mounted `<RangeCursor>` already draws this
+    //   same band; a `<CrosshairCursor>` keeps its crosshair).
     //
     // Which of the two the row gets is the TOPMOST sweep-capable layer's
     // business (§8's z-order rule again, and the same rule `beginTopmostSweep`
@@ -466,13 +464,14 @@ export function Layers({ children }) {
         !rectPreview &&
         !topmostSweepSpanOnly(layers) &&
         layers.some((e) => e.layer.beginSweep !== undefined);
-    // The resting brush replaces the implicit cursor either way; only its SHAPE
-    // differs. A 2-D row gets no band: its snap block is a whole x column while
+    // The resting brush is the row's cursor when no cursor component is
+    // mounted for it (a mounted cursor was asked for, so it wins); only its
+    // SHAPE differs. A 2-D row gets no band: its snap block is a whole x column while
     // a drag there captures a rect, so a band would advertise a set the gesture
     // never selects (the same reason the block hover opts out).
     const restingBrush = (blockPreview || rectPreview) &&
         !editingActive &&
-        effectiveCursorEntries(container.cursors, row.rowKey).every((e) => e.implicit === true);
+        effectiveCursorEntries(container.cursors, row.rowKey).length === 0;
     // …and a **transposed** row gets none yet: the resting block preview is
     // resolved from the shared x buckets, so a y-cutting row would draw a band
     // over a column its drag can never select. Suppressed rather than
@@ -484,6 +483,7 @@ export function Layers({ children }) {
         ? []
         : effectiveCursorEntries(container.cursors, row.rowKey), [editingActive, sweeping, restingBrush, container.cursors, row.rowKey]);
     const wantsSamples = cursorEntries.some((e) => e.wants.samples);
+    const wantsReticle = cursorEntries.some((e) => e.wants.reticle);
     const wantsFlags = cursorEntries.some((e) => e.wants.flags);
     const wantsBand = cursorEntries.some((e) => e.wants.band);
     const wantsPointer = cursorEntries.some((e) => e.wants.pointer);
@@ -502,15 +502,21 @@ export function Layers({ children }) {
     // slides under it. Empty when not hovering — or when no effective cursor
     // declared a need — so the data canvas is never touched and a line-only
     // cursor never pays the per-layer walk.
-    const trackerSamples = useMemo(() => {
-        if (cursorTime === null || !wantsSamples)
-            return [];
-        const out = [];
+    //
+    // Two lists from one walk. `samples` feeds the per-series marks (dots,
+    // chips), so a layer with a consolidated flag (BoxPlot) is left out — it
+    // renders that flag instead (its values still fan to the off-chart readout
+    // via sampleAt on the container). `reticle` feeds the crosshair's pick,
+    // which lands on ONE value, so a box's quantiles are candidates there
+    // ([PND-BOXPLT]).
+    const { samples: trackerSamples, reticle: reticleSamples } = useMemo(() => {
+        if (cursorTime === null || (!wantsSamples && !wantsReticle))
+            return { samples: [], reticle: [] };
+        const samples = [];
+        const reticle = [];
         for (const entry of layers) {
-            // A layer with a consolidated flag (BoxPlot) renders that, not per-sample
-            // dots/chips — skip it here (its values still fan to the off-chart readout
-            // via sampleAt on the container).
-            if (entry.layer.cursorFlag)
+            const toSamples = wantsSamples && !entry.layer.cursorFlag;
+            if (!toSamples && !wantsReticle)
                 continue;
             const axisId = entry.axisId ?? defaultAxisId;
             const yScale = yScales.get(axisId);
@@ -526,9 +532,12 @@ export function Layers({ children }) {
             const axisOffset = axisOffsets.get(axisId) ?? 0;
             const axisColor = axisColors.get(axisId);
             for (const s of entry.layer.sampleAt(cursorTime)) {
-                out.push({
+                const r = {
                     px: xScale(s.x),
                     py: yScale(s.value),
+                    x: s.x,
+                    value: s.value,
+                    ...(s.readout !== undefined ? { readout: s.readout } : {}),
                     axisId,
                     side,
                     axisOffset,
@@ -536,13 +545,18 @@ export function Layers({ children }) {
                     formatted: fmt(s.value),
                     color: s.color,
                     label: s.label,
-                });
+                };
+                if (toSamples)
+                    samples.push(r);
+                if (wantsReticle)
+                    reticle.push(r);
             }
         }
-        return out;
+        return { samples, reticle };
     }, [
         cursorTime,
         wantsSamples,
+        wantsReticle,
         layers,
         yScales,
         formats,
@@ -631,7 +645,7 @@ export function Layers({ children }) {
     // (#508 item 7). Trusted human-paced input hides this (React flushes
     // trusted discrete events synchronously); the ref is correct under both.
     // The release sink rides the ref too, so what fires is what the press
-    // resolved — a `<RangeCursor onDragRelease>` or the legacy `onRegionSelect`.
+    // resolved — the `<RangeCursor onDragRelease>`.
     const rangeDragRef = useRef(null);
     // The live sweep session (a mounted <MultiSelector> — RFC §8 / A7.7): the
     // anchor + the topmost capable layer's per-drag session + the container's
@@ -841,7 +855,7 @@ export function Layers({ children }) {
         const swept = sweepGesture !== null ? beginTopmostSweep(c, r) : null;
         const drag = resolveRangeDrag(c, gestureOwner(effectiveCursorEntries(c.cursors, r.rowKey)));
         // ONE brush recognizer arbitrates every drag claim — annotation-create,
-        // the sweep, the range drag (component or legacy), pan — in a
+        // the sweep, the range drag, pan — in a
         // documented order (RFC A1.5 / A2.7; see brush.tsx). This handler only
         // routes.
         const claim = resolveBrushClaim({
@@ -895,8 +909,7 @@ export function Layers({ children }) {
             }
             return;
         }
-        // Range drag (a drag-enabled <RangeCursor>, or the legacy
-        // `cursor="region"` + `onRegionSelect`): anchor the selection at the
+        // Range drag (a drag-enabled <RangeCursor>): anchor the selection at the
         // press; the band then extends as the pointer moves (bucket by bucket
         // with a sequence, freeform without), and release commits the span to
         // whichever sink the claim resolved. Continuous x only, and gated
@@ -1119,8 +1132,8 @@ export function Layers({ children }) {
             const t = +c.xScale.invert(rawX);
             for (let i = r.layers.length - 1; i >= 0; i -= 1) {
                 const entry = r.layers[i];
-                if (entry.layer.cursorFlag)
-                    continue;
+                // Box plots included ([PND-BOXPLT]): a box's samples sit at its
+                // centre, so the reticle lands mid-box.
                 const s = entry.layer.sampleAt(t)[0];
                 if (s !== undefined) {
                     px = c.xScale(s.x);
@@ -1269,7 +1282,7 @@ export function Layers({ children }) {
         }
         // End a range drag: commit the anchor→pointer span as a one-shot range —
         // to the sink the press resolved (`<RangeCursor onDragRelease>`'s
-        // `{ x: [lo, hi] }`, or the legacy `onRegionSelect` bare pair) — then
+        // `{ x: [lo, hi] }`) — then
         // clear the anchor: the cursor **reverts** to the single-bucket
         // highlight (it does not keep the range). The anchor is read from the
         // ref, never the state mirror — under a batched pointer stream the
@@ -1574,10 +1587,9 @@ export function Layers({ children }) {
     const formattedTime = wantsTime && cursorTime !== null
         ? (container.formatReadout ?? formatTime)(cursorTime)
         : null;
-    // The range cursor's band (continuous x axis — time or value): shade the
-    // span under the pointer. With snap buckets (a sequence / a histogram's
+    // The range cursor's band: shade the span under the pointer. With snap buckets (a sequence / a histogram's
     // bins) the band snaps to the bucket (and extends bucket by bucket under a
-    // legacy drag); with none it's the **freeform** case — a bare hover draws a
+    // drag); with none it's the **freeform** case — a bare hover draws a
     // plain line (`bandLine`), a drag shades the raw `[anchor, pointer]`. Edges
     // map through `xScale`, so on a trading-time axis the band crops to live time.
     // A live <MultiSelector> sweep shades the same band — and so does its
@@ -1594,12 +1606,27 @@ export function Layers({ children }) {
     // not ALSO shade an x band: `sweeping` alone would resolve one from the
     // pointer's bucket and lay a full-height column across the horizontal band
     // the drag is actually drawing.
-    const bandActive = (wantsBand &&
-        (container.xKind === 'time' || container.xKind === 'value')) ||
+    //
+    // A `<RangeCursor>` on a **category** axis shades the slot under the
+    // pointer ([PND-ORDCURSOR]). Its buckets are the unit slots `[i, i+1)` —
+    // a vertical bar layer already publishes exactly those as `cursorBuckets`;
+    // a category row with no bar layer (a heat map) gets them from the band
+    // scale's domain (`categoryBandSlots`). The range *drag* stays off there
+    // (`resolveRangeDrag`): it reports a numeric span, and a category chart
+    // selects slots, which is `<MultiSelector>`'s gesture.
+    // The slot fallback is for the cursor's band only: a sweep or the resting
+    // brush keeps reading `cursorBuckets` alone, exactly as before. Memoized on
+    // the scale, so a pointer move doesn't rebuild the slots.
+    const categoryBandSlots = useMemo(() => wantsBand &&
+        container.xKind === 'category' &&
+        container.cursorBuckets === undefined
+        ? categorySlots(xScale.domain())
+        : undefined, [wantsBand, container.xKind, container.cursorBuckets, xScale]);
+    const bandActive = wantsBand ||
         (sweeping && sweepRect === null && sweepBandY === null) ||
         restingBand;
     const band = bandActive && cursorTime !== null
-        ? bandRect(container.cursorBuckets ?? [], cursorTime, (v) => xScale(v), plotWidth, container.regionAnchor ?? undefined)
+        ? bandRect(container.cursorBuckets ?? categoryBandSlots ?? [], cursorTime, (v) => xScale(v), plotWidth, container.regionAnchor ?? undefined)
         : null;
     // Degenerate range cursor (no buckets, not mid-drag): a plain vertical
     // line. Deliberately NOT extended to `restingBand` — the resting preview is
@@ -1627,6 +1654,7 @@ export function Layers({ children }) {
         rowKey: row.rowKey,
         hoveredRowKey: cursor.cursorRowKey,
         samples: trackerSamples,
+        reticleSamples,
         flags: trackerFlags,
         pointer,
         band,
@@ -1642,6 +1670,28 @@ export function Layers({ children }) {
         theme: container.theme,
         xAxis: null,
     };
+    // The crosshair's snap report (`<CrosshairCursor onSnap>`). The snap owner is
+    // read from the unfiltered entries, so a row whose cursor is hidden (editing,
+    // a sweep, the resting brush) still reports "nothing snapped" rather than
+    // leaving the consumer on a stale point. Only the hovered row reports a
+    // point; the other rows report `null` — unless the hovered row has the same
+    // owner, in which case it speaks for all of them (two rows calling at once
+    // would flap). The cursor dedupes, so repeated calls are free.
+    const snapOwner = gestureOwner(effectiveCursorEntries(container.cursors, row.rowKey));
+    const hoveredRowKey = cursor.cursorRowKey;
+    useEffect(() => {
+        const report = snapOwner?.reportSnap;
+        if (report === undefined)
+            return;
+        if (hoveredRowKey === row.rowKey) {
+            report(cursorEntries.includes(snapOwner) ? cursorRenderFrame : null);
+        }
+        else if (hoveredRowKey === null ||
+            gestureOwner(effectiveCursorEntries(container.cursors, hoveredRowKey)) !==
+                snapOwner) {
+            report(null);
+        }
+    });
     // Cross-row guide lines: the x-positions of annotations on the OTHER rows
     // (markers + region edges), so a mark on one row reads against this row's data +
     // the shared x axis. A mark's own row skips itself; baselines cast no vertical

package/dist/XAxis.js

@@ -667,6 +667,7 @@ export function XAxis({ format, label, side = 'bottom', height, ticks: customTic
                         rowKey: null,
                         hoveredRowKey: cursor.cursorRowKey,
                         samples: [],
+                        reticleSamples: [],
                         flags: [],
                         pointer: null,
                         band: null,

package/dist/area.d.ts

@@ -27,8 +27,9 @@ export declare function fillAffineArea(ctx: CanvasRenderingContext2D, xs: Float6
  * The `[min, max]` vertical extent an area occupies — the finite values of
  * `cs.y` widened to include `baseline`, since the fill spans from each value to
  * the baseline (so the baseline must be in-domain or the fill clips). `null` if
- * no value is finite. When `baseline` is `undefined` the area rests on the
- * axis's own lower bound (resolved later), so only the values constrain the
+ * no value is finite. When `baseline` is `undefined` (`<AreaChart
+ * baseline="floor">`) the area rests on the axis's own lower bound (resolved
+ * later), so only the values constrain the
  * domain — matching {@link yExtent}.
  *
  * NaN values (the gap signal) are ignored, so a coast doesn't drag the domain.
@@ -41,10 +42,10 @@ export declare function areaExtent(cs: ChartSeries, baseline: number | undefined
  *
  * Two forms, selected by `baseline`:
  *
- * - **Elevation** (`baseline` = the axis lower bound, supplied as the resolved
- *   `baselineValue`): the line sits above the baseline, the shade grades down
+ * - **Floor** (`<AreaChart baseline="floor">` — the axis lower bound,
+ *   supplied as the resolved `baselineValue`): the line sits above the baseline, the shade grades down
  *   from it — the estela elevation look.
- * - **Above/below axis** (`baseline` = `0`): positive values fill up, negative
+ * - **Above/below a level** (`baseline` = `0`, the default, or any number): positive values fill up, negative
  *   fill down (d3's `area` handles the zero crossing in one path). The gradient
  *   is anchored at the baseline pixel so each side grades *away* from the axis —
  *   opaque at the line, transparent at the axis — in both directions. Compose

package/dist/area.js

@@ -89,8 +89,9 @@ export function fillAffineArea(ctx, xs, ys, baselinePx, ax, ay) {
  * The `[min, max]` vertical extent an area occupies — the finite values of
  * `cs.y` widened to include `baseline`, since the fill spans from each value to
  * the baseline (so the baseline must be in-domain or the fill clips). `null` if
- * no value is finite. When `baseline` is `undefined` the area rests on the
- * axis's own lower bound (resolved later), so only the values constrain the
+ * no value is finite. When `baseline` is `undefined` (`<AreaChart
+ * baseline="floor">`) the area rests on the axis's own lower bound (resolved
+ * later), so only the values constrain the
  * domain — matching {@link yExtent}.
  *
  * NaN values (the gap signal) are ignored, so a coast doesn't drag the domain.
@@ -126,10 +127,10 @@ export function areaExtent(cs, baseline) {
  *
  * Two forms, selected by `baseline`:
  *
- * - **Elevation** (`baseline` = the axis lower bound, supplied as the resolved
- *   `baselineValue`): the line sits above the baseline, the shade grades down
+ * - **Floor** (`<AreaChart baseline="floor">` — the axis lower bound,
+ *   supplied as the resolved `baselineValue`): the line sits above the baseline, the shade grades down
  *   from it — the estela elevation look.
- * - **Above/below axis** (`baseline` = `0`): positive values fill up, negative
+ * - **Above/below a level** (`baseline` = `0`, the default, or any number): positive values fill up, negative
  *   fill down (d3's `area` handles the zero crossing in one path). The gradient
  *   is anchored at the baseline pixel so each side grades *away* from the axis —
  *   opaque at the line, transparent at the axis — in both directions. Compose
@@ -509,7 +510,13 @@ export function areaHitIndex(cs, baseline, px, py, xScale, yScale, tolerance = T
     // slope and not a staircase. Guard the degenerate same-pixel pair.
     const t = xi === xj ? 0 : (px - xj) / (xi - xj);
     const edgePx = yScale(yj + (yi - yj) * Math.max(0, Math.min(1, t)));
-    const basePx = baseline === undefined ? baselinePxFromScale(yScale) : yScale(baseline);
+    // A baseline with no position on this axis (zero on a log axis) falls back
+    // to the axis floor — the same resolution the draw uses. Without it `basePx`
+    // is NaN, both range checks below are false, and every point hits.
+    const fixedPx = baseline === undefined ? NaN : yScale(baseline);
+    const basePx = Number.isFinite(fixedPx)
+        ? fixedPx
+        : baselinePxFromScale(yScale);
     const top = Math.min(edgePx, basePx) - tolerance;
     const bottom = Math.max(edgePx, basePx) + tolerance;
     if (py < top || py > bottom)

package/dist/axis-events.d.ts

@@ -44,11 +44,11 @@ export interface AxisMouseEvent {
      * elsewhere.
      *
      * Precisely: it is the axis's **readout** channel, the one the cursor pill
-     * uses — so it always agrees with the pill at that pixel, and a container
-     * `cursorFormat` shapes it exactly as it shapes the pill. That is the
-     * documented precedence (`cursorFormat` → axis `format` → container), and it
+     * uses — so it always agrees with the pill at that pixel, and a cursor
+     * `format` shapes it exactly as it shapes the pill. That is the
+     * documented precedence (cursor `format` → axis `format` → container), and it
      * is the one case where `label` can read differently from the tick text: a
-     * chart with a precise `cursorFormat` over terse ticks gets the precise form
+     * chart with a precise cursor `format` over terse ticks gets the precise form
      * here, which is the readout it asked for.
      */
     label: string;

package/dist/brush.d.ts

@@ -28,8 +28,7 @@ import type { ContainerFrame, CursorEntry, ResolvedCursorFrame } from './context
  *    `DRAG_SLOP` — a plain click stays a click and selects one mark (§8.1:
  *    the two are separated by movement, not modifier).
  * 3. **The range drag** ({@link resolveRangeDrag}) — a drag-enabled
- *    `<RangeCursor>` in the hovered row's effective cursor set, else the
- *    legacy `cursor="region"` + `onRegionSelect` container props. Preempts
+ *    `<RangeCursor>` in the hovered row's effective cursor set. Preempts
  *    pan — unless a `dragModifier` is declared **and pan is enabled**, in
  *    which case a plain drag falls through to pan and only a modifier-held
  *    drag brushes. (With pan off there is no gesture to share, so the
@@ -45,9 +44,8 @@ import type { ContainerFrame, CursorEntry, ResolvedCursorFrame } from './context
  * marks), which is A1.5's "one brush engine, two components".
  */
 /** What a completed range drag calls with the released `[start, end]`
- *  (axis units, `start ≤ end`). Resolved once at pointer-down — the component
- *  path wraps `onDragRelease` (the `{ x }` payload), the legacy path wraps
- *  `onRegionSelect` (the bare pair). */
+ *  (axis units, `start ≤ end`). Resolved once at pointer-down, wrapping the
+ *  `<RangeCursor>`'s `onDragRelease` (the `{ x }` payload). */
 export interface RangeDrag {
     readonly release: (start: number, end: number) => void;
     /** The modifier the drag needs — only enforced while pan is enabled. */
@@ -55,23 +53,17 @@ export interface RangeDrag {
 }
 /**
  * Resolve whether a press could start a **range drag**, and who gets the
- * released span. Two sources, component first:
- *
- * 1. **A mounted `<RangeCursor>`** — the hovered row's effective
- *    gesture-owning cursor (`owner`), when it carries `onDragRelease` and is
- *    not frozen (`enableDrag={false}` — the OFF switch, which also suppresses
- *    the legacy fallback: the consumer wired the new API and asked for no
- *    gesture). A `<RangeCursor>` without `onDragRelease` has nothing to fire,
- *    so it does not claim — the legacy props keep working underneath it
- *    during the deprecation window (exactly the step-2 behaviour).
- * 2. **The legacy container props** — `cursor="region"` + `onRegionSelect`
- *    (+ `regionSelectModifier`), byte-for-byte today's semantics, including
- *    the bare-pair payload.
+ * released span: the hovered row's effective gesture-owning cursor (`owner`),
+ * when it is a `<RangeCursor>` carrying `onDragRelease` and is not frozen
+ * (`enableDrag={false}` — the OFF switch). A `<RangeCursor>` without
+ * `onDragRelease` has nothing to fire, so it does not claim.
  *
  * Continuous x only (time or value): a category axis has no span to drag
- * (an ordinal-slot select is a different gesture), so both paths gate on it.
+ * (an ordinal-slot select is `<MultiSelector>`'s gesture). The range cursor's
+ * hover band still draws there — over the slot — and the container dev-warns
+ * that the drag is off ([PND-ORDCURSOR]).
  */
-export declare function resolveRangeDrag(c: Pick<ContainerFrame, 'cursor' | 'onRegionSelect' | 'regionSelectModifier' | 'xKind'>, owner: CursorEntry | undefined): RangeDrag | null;
+export declare function resolveRangeDrag(c: Pick<ContainerFrame, 'xKind'>, owner: CursorEntry | undefined): RangeDrag | null;
 /** Who owns the drag a pointer-down might start (see the module doc's
  *  precedence order). `'none'` = the press is a potential click only. */
 export type BrushClaim = {
@@ -110,8 +102,8 @@ export declare function resolveBrushClaim(opts: {
 }): BrushClaim;
 /**
  * Dev-warn (once per plot surface) when a press found BOTH a mounted
- * `<MultiSelector>` and a live range drag (a drag-enabled `<RangeCursor>`, or
- * the legacy region props) competing for it — the sweep wins (see the module
+ * `<MultiSelector>` and a live range drag (a drag-enabled `<RangeCursor>`)
+ * competing for it — the sweep wins (see the module
  * doc's precedence), and a silent shadow would hide the loser exactly the way
  * A1.5 said docs alone couldn't.
  */

package/dist/brush.js

@@ -1,44 +1,30 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * Resolve whether a press could start a **range drag**, and who gets the
- * released span. Two sources, component first:
- *
- * 1. **A mounted `<RangeCursor>`** — the hovered row's effective
- *    gesture-owning cursor (`owner`), when it carries `onDragRelease` and is
- *    not frozen (`enableDrag={false}` — the OFF switch, which also suppresses
- *    the legacy fallback: the consumer wired the new API and asked for no
- *    gesture). A `<RangeCursor>` without `onDragRelease` has nothing to fire,
- *    so it does not claim — the legacy props keep working underneath it
- *    during the deprecation window (exactly the step-2 behaviour).
- * 2. **The legacy container props** — `cursor="region"` + `onRegionSelect`
- *    (+ `regionSelectModifier`), byte-for-byte today's semantics, including
- *    the bare-pair payload.
+ * released span: the hovered row's effective gesture-owning cursor (`owner`),
+ * when it is a `<RangeCursor>` carrying `onDragRelease` and is not frozen
+ * (`enableDrag={false}` — the OFF switch). A `<RangeCursor>` without
+ * `onDragRelease` has nothing to fire, so it does not claim.
  *
  * Continuous x only (time or value): a category axis has no span to drag
- * (an ordinal-slot select is a different gesture), so both paths gate on it.
+ * (an ordinal-slot select is `<MultiSelector>`'s gesture). The range cursor's
+ * hover band still draws there — over the slot — and the container dev-warns
+ * that the drag is off ([PND-ORDCURSOR]).
  */
 export function resolveRangeDrag(c, owner) {
     if (c.xKind !== 'time' && c.xKind !== 'value')
         return null;
-    if (owner !== undefined && !owner.legacy && owner.onDragRelease) {
-        // Frozen: the gesture is off without unwiring the callback (§6's
-        // `enableDrag`-as-disabler) — and the legacy fallback stays off too.
-        if (owner.enableDrag === false)
-            return null;
-        const cb = owner.onDragRelease;
-        return {
-            release: (start, end) => cb({ x: [start, end] }),
-            modifier: owner.dragModifier,
-        };
-    }
-    if (c.cursor === 'region' && c.onRegionSelect !== undefined) {
-        const cb = c.onRegionSelect;
-        return {
-            release: (start, end) => cb([start, end]),
-            modifier: c.regionSelectModifier,
-        };
-    }
-    return null;
+    if (owner === undefined || !owner.onDragRelease)
+        return null;
+    // Frozen: the gesture is off without unwiring the callback (§6's
+    // `enableDrag`-as-disabler).
+    if (owner.enableDrag === false)
+        return null;
+    const cb = owner.onDragRelease;
+    return {
+        release: (start, end) => cb({ x: [start, end] }),
+        modifier: owner.dragModifier,
+    };
 }
 /**
  * The claim decision at pointer-down — pure, so the precedence order is
@@ -71,8 +57,8 @@ export function resolveBrushClaim(opts) {
 }
 /**
  * Dev-warn (once per plot surface) when a press found BOTH a mounted
- * `<MultiSelector>` and a live range drag (a drag-enabled `<RangeCursor>`, or
- * the legacy region props) competing for it — the sweep wins (see the module
+ * `<MultiSelector>` and a live range drag (a drag-enabled `<RangeCursor>`)
+ * competing for it — the sweep wins (see the module
  * doc's precedence), and a silent shadow would hide the loser exactly the way
  * A1.5 said docs alone couldn't.
  */
@@ -80,8 +66,8 @@ export function warnSweepShadowsRangeDrag(warned) {
     if (warned.current)
         return;
     warned.current = true;
-    console.warn('[pond-charts] a <MultiSelector> and a drag-enabled <RangeCursor> (or ' +
-        'the legacy onRegionSelect props) are both in scope for this plot — ' +
+    console.warn('[pond-charts] a <MultiSelector> and a drag-enabled <RangeCursor> are ' +
+        'both in scope for this plot — ' +
         'the sweep claims the drag and the range drag never fires. Mount one ' +
         'drag owner per scope, or freeze the cursor with enableDrag={false}. ' +
         'See docs/rfcs/interaction.md A1.5 / §8.1.');