@pond-ts/charts 0.57.0 → 0.59.0

package/dist/BarChart.js

@@ -1,11 +1,15 @@
 import { useContext, useEffect, useMemo } from 'react';
 import { Interval, ValueSeries } from 'pond-ts';
-import { barsFromTimeSeries, barsFromBins, barsFromValueSeries, categoryStack, stacksFromBins, stacksFromColumns, stacksFromGroups, } from './data.js';
+import { barsFromTimeSeries, barsFromBins, barsFromValueSeries, categoryStack, categoryStacks, stacksFromBins, stacksFromColumns, stacksFromGroups, } from './data.js';
 import { barAt, barExtent, barIndexAtTime, drawBars, drawStacks, normalizeThresholds, resolveBarBaseline, stackAt, stackBinExtent, stackValueExtent, } from './bars.js';
+import { spansForLayer } from './span.js';
 import { isDev } from './dev.js';
 import { ContainerContext, LayersContext, } from './context.js';
+import { sweep1D } from './sweep.js';
 import { legendLabelFor, useLegendItems, } from './swatch.js';
 import { useSlotKey } from './use-slot-key.js';
+/** Stable "nothing selected" identity for the narrowed mark lists below. */
+const EMPTY_MARKS = [];
 /**
  * A bar / histogram draw layer. In its simplest form, one rectangle per event
  * spanning the key's `[begin, end]` from the axis baseline to a numeric
@@ -56,7 +60,7 @@ import { useSlotKey } from './use-slot-key.js';
  * </Layers>
  * ```
  */
