@fundar/data-chart-telling 1.1.0 → 1.3.0

package/dist/markers/violin/ViolinProfiles.d.ts

@@ -0,0 +1,29 @@
+import type { ProcessedRow } from '../../types/phases';
+import type { DensityKernel } from '../../types/transforms/density';
+/** One violin: a category's density curve. */
+export type ViolinProfile = {
+    category: unknown;
+    /** The density estimate, in order along the value axis. */
+    curve: {
+        value: number;
+        density: number;
+    }[];
+};
+/** How the density of each category is estimated. */
+export type ViolinEstimate = {
+    kernel?: DensityKernel;
+    bandwidth?: number;
+    /** Keeps each curve within its values' own extent. Defaults to `true`. */
+    trim?: boolean;
+};
+/** The violins of a set of rows, one per category. */
+export declare class ViolinProfiles {
+    #private;
+    /** One profile per category of `rows` with at least two values, in the order the rows first reach it. */
+    static of(rows: ProcessedRow[], read: {
+        category: (row: ProcessedRow) => unknown;
+        value: (row: ProcessedRow) => unknown;
+    }, estimate?: ViolinEstimate): ViolinProfile[];
+    /** The densest point of any of `profiles`, for violins that share one density scale. */
+    static peak(profiles: ViolinProfile[]): number;
+}

package/dist/markers/violin/ViolinProfiles.js

@@ -0,0 +1,55 @@
+import { Transforms } from '../../phases/transforms/Transforms';
+import { resolveAccessor } from '../../utils/accessors';
+import { isGapValue } from '../../plots/utils/gaps';
+/** The violins of a set of rows, one per category. */
+export class ViolinProfiles {
+    /** One profile per category of `rows` with at least two values, in the order the rows first reach it. */
+    static of(rows, read, estimate = {}) {
+        const groups = new Map();
+        for (const row of rows) {
+            const raw = read.value(row);
+            if (isGapValue(raw))
+                continue;
+            const value = Number(raw);
+            if (!Number.isFinite(value))
+                continue;
+            const category = read.category(row);
+            const key = String(category);
+            const group = groups.get(key);
+            if (group) {
+                group.rows.push(row);
+                group.values.push(value);
+            }
+            else
+                groups.set(key, { category, rows: [row], values: [value] });
+        }
+        return [...groups.values()].flatMap(({ category, rows: own, values }) => {
+            if (values.length < 2)
+                return [];
+            const extent = [Math.min(...values), Math.max(...values)];
+            const curve = ViolinProfiles.#curve(own, read.value, estimate, extent);
+            return curve.length < 2 ? [] : [{ category, curve }];
+        });
+    }
+    /** The densest point of any of `profiles`, for violins that share one density scale. */
+    static peak(profiles) {
+        return Math.max(0, ...profiles.flatMap((p) => p.curve.map((point) => point.density)));
+    }
+    static #curve(rows, value, estimate, extent) {
+        const trim = estimate.trim ?? true;
+        const result = Transforms.run({
+            type: 'densityY',
+            data: rows,
+            y: value,
+            kernel: estimate.kernel,
+            bandwidth: estimate.bandwidth,
+            trim
+        });
+        const along = resolveAccessor(result.y);
+        const density = resolveAccessor(result.x);
+        return result.data
+            .map((row) => ({ value: Number(along(row)), density: Number(density(row)) }))
+            .map((p) => (trim ? { ...p, value: Math.min(Math.max(p.value, extent[0]), extent[1]) } : p))
+            .filter((p) => Number.isFinite(p.value) && Number.isFinite(p.density));
+    }
+}

package/dist/markers/waffle/WaffleMarker.svelte

@@ -10,6 +10,7 @@
 
 	const plot = usePlot();
 	const isHorizontal = $derived(plot.axes?.isHorizontal ?? false);
+	const WaffleMark = $derived(isHorizontal ? WaffleX : WaffleY);
 
 	const cfg = $derived(getConfiguration());
 	const data = $derived(marker.data ?? []);
@@ -17,40 +18,19 @@
 	const fill = $derived(channelFill ?? marker.styles?.fill ?? cfg.palette[0]);
 </script>
 
-{#if isHorizontal}
-	<WaffleX
-		{data}
-		x={marker.x}
-		x1={marker.x1}
-		x2={marker.x2}
-		y={marker.y}
-		unit={marker.unit}
-		multiple={marker.multiple}
-		gap={marker.gap}
-		round={marker.round}
-		borderRadius={marker.styles?.borderRadius}
-		{fill}
-		fillOpacity={marker.styles?.fillOpacity}
-		stroke={marker.styles?.stroke}
-		strokeWidth={marker.styles?.strokeWidth}
-		strokeOpacity={marker.styles?.strokeOpacity}
-	/>
-{:else}
-	<WaffleY
-		{data}
-		x={marker.x}
-		y={marker.y}
-		y1={marker.y1}
-		y2={marker.y2}
-		unit={marker.unit}
-		multiple={marker.multiple}
-		gap={marker.gap}
-		round={marker.round}
-		borderRadius={marker.styles?.borderRadius}
-		{fill}
-		fillOpacity={marker.styles?.fillOpacity}
-		stroke={marker.styles?.stroke}
-		strokeWidth={marker.styles?.strokeWidth}
-		strokeOpacity={marker.styles?.strokeOpacity}
-	/>
-{/if}
+<WaffleMark
+	{data}
+	x={marker.x}
+	y={marker.y}
+	{...isHorizontal ? { x1: marker.x1, x2: marker.x2 } : { y1: marker.y1, y2: marker.y2 }}
+	unit={marker.unit}
+	multiple={marker.multiple}
+	gap={marker.gap}
+	round={marker.round}
+	borderRadius={marker.styles?.borderRadius}
+	{fill}
+	fillOpacity={marker.styles?.fillOpacity}
+	stroke={marker.styles?.stroke}
+	strokeWidth={marker.styles?.strokeWidth}
+	strokeOpacity={marker.styles?.strokeOpacity}
+/>

package/dist/phases/Pipeline.d.ts

@@ -15,6 +15,11 @@ export type AxisPipelineProps<TData extends Record<string, unknown>> = {
     opacity?: unknown;
     r?: unknown;
     symbol?: unknown;
+    lower?: Accessor<TData, unknown>;
+    upper?: Accessor<TData, unknown>;
+    error?: Accessor<TData, unknown>;
+    target?: unknown;
+    ranges?: unknown[];
     segments?: unknown;
     styles?: {
         gaps?: unknown;

package/dist/phases/Pipeline.js

@@ -210,6 +210,11 @@ export class Pipeline {
             opacity: props.opacity,
             r: props.r,
             symbol: props.symbol,
+            lower: props.lower,
+            upper: props.upper,
+            error: props.error,
+            target: props.target,
+            ranges: props.ranges,
             segments: props.segments ?? {},
             styles: props.styles,
             gaps: props.styles?.gaps,

package/dist/phases/data/DataPhase.js

@@ -1,6 +1,6 @@
 import { buildSeries } from '../../utils/grouping';
-import { resolveColorScale } from '../../utils/color';
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { ColorRamp } from '../../utils/color';
+import { resolveAccessor } from '../../utils/accessors';
 import { buildGroupedSeries, buildScopedMarkerGroups } from '../../plots/utils/segments';
 import { buildGapFillMaps, isGapValue } from '../../plots/utils/gaps';
 import { FacetPanels } from '../facet/FacetPanels';
@@ -34,7 +34,7 @@ export class DataPhase {
             given: { x: state.x !== undefined, y: state.y !== undefined },
             discrete: options.discreteAxes
         });
-        const colorForSeries = resolveColorScale(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), ctx.cfg.palette);
+        const colorForSeries = ColorRamp.resolve(scales.color, (options.colorOrder ? options.colorOrder(fullSeries) : fullSeries).map((s) => s.name), ctx.cfg.palette);
         const panelSeries = state.panels && state.panelOf && !series
             ? FacetPanels.splitSeries(fullSeries, state.panels, state.panelOf)
             : fullSeries;

package/dist/phases/data/PlotAxes.d.ts

@@ -58,6 +58,16 @@ export declare class PlotAxes {
     static categoryOf(state: {
         axes?: PlotAxes;
     }): AxisChannelName;
+    /**
+     * Where marks that rise from a baseline start along the value axis: zero,
+     * or the nearest end of a pinned domain that leaves zero out.
+     */
+    static baselineOf(state: {
+        axes?: PlotAxes;
+        scales: Partial<Record<AxisChannelName, {
+            domain?: readonly unknown[];
+        }>>;
+    }): number;
     /** The other position axis. */
     static other(axis: AxisChannelName): AxisChannelName;
     /**

package/dist/phases/data/PlotAxes.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 import { isGapValue } from '../../plots/utils/gaps';
 import { DISCRETE_SCALE_TYPES, TEMPORAL_SCALE_TYPES } from '../../types/layout/scales';
 const AXES = ['x', 'y'];
@@ -47,6 +47,19 @@ export class PlotAxes {
     static categoryOf(state) {
         return state.axes?.category ?? 'x';
     }
+    /**
+     * Where marks that rise from a baseline start along the value axis: zero,
+     * or the nearest end of a pinned domain that leaves zero out.
+     */
+    static baselineOf(state) {
+        const domain = state.scales[PlotAxes.valueOf(state)]?.domain;
+        const lo = Number(domain?.[0]);
+        const hi = Number(domain?.[(domain?.length ?? 1) - 1]);
+        if (!domain || domain.length < 2 || Number.isNaN(lo) || Number.isNaN(hi))
+            return 0;
+        const [min, max] = [Math.min(lo, hi), Math.max(lo, hi)];
+        return min > 0 ? min : max < 0 ? max : 0;
+    }
     /** The other position axis. */
     static other(axis) {
         return axis === 'x' ? 'y' : 'x';

package/dist/phases/facet/FacetPanels.d.ts

@@ -20,6 +20,7 @@ type NarrowableState = FacetStageState & {
             panel?: string;
         };
     }[];
+    labelled?: Record<string | symbol, unknown>[];
 };
 /** The field a processed row carries its facet panel under. */
 export declare const PANEL_KEY = "__panel";

package/dist/phases/facet/FacetPanels.js

@@ -63,6 +63,7 @@ export class FacetPanels {
             scopedGroups: state.scopedGroups?.filter((g) => has(g.panel)),
             groupedSeries: state.groupedSeries?.filter((g) => has(g.series.panel)),
             processedGroups: state.processedGroups?.filter((g) => has(g.series.panel)),
+            labelled: state.labelled?.filter((row) => has(row[PANEL_KEY])),
             processedData: state.processedData && {
                 ...state.processedData,
                 data: state.processedData.data.filter((row) => has(row[PANEL_KEY]))

package/dist/phases/facet/FacetPhase.d.ts

@@ -3,7 +3,8 @@ import type { FacetStageState, PhaseStage } from '../../types/phases';
  * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
  * which panel each row belongs to. It runs first, so the "data" phase builds
  * every series already split by panel. A plot drawn from pre-built `series`
- * has no rows to split, so its facet is ignored.
+ * has no rows to split, so its facet is ignored. The plot's `segments` and markers that name a facet
+ * are handed to the panels they name here, once, for every later phase.
  */
 export declare class FacetPhase<TState extends FacetStageState> implements PhaseStage<TState> {
     readonly phase: "facet";

package/dist/phases/facet/FacetPhase.js

@@ -1,18 +1,26 @@
 import { buildFacetKeyOf, buildFacetPanels } from '../../layout/facet/config';
 import { PANEL_KEY } from './FacetPanels';
+import { FacetScope } from '../../layout/facet/scope';
 /**
  * The "facet" phase: the panels the plot's `facet` lays its rows out in, and
  * which panel each row belongs to. It runs first, so the "data" phase builds
  * every series already split by panel. A plot drawn from pre-built `series`
- * has no rows to split, so its facet is ignored.
+ * has no rows to split, so its facet is ignored. The plot's `segments` and markers that name a facet
+ * are handed to the panels they name here, once, for every later phase.
  */
 export class FacetPhase {
     phase = 'facet';
     run = (state) => {
         const { data, series } = state;
         const facet = state.facet;
-        if (!facet || series || !data)
-            return state;
+        // Without panels, a segment or a marker that names a facet has none to be drawn in.
+        if (!facet || series || !data) {
+            return {
+                ...state,
+                segments: FacetScope.scopeSegments(state.segments, undefined),
+                authorMarkers: FacetScope.scope(state.authorMarkers, undefined)
+            };
+        }
         const panels = buildFacetPanels(facet, data).map(({ rows: _rows, ...panel }) => panel);
         const keys = new Set(panels.map((p) => p.key));
         const keyOf = buildFacetKeyOf(facet);
@@ -23,6 +31,13 @@ export class FacetPhase {
             const key = keyOf(row);
             return keys.has(key) ? key : undefined;
         };
-        return { ...state, panels, panelOf };
+        // Every later phase reads each panel's own segments and markers: nothing past here knows of `facet`.
+        return {
+            ...state,
+            panels,
+            panelOf,
+            segments: FacetScope.distributeSegments(state.segments, panels),
+            authorMarkers: FacetScope.distributeMarkers(state.authorMarkers, panels)
+        };
     };
 }

package/dist/phases/mapping/MappingPhase.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from '../../plots/utils/accessors';
+import { resolveAccessor } from '../../utils/accessors';
 /**
  * The "mapping" phase every axis-based plot shares: every channel resolved to
  * a row accessor. `x`/`y` (and `color`) read the first series' own, falling

package/dist/phases/markers/MarkersPhase.js

@@ -1,3 +1,4 @@
+import { MarkerChannels } from '../../markers/utils/MarkerChannels';
 /**
  * The shared "markers" phase: everything the plot draws, bottom to top - the
  * plot kind's own marks, then what the "statistics" phase left in
@@ -21,7 +22,7 @@ export class MarkersPhase {
             : [];
         return {
             ...state,
-            markers: [...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels]
+            markers: MarkerChannels.inheritPosition(MarkerChannels.inheritAll([...options.marks(state, ctx), ...(state.markers ?? []), ...valueLabels], state.scales), state.processedData)
         };
     };
 }

package/dist/phases/scales/CategoryOrder.d.ts

@@ -0,0 +1,23 @@
+import { PlotAxes } from '../data/PlotAxes';
+import { type IntervalAccessors } from '../../plots/utils/RowNumbers';
+import type { AxisChannelName } from '../../types/layout/mapping';
+import type { CategorySort } from '../../types/layout/scales';
+import type { ProcessedData } from '../../types/phases';
+/**
+ * The order of a plot's categories under a declarative `scales.*.sort`: read off
+ * the processed rows, by what each category holds on the value axis - its value
+ * in a series, the sum of its values, or the spread between its lowest and its
+ * highest.
+ */
+export declare class CategoryOrder {
+    /** Whether a `sort` is a {@link CategorySort} rather than a comparator. */
+    static isDeclarative(sort: unknown): sort is CategorySort;
+    /**
+     * The categories of `axis`, in the order `sort` gives them; `undefined` without rows to
+     * read. The state is whatever has the processed rows and the axes.
+     */
+    static of(sort: CategorySort, state: {
+        processedData?: ProcessedData;
+        axes?: PlotAxes;
+    } & IntervalAccessors, axis: AxisChannelName): unknown[] | undefined;
+}

package/dist/phases/scales/CategoryOrder.js

@@ -0,0 +1,73 @@
+import { ProcessedPositions } from '../transforms/ProcessedPositions';
+import { SERIES_KEY } from '../transforms/TransformsPhase';
+import { PlotAxes } from '../data/PlotAxes';
+import { RowNumbers } from '../../plots/utils/RowNumbers';
+import { isGapValue } from '../../plots/utils/gaps';
+/**
+ * The order of a plot's categories under a declarative `scales.*.sort`: read off
+ * the processed rows, by what each category holds on the value axis - its value
+ * in a series, the sum of its values, or the spread between its lowest and its
+ * highest.
+ */
+export class CategoryOrder {
+    /** Whether a `sort` is a {@link CategorySort} rather than a comparator. */
+    static isDeclarative(sort) {
+        return typeof sort === 'object' && sort !== null && 'by' in sort;
+    }
+    /**
+     * The categories of `axis`, in the order `sort` gives them; `undefined` without rows to
+     * read. The state is whatever has the processed rows and the axes.
+     */
+    static of(sort, state, axis) {
+        const processed = state.processedData;
+        if (!processed)
+            return undefined;
+        const valueAxis = PlotAxes.valueOf(state);
+        const position = ProcessedPositions.of(processed, valueAxis);
+        const categoryOf = position[axis];
+        const valueOf = position[valueAxis];
+        // Each category, in the order the rows give them, with the values it holds.
+        const held = new Map();
+        for (const row of processed.data) {
+            const category = categoryOf(row);
+            const key = String(category);
+            let entry = held.get(key);
+            if (!entry)
+                held.set(key, (entry = { category, series: String(row[SERIES_KEY]), values: [], own: [] }));
+            const raw = valueOf(row);
+            const value = Number(raw);
+            if (isGapValue(raw) || !Number.isFinite(value))
+                continue;
+            entry.values.push(...RowNumbers.interval(state, row, value));
+            if (sort.series === undefined || String(row[SERIES_KEY]) === sort.series) {
+                entry.own.push(value);
+            }
+        }
+        const keyOf = (entry) => {
+            if (sort.by === 'range') {
+                return entry.values.length === 0
+                    ? undefined
+                    : Math.max(...entry.values) - Math.min(...entry.values);
+            }
+            return entry.own.length === 0 ? undefined : entry.own.reduce((sum, v) => sum + v, 0);
+        };
+        const sign = sort.order === 'descending' ? -1 : 1;
+        const sorted = (entries) => entries
+            .map((entry, index) => ({ entry, index, key: keyOf(entry) }))
+            .sort((a, b) => {
+            if (a.key === undefined || b.key === undefined) {
+                return ((a.key === undefined ? 1 : 0) - (b.key === undefined ? 1 : 0) || a.index - b.index);
+            }
+            return sign * (a.key - b.key) || a.index - b.index;
+        })
+            .map(({ entry }) => entry);
+        const entries = [...held.values()];
+        if (!sort.grouped)
+            return sorted(entries).map((entry) => entry.category);
+        const bySeries = new Map();
+        for (const entry of entries) {
+            bySeries.set(entry.series, [...(bySeries.get(entry.series) ?? []), entry]);
+        }
+        return [...bySeries.values()].flatMap((group) => sorted(group).map((entry) => entry.category));
+    }
+}

package/dist/phases/scales/ScalesPhase.js

@@ -2,6 +2,7 @@ import { ProcessedPositions } from '../transforms/ProcessedPositions';
 import { isGapValue } from '../../plots/utils/gaps';
 import { MarkerAxisValues } from './MarkerAxisValues';
 import { PlotAxes } from '../data/PlotAxes';
+import { CategoryOrder } from './CategoryOrder';
 import { NiceTicks } from '../../layout/scales/NiceTicks';
 import { DISCRETE_SCALE_TYPES } from '../../types/layout/scales';
 const AXES = ['x', 'y'];
@@ -53,7 +54,7 @@ export class ScalesPhase {
         for (const axis of AXES) {
             const own = ScalesPhase.#defaultsOf(defaults, axis, axes);
             if (axes?.bands.includes(axis)) {
-                scales[axis] = this.#band(scales[axis], own, processedData, axis);
+                scales[axis] = this.#band(scales[axis], own, state, axis);
                 continue;
             }
             // The value axis of a plot with categories is never one itself, whatever it was marked as.
@@ -72,9 +73,14 @@ export class ScalesPhase {
             }
         }
         const fitted = options.fit?.({ ...state, scales }, ctx) ?? {};
+        const fittedAxes = [];
         for (const axis of AXES) {
-            if (fitted[axis])
-                scales[axis] = { ...scales[axis], ...fitted[axis] };
+            if (!fitted[axis])
+                continue;
+            const { fitted: ownDomain, ...fit } = fitted[axis];
+            scales[axis] = { ...scales[axis], ...fit };
+            if (ownDomain)
+                fittedAxes.push(axis);
         }
         for (const axis of AXES) {
             if (axes?.bands.includes(axis) || scales[axis]?.domain)
@@ -99,19 +105,20 @@ export class ScalesPhase {
             scales[axis] = niced
                 ? {
                     ...author,
-                    domain: NiceTicks.fit(state, axis, lo, hi, author?.niceTolerance),
+                    domain: NiceTicks.fit(state, axis, lo, hi, NiceTicks.toleranceOf(author?.nice)),
                     nice: false
                 }
                 : { ...author, domain: [lo, hi], nice: author?.nice ?? true };
         }
-        const next = { ...state, scales };
+        const next = { ...state, scales, ...(fittedAxes.length ? { fittedAxes } : {}) };
         return options.extend ? options.extend(next, ctx) : next;
     };
     /** A category axis as a band scale: the kind's options under the author's, in the order the kind asks for. */
-    #band(author, own, processed, axis) {
+    #band(author, own, state, axis) {
+        const processed = state.processedData;
         const given = author ?? {};
         const type = given.type === undefined || given.type === 'auto' || given.type === 'categorical'
-            ? 'band'
+            ? (own.type ?? 'band')
             : given.type;
         const band = { ...own, ...given, type };
         // A padding the author gives replaces the kind's own inner and outer ones.
@@ -123,6 +130,13 @@ export class ScalesPhase {
                 band.paddingOuter = given.padding;
             }
         }
+        // A sort by what the categories hold is read here, off the rows; the axis then draws from its domain.
+        if (CategoryOrder.isDeclarative(band.sort)) {
+            const order = band.domain ? undefined : CategoryOrder.of(band.sort, state, axis);
+            delete band.sort;
+            if (order)
+                band.domain = order;
+        }
         if (this.keepsDataOrder && !band.domain) {
             band.domain = [...new Set(ProcessedPositions.values(processed, axis))];
         }

package/dist/phases/sharedScales/SharedScalesPhase.d.ts

@@ -2,7 +2,7 @@ import { ScalesPhase } from '../scales/ScalesPhase';
 import type { PlotAxes } from '../data/PlotAxes';
 import type { AxisChannelName } from '../../types/layout/mapping';
 import type { FacetStageState, PhaseStage, ProcessedData, SharedAxisValues, SharedScalesOptions } from '../../types/phases';
-import type { AxisBasedScalesConfig } from '../../types/layout/scales';
+import type { AxisBasedScalesConfig, NiceOption } from '../../types/layout/scales';
 /** One channel's shared scale: its domain, and whether svelteplot may still round it. */
 type SharedScale = {
     domain: unknown[];
@@ -14,7 +14,8 @@ type SharedScalesState = FacetStageState & {
     processedData?: ProcessedData;
     markers?: object[];
     scales?: Partial<Record<AxisChannelName, {
-        niceTolerance?: number;
+        nice?: NiceOption;
+        sort?: unknown;
     }>>;
     sharedScales?: Record<string, AxisBasedScalesConfig<never>>;
 };

package/dist/phases/sharedScales/SharedScalesPhase.js

@@ -1,5 +1,6 @@
 import { ProcessedPositions } from '../transforms/ProcessedPositions';
 import { NiceTicks } from '../../layout/scales/NiceTicks';
+import { CategoryOrder } from '../scales/CategoryOrder';
 import { ScalesPhase } from '../scales/ScalesPhase';
 import { Pipeline } from '../Pipeline';
 import { PANEL_KEY, FacetPanels } from '../facet/FacetPanels';
@@ -39,7 +40,9 @@ export class SharedScalesPhase {
         // A symmetric axis has no domain but the one the kind's "scales" phase gives it.
         const fromPhase = new Set([
             ...(this.#options?.fromScalesPhase ?? []),
-            ...this.#scales.symmetricAxes(state)
+            ...this.#scales.symmetricAxes(state),
+            // A category axis ordered by what its categories hold takes the order the "scales" phase reads off every row.
+            ...(state.axes?.bands ?? []).filter((axis) => CategoryOrder.isDeclarative(state.scales?.[axis]?.sort))
         ]);
         const layout = {
             band: [...(state.axes?.bands ?? [])],
@@ -60,7 +63,7 @@ export class SharedScalesPhase {
             const values = members
                 ? members.map((panel) => SharedScalesPhase.buildPanelAxisValues(state, panel, layout))
                 : [SharedScalesPhase.buildPanelAxisValues(state, undefined, layout)];
-            return SharedScalesPhase.buildSharedAxisScale(values, channel, state.scales?.[channel]?.niceTolerance);
+            return SharedScalesPhase.buildSharedAxisScale(values, channel, NiceTicks.toleranceOf(state.scales?.[channel]?.nice));
         };
         const cache = new Map();
         const scalesOf = (place) => {

package/dist/phases/statistics/Statistics.d.ts

@@ -1,4 +1,5 @@
 import type { StatisticSource } from '../../types/phases/statistics/source';
+import type { AxisChannelName } from '../../types/layout/mapping';
 import type { Series } from '../../types/plots/data/common';
 import type { StatisticConfig } from '../../types/layout/statistics';
 import type { AxisBasedMarkersConfig } from '../../types/markers/common';
@@ -10,12 +11,13 @@ import type { AxisBasedMarkersConfig } from '../../types/markers/common';
 export declare class Statistics {
     #private;
     /**
-     * Builds one {@link StatisticConfig} over a data source into the marker it
-     * renders as - `regression`/`bollinger` construct their marker directly
-     * (svelteplot resolves the curve/band itself, at render time); the others
-     * compute their rows first.
+     * Builds one {@link StatisticConfig} over a data source into the markers it
+     * renders as. Every statistic's own `build` returns a list, since one can
+     * draw several markers (`deviation`'s band and rule); `regression`/`bollinger`
+     * construct their marker directly (svelteplot resolves the curve/band
+     * itself, at render time), the others compute their rows first.
      */
-    static buildMarker<T extends Record<string, unknown>>(source: StatisticSource<T>, config: StatisticConfig): AxisBasedMarkersConfig;
+    static buildMarker<T extends Record<string, unknown>>(source: StatisticSource<T>, config: StatisticConfig): AxisBasedMarkersConfig[];
     /**
      * Resolves a plot's own top-level `statistics` prop against its already-built
      * `Series<T>[]` (every kind has this before `mapping` runs - see
@@ -30,6 +32,8 @@ export declare class Statistics {
     static buildForPlot<T extends Record<string, unknown>>(args: {
         series: Series<T>[];
         statistics: StatisticConfig[] | undefined;
+        /** The axis the plot measures along, from its `PlotAxes`. */
+        valueAxis?: AxisChannelName;
         colorFor?: (seriesName: string) => string;
     }): AxisBasedMarkersConfig[];
     /**
@@ -49,5 +53,5 @@ export declare class Statistics {
      */
     static expandMarkers<TMarker extends {
         type: string;
-    }, T extends Record<string, unknown>>(markers: TMarker[], fallbackData: T[]): (TMarker | AxisBasedMarkersConfig)[];
+    }, T extends Record<string, unknown>>(markers: TMarker[], fallbackData: T[], valueAxis?: AxisChannelName): (TMarker | AxisBasedMarkersConfig)[];
 }