-export function BarChart({ series, bins, categories, column, columns, as: semantic, colors, binColors, thresholds, bandColors, orientation = 'vertical', ordinal = false, id, axis, gap, decimate = true, legend, index = 0, }) {
+export function BarChart({ series, bins, categories, column, columns, as: semantic, colors, binColors, thresholds, bandColors, orientation = 'vertical', ordinal = false, id, axis, gap, maxBarWidth, decimate = true, legend, index = 0, }) {
     const container = useContext(ContainerContext);
     if (container === null) {
         throw new Error('<BarChart> must be rendered inside a <ChartContainer>');
@@ -74,8 +78,11 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
         throw new Error('<BarChart> needs exactly one of `series`, `bins`, or `categories`');
     }
     if (categories !== undefined) {
-        if (column !== undefined || columns !== undefined) {
-            throw new Error('<BarChart categories> takes no `column`/`columns` (each datum carries its own value)');
+        if (column !== undefined) {
+            throw new Error('<BarChart categories> takes no `column` — a single-value datum carries its own `value`, and a stacked one names its groups with `columns`');
+        }
+        if (columns !== undefined && columns.length === 0) {
+            throw new Error('<BarChart categories> with `columns` needs at least one group name');
         }
     }
     const isMap = series instanceof Map;
@@ -101,10 +108,21 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
     // horizontal bar) so one oriented draw path covers it.
     const shape = useMemo(() => {
         if (categories !== undefined) {
-            // Categorical row-read: one unit-slot bar per category (G === 1), drawn on
-            // the container's band scale. The reused stacked geometry — only the axis
+            // Categorical row-read: one unit-slot bar per category, drawn on the
+            // container's band scale. The reused stacked geometry — only the axis
             // (band scale + labels) is new.
-            return { kind: 'stacked', ss: categoryStack(categories) };
+            //
+            // With `columns` it is a real multi-group stack ([PND-CATSTACK]): same
+            // slots, same `marks`, `G > 1`. Because `marks` is indexed by BIN, one
+            // selection entry naming `(id, mark)` matches every segment of a bar —
+            // which is the property that made the hand-composed workaround's
+            // "recedes from the waist up" bug inexpressible here.
+            return {
+                kind: 'stacked',
+                ss: columns !== undefined
+                    ? categoryStacks(categories, columns)
+                    : categoryStack(categories),
+            };
         }
         if (bins !== undefined) {
             const cols = columns ?? (column !== undefined ? [column] : undefined);
@@ -191,15 +209,21 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                 : series instanceof ValueSeries
                     ? 'value'
                     : 'time';
-    // The bars' `[begin, end)` spans as pond `Interval`s — the region cursor's snap
-    // buckets (a region drag snaps bar by bar; a hover highlights the bar under the
-    // pointer). Published only for a **vertical** bar layer on a **continuous**
-    // (time / value) x axis: a horizontal chart puts the value/count on x (snapping
-    // it is meaningless) and a categorical (ordinal-slot) axis is out of the region
-    // cursor's scope. Memoized off the shape alone, so a hover / selection change
-    // (which rebuilds the layer entry) doesn't re-allocate the intervals.
+    // The bars' `[begin, end)` spans as pond `Interval`s — the shared snap
+    // buckets (a region drag snaps bar by bar; a `<MultiSelector>` sweep's band
+    // extends bar by bar). Published for any **vertical** bar layer: a
+    // horizontal chart puts the value/count on x (snapping it is meaningless).
+    // On a **category** axis the buckets are the unit slots `[i, i+1)` — the
+    // region cursor still ignores them (its band gates on a continuous axis),
+    // but the sweep's band needs them to snap to the slots' **outer edges**:
+    // the band scale's `invert` snaps a pixel to the slot *centre*, so a
+    // freeform sweep band ran centre-to-centre while capture and the committed
+    // span snapped outward (RFC A7.6's edge rule) — the band disagreed with
+    // what release would select. Memoized off the shape alone, so a hover /
+    // selection change (which rebuilds the layer entry) doesn't re-allocate
+    // the intervals.
     const binBuckets = useMemo(() => {
-        if (orientation !== 'vertical' || binAxisKind === 'category')
+        if (orientation !== 'vertical')
             return null;
         const { begin, end, length } = shape.kind === 'single' ? shape.bs : shape.ss;
         if (length === 0)
@@ -240,6 +264,19 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
     // The stacked path's bar-thickness floor comes from `bar.default` (not the `as`
     // role — `as` is single-series only), matching how `gapPx` sources its default.
     const stackMinWidth = bar.default.minWidth;
+    // Same sourcing as `gapPx`: the prop wins, else the theme token, else
+    // uncapped ([PND-BARWIDTH]). `bar.default` rather than the `as` role for the
+    // stacked ceiling, for the reason above.
+    const maxWidthPx = maxBarWidth ?? bar.default.maxWidth;
+    // The single-series draw takes a `BarStyle` straight from the theme, so the
+    // prop override is applied by shadowing the token — same relationship `gap`
+    // has, and with the prop absent the role's own `maxWidth` (if any) already
+    // rides along untouched. Only the INK path gets this: `barSlotRect` (the hit
+    // region) stays the whole slot, so a narrow capped bar keeps a full-width
+    // target — the deliberate ink/hit split `gapPx` already relies on.
+    const singleDrawStyle = useMemo(() => maxBarWidth !== undefined
+        ? { ...singleStyle, maxWidth: maxBarWidth }
+        : singleStyle, [singleStyle, maxBarWidth]);
     // ── Threshold ladder ([PND-BANDBAR2]) ────────────────────────────────────
     // Resolved once here rather than per bar per frame: normalize the breakpoints
     // (sort, drop non-finite), then pair them with `bandColors` → the role's
@@ -327,9 +364,62 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
     const groups = shape.kind === 'stacked' ? shape.ss.groups : undefined;
     const stackStyle = useMemo(() => {
         const base = bar.default;
-        const fills = (groups ?? []).map((g) => colors?.[g] ?? (bar[g] ?? base).fill);
+        // The theme's **group ramp** — multi-group only, since a ramp exists to
+        // tell groups apart and `G === 1` (every categorical and single-series
+        // chart runs this same path) has nothing to tell apart. Resolution per
+        // group: `colors` → a role named after the group → the ramp → `fill`.
+        const multi = (groups?.length ?? 0) > 1;
+        const ramp = multi ? base.groups : undefined;
+        const rampDim = multi ? base.groupsDimmed : undefined;
+        const rampHover = multi ? base.groupsHover : undefined;
+        const at = (r, i) => r[i % r.length];
+        const fills = (groups ?? []).map((g, i) => colors?.[g] ??
+            bar[g]?.fill ??
+            (ramp !== undefined ? at(ramp, i) : base.fill));
+        // A ramp entry the call site overrode is no longer the ramp's colour, so
+        // its receded counterpart would be wrong — the whole ramp only means
+        // anything when it is the ramp that painted it. This gates the *derived*
+        // companions (`dimmedFills` / `hoverFills`), which need a counterpart per
+        // group and cannot invent one for an arbitrary call-site colour.
+        const ramped = ramp !== undefined && colors === undefined;
+        // `groupColored` derives nothing — it only says "a selected segment keeps
+        // its own fill rather than taking the flat `highlight`", because the colour
+        // is meaning-carrying.
+        //
+        // So the condition is exactly **"do the fills actually differ"**, read off
+        // the resolved `fills` rather than inferred from anything upstream of them.
+        // Both cheaper inferences are wrong, and each was shipped in turn:
+        //
+        //  - Gating on `ramped` (the ramp painted it) meant a stack with `colors`
+        //    collapsed BOTH segments of a selected bar to one `highlight` blue —
+        //    losing the segment distinction exactly where the reader is looking. A
+        //    call site naming its groups' colours is *more* deliberate than a
+        //    fallback ramp, not less. Found building [PND-CATSTACK].
+        //  - Gating on `groups.length > 1` (my fix for that) is wrong in the other
+        //    direction: a multi-group stack under a theme with **no** group ramp, no
+        //    `colors` and no per-group roles resolves every fill to `base.fill`, so
+        //    claiming the colour carries meaning suppresses the highlight and leaves
+        //    *nothing* — selection becomes invisible. `estelaTheme` is exactly that
+        //    theme, and it ships. Found by Layer-2 review, which is the only way it
+        //    could have been: every story and test renders `defaultTheme`, whose ramp
+        //    makes the two gates indistinguishable.
+        //
+        // Reading `fills` also handles the degenerate `colors` map that assigns one
+        // colour to every group: nothing is distinguished, so the highlight applies.
+        const groupColoured = new Set(fills).size > 1;
         return {
             fills,
+            ...(groupColoured ? { groupColored: true } : {}),
+            ...(ramped && rampDim !== undefined
+                ? {
+                    dimmedFills: (groups ?? []).map((_g, i) => at(rampDim, i)),
+                }
+                : {}),
+            ...(ramped && rampHover !== undefined
+                ? {
+                    hoverFills: (groups ?? []).map((_g, i) => at(rampHover, i)),
+                }
+                : {}),
             opacity: base.opacity,
             outlineWidth: base.outlineWidth,
             // [PND-CATEMPH] Forward the themed emphasis so the category / horizontal
@@ -343,32 +433,42 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
             ...(base.emphasisOpacity !== undefined
                 ? { emphasisOpacity: base.emphasisOpacity }
                 : {}),
+            ...(base.dimmed !== undefined ? { dimmed: base.dimmed } : {}),
+            ...(maxWidthPx !== undefined ? { maxWidth: maxWidthPx } : {}),
             ...(binColors !== undefined ? { binFills: binColors } : {}),
         };
-    }, [bar, groups, colors, binColors]);
+    }, [bar, groups, colors, binColors, maxWidthPx]);
     // The current selection / hover, narrowed to the identity the highlight match
     // needs. For a stack that's (id, key, label = group); the single path uses just
     // (id, key). Read here so a change re-registers the layer → the canvas repaints.
     const selected = container.selected;
     const hoveredMark = container.hovered;
-    const selection = useMemo(() => selected === null
-        ? null
-        : {
-            id: selected.id,
-            key: selected.key,
-            label: selected.label,
-            ...(selected.mark !== undefined ? { mark: selected.mark } : {}),
-        }, [selected]);
-    const hover = useMemo(() => hoveredMark === null
-        ? null
-        : {
-            id: hoveredMark.id,
-            key: hoveredMark.key,
-            label: hoveredMark.label,
-            ...(hoveredMark.mark !== undefined
-                ? { mark: hoveredMark.mark }
-                : {}),
-        }, [hoveredMark]);
+    // The selection is a set ([PND-MULTISEL]); narrow each member to the identity
+    // the draw path matches on. `EMPTY_MARKS` keeps the no-selection case
+    // reference-stable so it doesn't re-identify the layer entry each render.
+    const selection = useMemo(() => selected.length === 0
+        ? EMPTY_MARKS
+        : selected.map((m) => ({
+            id: m.id,
+            key: m.key,
+            label: m.label,
+            ...(m.mark !== undefined ? { mark: m.mark } : {}),
+        })), [selected]);
+    const hover = useMemo(() => hoveredMark.length === 0
+        ? EMPTY_MARKS
+        : hoveredMark.map((m) => ({
+            id: m.id,
+            key: m.key,
+            label: m.label,
+            ...(m.mark !== undefined ? { mark: m.mark } : {}),
+        })), [hoveredMark]);
+    // The selection's span entries, narrowed to this layer (interaction RFC
+    // A5.2). On the single-series path every mark shares one label, so a span's
+    // `rows` channel resolves here (once) rather than per bar; the stacked path's
+    // labels vary per segment (group / category), so `rows` rides through for
+    // `drawStacks` to test. Empty (and reference-stable) when no span names us —
+    // this layer neither re-registers nor repaints for other layers' spans.
+    const layerSpans = useMemo(() => spansForLayer(container.selectedSpans, id, shape.kind === 'single' ? label : undefined), [container.selectedSpans, id, shape.kind, label]);
     const entry = useMemo(() => {
         // ── Single-series, vertical: the original bar path, pixels unchanged. ──
         if (shape.kind === 'single') {
@@ -403,7 +503,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                     ...(id === undefined
                         ? {}
                         : {
-                            hitTest: (px, py, xScale, yScale) => {
+                            hitTest: (px, py, xScale, yScale, mode) => {
                                 const baseline = resolveBarBaseline(yScale);
                                 // No `gapPx` — the hit region is the bar's whole slot (its
                                 // interval width, full plot height), not the inset rect the
@@ -412,6 +512,20 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                                 if (hit === null)
                                     return null;
                                 const [bi, begin, value] = hit;
+                                // A CLICK narrows the slot to the bar's drawn ink
+                                // vertically (the x keeps the slot, so the gap between
+                                // columns is still not a dead channel). Slots tile the
+                                // whole plot, so without this a click could never resolve
+                                // to null — and that null IS the deselect path (RFC §7's
+                                // empty commit). Hover keeps the full slot: the highlight
+                                // tracks continuously like the readout (#582).
+                                if (mode === 'select') {
+                                    const yValue = yScale(value);
+                                    const yBase = yScale(baseline);
+                                    if (py < Math.min(yValue, yBase) ||
+                                        py > Math.max(yValue, yBase))
+                                        return null;
+                                }
                                 // The bar's stable `mark` (its own axis key) rides the
                                 // selection, so the highlight match and a controlled echo key
                                 // on the *sample* rather than on the `begin` edge — which on a
@@ -430,8 +544,43 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                                     ...(stableMark !== undefined ? { mark: stableMark } : {}),
                                 };
                             },
+                            // The <MultiSelector> sweep's range query (RFC A7.6): bars
+                            // are sorted, non-overlapping intervals, so the covered set
+                            // is a contiguous run — sweep1D's two binary searches. Each
+                            // materialised hit is EXACTLY what hitTest reports for that
+                            // bar, so a swept bar and a clicked bar are the same currency.
+                            beginSweep: () => bs.length === 0
+                                ? null
+                                : sweep1D({
+                                    id,
+                                    begin: bs.begin,
+                                    end: bs.end,
+                                    length: bs.length,
+                                    // A gap bar (non-finite value) owns no membership.
+                                    selectable: (i) => Number.isFinite(bs.y[i]),
+                                    materialize: (lo, hi) => {
+                                        const out = [];
+                                        for (let i = lo; i < hi; i += 1) {
+                                            const v = bs.y[i];
+                                            if (!Number.isFinite(v))
+                                                continue;
+                                            const stableMark = bs.marks?.[i];
+                                            out.push({
+                                                id,
+                                                key: bs.begin[i],
+                                                value: v,
+                                                color: binColors?.[i] ?? singleStyle.fill,
+                                                label,
+                                                ...(stableMark !== undefined
+                                                    ? { mark: stableMark }
+                                                    : {}),
+                                            });
+                                        }
+                                        return out;
+                                    },
+                                }),
                         }),
-                    draw: (ctx, xScale, yScale) => drawBars(ctx, bs, xScale, yScale, singleStyle, resolveBarBaseline(yScale), gapPx, id, selection, hover, decimate, binColors, bandLadder),
+                    draw: (ctx, xScale, yScale) => drawBars(ctx, bs, xScale, yScale, singleDrawStyle, resolveBarBaseline(yScale), gapPx, id, selection, hover, decimate, binColors, bandLadder, layerSpans),
                 },
                 axisId: axis,
                 index,
@@ -469,7 +618,20 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                     ? {}
                     : {
                         hitTest: (px, py, xScale, yScale) => {
-                            const hit = stackAt(ss, px, py, orientation, xScale, yScale, gapPx, stackMinWidth);
+                            // 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
+                            // and nothing to disambiguate, so narrowing its target buys
+                            // nothing and costs clickability.
+                            //
+                            // This path serves single-series **horizontal** charts as well as
+                            // stacks (see the branch comment above), which is how the prop's
+                            // documented guarantee — "a single-series bar hit-tests its whole
+                            // slot" — was true only of vertical ones. Found by Layer-2 review;
+                            // 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);
                             if (hit === null)
                                 return null;
                             const [bi, g, begin, name, value] = hit;
@@ -490,8 +652,67 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
                                 ...(stableMark !== undefined ? { mark: stableMark } : {}),
                             };
                         },
+                        // The sweep, on the binned/stacked/categorical path — **either
+                        // orientation** ([PND-HSWEEP]). The session is identical, because
+                        // `sweep1D` cuts in KEY-axis units and does not care which screen
+                        // axis produced them; the bins are `ss.begin`/`ss.end` whichever
+                        // way the chart is drawn. What differs is only where the gesture
+                        // reads the pointer, which `sweepAxis` declares.
+                        //
+                        // The cut stays 1-D on a horizontal chart, deliberately: a
+                        // vertical bar's sweep ignores the value axis (drag anywhere
+                        // horizontally, take whole columns), so its transpose ignores it
+                        // too. A rect here would be value-filtering — a capability the
+                        // vertical chart has never had.
+                        //
+                        // A covered bin materialises every drawn segment (finite,
+                        // non-zero — the marks hitTest can hit), assembled exactly as
+                        // hitTest assembles them.
+                        sweepAxis: vertical ? 'x' : 'y',
+                        beginSweep: () => {
+                            const G = ss.groups.length;
+                            if (ss.length === 0 || G === 0)
+                                return null;
+                            const drawn = (b, g) => {
+                                const v = ss.values[b * G + g];
+                                return Number.isFinite(v) && v !== 0;
+                            };
+                            return sweep1D({
+                                id,
+                                begin: ss.begin,
+                                end: ss.end,
+                                length: ss.length,
+                                selectable: (b) => {
+                                    for (let g = 0; g < G; g += 1)
+                                        if (drawn(b, g))
+                                            return true;
+                                    return false;
+                                },
+                                materialize: (lo, hi) => {
+                                    const out = [];
+                                    for (let b = lo; b < hi; b += 1) {
+                                        const stableMark = ss.marks?.[b];
+                                        for (let g = 0; g < G; g += 1) {
+                                            if (!drawn(b, g))
+                                                continue;
+                                            out.push({
+                                                id,
+                                                key: ss.begin[b],
+                                                value: ss.values[b * G + g],
+                                                color: stackStyle.binFills?.[b] ?? stackStyle.fills[g],
+                                                label: stableMark ?? ss.groups[g],
+                                                ...(stableMark !== undefined
+                                                    ? { mark: stableMark }
+                                                    : {}),
+                                            });
+                                        }
+                                    }
+                                    return out;
+                                },
+                            });
+                        },
                     }),
-                draw: (ctx, xScale, yScale) => drawStacks(ctx, ss, orientation, xScale, yScale, stackStyle, gapPx, stackMinWidth, id, selection, hover, bandLadder),
+                draw: (ctx, xScale, yScale) => drawStacks(ctx, ss, orientation, xScale, yScale, stackStyle, gapPx, stackMinWidth, id, selection, hover, bandLadder, layerSpans),
             },
             axisId: axis,
             index,
@@ -503,6 +724,7 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
         categoryLabels,
         orientation,
         singleStyle,
+        singleDrawStyle,
         stackStyle,
         binColors,
         bandLadder,
@@ -511,8 +733,10 @@ export function BarChart({ series, bins, categories, column, columns, as: semant
         gapPx,
         decimate,
         stackMinWidth,
+        maxWidthPx,
         selection,
         hover,
+        layerSpans,
         axis,
         index,
     ]);

package/dist/BarList.d.ts

@@ -2,6 +2,7 @@ import { type ReactNode } from 'react';
 import type { SeriesSchema, ValueSeriesSchema } from 'pond-ts';
 import { type BarListColumn, type ListCellSpec, type ListMarker, type ListRow, type ListSortDirection } from './list.js';
 import { type ListRowsSource, type ListSeriesSource } from './list-source.js';
+import type { SelectModifiers } from './context.js';
 import { type ChartTheme } from './theme.js';
 /** The props both BarList source doors share. */
 export interface BarListCommon<R extends ListRow = ListRow> {
@@ -53,13 +54,92 @@ export interface BarListCommon<R extends ListRow = ListRow> {
     /** Observe a toggle (`expanded` is the row's **new** state). */
     onExpandToggle?: (key: string, expanded: boolean) => void;
     /**
-     * The selected row's `key`, marked with an inset edge in the annotation
-     * (marks) register — selection is a user's mark, not data. Consumer-owned
-     * state: pair with `onRowClick`. `null` / omitted ⇒ none.
+     * The selected row(s), marked with an inset edge in the annotation (marks)
+     * register — selection is a user's mark, not data. Consumer-owned state:
+     * pair with {@link onRowClick}. `null` / omitted ⇒ none.
+     *
+     * **Accepts one key or a set**, the same union {@link hovered} takes
+     * ([PND-INTERACTCONF] / RFC `interaction.md` A3.1 — the list family speaks
+     * the canvas's interaction vocabulary, not a parallel one). Plural because
+     * a range of rows can be selected at once; passing a bare key still means
+     * exactly what it looks like.
+     *
+     * The library applies **no set arithmetic** — it renders what you hand back.
      */
-    selected?: string | null;
-    /** Row click (rows show hover + pointer affordances only when provided). */
+    selected?: string | readonly string[] | null;
+    /** Row click (rows show the pointer affordance only when provided). */
     onRowClick?: (row: R) => void;
+    /**
+     * **Plural select** — the list's answer to `<MultiSelector>`, and how a user
+     * produces a multi-row {@link selected}.
+     *
+     * Fires with the rows the gesture took plus its modifiers:
+     *
+     * - a **click** reports `[row]` — so this is a strict *superset* of
+     *   {@link onRowClick}, the way `<MultiSelector>` is of `<Selector>`;
+     * - a **drag across rows** reports the whole inclusive run, in display
+     *   order.
+     *
+     * **Mounting it is what enables the drag** (interaction RFC A4.2 rule 1 —
+     * the same rule that makes a bare `<MultiSelector />` enable the canvas
+     * sweep). A list with only `onRowClick` behaves exactly as it always has.
+     *
+     * **Crossing into another row is what makes it a range**, not a pixel slop:
+     * a row is tall and discrete, so a press-and-release on one row is always a
+     * click, and a horizontal wobble — which on a stack of rows means nothing —
+     * can never commit one. While the drag runs, the covered rows light as
+     * *hovered*: that is the live preview of what releasing would take, and it
+     * out-ranks {@link hovered} for the duration without touching it.
+     *
+     * **The library holds no state and applies no set arithmetic.** You get the
+     * run and the modifiers; you decide whether to replace or union, and feed
+     * the result back through {@link selected}:
+     *
+     * ```tsx
+     * onRowSelect={(rows, m) =>
+     *   setSel((cur) => {
+     *     const keys = rows.map((r) => r.key);
+     *     return m.additive ? [...new Set([...cur, ...keys])] : keys;
+     *   })
+     * }
+     * ```
+     *
+     * `modifiers.additive` is the platform-idiomatic add chord already resolved
+     * (⌘ on macOS, Ctrl elsewhere). **`shiftKey` is reported but carries no
+     * built-in meaning** — an ordinal range is a gesture here, not a modifier
+     * (see `SelectModifiers`), so a shift-click extend is yours to define if you
+     * want one.
+     */
+    onRowSelect?: (rows: readonly R[], modifiers: SelectModifiers) => void;
+    /**
+     * Controlled **hover-highlight** — the transiently lit row key(s), or `null`.
+     * **Omitted ⇒ uncontrolled** (the list tracks its own pointer, as it always
+     * has). The hover analog of {@link selected}: pass it to light rows from
+     * _outside_ the list — the chart bar the pointer is on, a map segment, a
+     * sibling list.
+     *
+     * **Accepts one key or a set**, the same union `<Selector hovered>`
+     * takes ([PND-INTERACTCONF] / RFC `interaction.md` A3.1 — the list family
+     * speaks the canvas's interaction vocabulary, not a parallel one). Plural
+     * because a sweep lights several marks at once; a plain pointer-over carries
+     * 0 or 1, so passing a bare key still means exactly what it looks like.
+     *
+     * The library applies **no set arithmetic** — it reports what the pointer is
+     * over and renders what you hand back.
+     */
+    hovered?: string | readonly string[] | null;
+    /**
+     * Fires when the pointer enters a row (with that row) or leaves every row
+     * (`null`) — the hover analog of `onRowClick`, and the list's half of the
+     * bidirectional channel: mirror it out to light the matching chart bar,
+     * pairing with {@link hovered} to sync hover both ways.
+     *
+     * Notification only (fires controlled or uncontrolled) and **deduped by row
+     * key**, so it reports a row transition, not every pointer move. Moving from
+     * one row straight to the next reports the new row — no `null` in between;
+     * `null` means the pointer genuinely left the rows.
+     */
+    onHover?: (row: R | null) => void;
     /** Each bar line's height in px. **Omitted ⇒ `8`.** */
     barHeight?: number;
     /** Rule between rows (`theme.axis.grid`). **Omitted ⇒ `true`.** */

package/dist/BarList.js

@@ -36,7 +36,7 @@ export function BarList(props) {
     // One normalized view of the union — `isSeriesSource` is the runtime
     // narrowing; the doors are mutually exclusive by construction now.
     const source = props;
-    const { rows, series, label, columns, domain, sortBy, sortDirection = 'desc', sort, before, after, renderExpanded, defaultExpanded, onExpandToggle, selected, onRowClick, markers, barHeight = 8, divided, baseline, theme = defaultTheme, } = source;
+    const { rows, series, label, columns, domain, sortBy, sortDirection = 'desc', sort, before, after, renderExpanded, defaultExpanded, onExpandToggle, selected, onRowClick, onRowSelect, hovered, onHover, markers, barHeight = 8, divided, baseline, theme = defaultTheme, } = source;
     // A runtime guard for JS consumers and `any`-typed call sites — the
     // props union makes both branches unreachable from typed TS, but a
     // silently-ignored source prop is a worse failure than a throw.
@@ -55,9 +55,30 @@ export function BarList(props) {
         frac: listFraction(m.value, scale),
         ...(m.label !== undefined ? { label: m.label } : {}),
     })), [markers, scale]);
-    return (_jsx(ListTable, { rows: sorted, kind: "bar", markers: resolvedMarkers, before: before, after: after, renderExpanded: renderExpanded, defaultExpanded: defaultExpanded, onExpandToggle: onExpandToggle, selected: selected, onRowClick: onRowClick, divided: divided, baseline: baseline, theme: theme, renderGlyphs: (row) => (_jsx(_Fragment, { children: columns.map((col, ci) => {
+    return (_jsx(ListTable, { rows: sorted, kind: "bar", markers: resolvedMarkers, before: before, after: after, renderExpanded: renderExpanded, defaultExpanded: defaultExpanded, onExpandToggle: onExpandToggle, selected: selected, onRowClick: onRowClick, onRowSelect: onRowSelect, hovered: hovered, onHover: onHover, divided: divided, baseline: baseline, theme: theme, renderGlyphs: (row, state) => (_jsx(_Fragment, { children: columns.map((col, ci) => {
                 const style = theme.bar[col.as ?? 'default'] ?? theme.bar.default;
                 const frac = listFraction(row.values[col.column], scale);
+                // **The fill's state treatment — decorative, never load-bearing.**
+                // The band and the rail have already said "selected"; this only
+                // agrees with them. It is skipped entirely on a multi-metric row
+                // because there the fill IS the metric's identity, and recolouring
+                // it would trade a distinction the reader needs for one they
+                // already have (`ChartTheme.list`'s channel rule).
+                //
+                // Which is also why nothing below may be the *only* signal: strip
+                // this block and a selected row still reads as selected.
+                const soleMetric = columns.length === 1;
+                const fill = state.selected && soleMetric
+                    ? style.highlight
+                    : state.dimmed
+                        ? (style.dimmed ?? style.fill)
+                        : style.fill;
+                // A `dimmed` token carries its own alpha (`rgba(…,0.32)`), so
+                // multiplying `opacity` on top of it would dim twice. Fall back to
+                // the raw 0.32 only when the theme names no dimmed colour.
+                const fillOpacity = state.dimmed && style.dimmed === undefined
+                    ? style.opacity * 0.32
+                    : style.opacity;
                 return (_jsxs("div", { "data-list-track": col.column, style: {
                         position: 'relative',
                         height: barHeight,
@@ -75,8 +96,8 @@ export function BarList(props) {
                                 bottom: 0,
                                 left: 0,
                                 width: `${frac * 100}%`,
-                                background: style.fill,
-                                opacity: style.opacity,
+                                background: fill,
+                                opacity: fillOpacity,
                                 borderRadius: barHeight / 2,
                             } }))] }, `${ci} ${col.column}`));
             }) })) }));