@pond-ts/charts 0.50.0 → 0.52.0

package/dist/context.js

@@ -1,5 +1,13 @@
 import { createContext } from 'react';
 export const ContainerContext = createContext(null);
+/** No-cursor default, so a consumer outside a provider reads "not hovering"
+ *  rather than needing a null guard (the container always provides a real one). */
+const NO_CURSOR = {
+    cursorX: null,
+    cursorY: null,
+    cursorRowKey: null,
+};
+export const CursorContext = createContext(NO_CURSOR);
 export const RowContext = createContext(null);
 export const LayersContext = createContext(null);
 //# sourceMappingURL=context.js.map

package/dist/data.d.ts

@@ -13,6 +13,14 @@ import type { SeriesSchema, TimeSeries, ValueSeriesSchema } from 'pond-ts';
  * column materialized to a `Float64Array`. `x` is **monotonically ascending**
  * (a series' key column is sorted) — the draw layers and the viewport bisect
  * (`culling.ts`) rely on it, as `sessionRuns` already does.
+ *
+ * **Neither buffer may be mutated in place** — not just `x`. The area fill
+ * gradient's value extent is memoized on the `y` buffer's identity
+ * (`columnFiniteExtent`, [PND-GRADX]), so a consumer that mutated a live `y`
+ * buffer's contents across frames instead of materializing a fresh column would
+ * read a stale gradient span (no crash, just a wrong shade). The built-in
+ * readers always allocate a fresh exactly-sized buffer per materialization, so
+ * buffer identity tracks data identity — hold to that.
  */
 export interface ChartSeries {
     readonly x: Float64Array;

package/dist/decimate.d.ts

@@ -45,7 +45,7 @@
  * `xScale` and breaks its subpath on `NaN`) — decimation is a pre-pass that
  * shrinks the point count, not a second renderer.
  */
-import type { ChartSeries, BandSeries, OhlcSeries, BoxSeries } from './data.js';
+import type { ChartSeries, BandSeries, OhlcSeries, BoxSeries, BarSeries } from './data.js';
 import type { Scale } from './line.js';
 /**
  * A line layer's M4-decimation control (`<LineChart decimate>`). **Default
@@ -152,6 +152,42 @@ export declare function mergeGapEdges(edges: Float64Array, gaps: number[], lo: n
  * series into per-session subpaths at exactly those instants.
  */
 export declare function decimateM4(cs: ChartSeries, xScale: Scale, ctx: CanvasRenderingContext2D, k?: number, boundaries?: readonly number[]): ChartSeries;
+/**
+ * Cull `source` to the visible window and M4-decimate it, **memoized per source
+ * series** so a y-only repaint reuses the prior frame's polyline instead of
+ * re-binning O(N) points. The decimation output is a pure function of the source
+ * data, the x mapping, the device width, the threshold, and the session breaks —
+ * it **never reads the y-scale** — so it is byte-identical across every y-zoom /
+ * y-autorange frame (the ~19% mountain@1M recompute the 2026-07 bench profile
+ * flagged, finding 3: an x-only computation re-run under y-only invalidation).
+ *
+ * The cache holds **one** entry per source: a y-only frame matches the stored
+ * key → hit; a pan / x-zoom mints a fresh `xScale` (`ChartContainer` keys the
+ * scale on the x-domain, not the y-domain — so the scale object is stable under
+ * y-zoom and fresh under pan) → miss, and the single entry is overwritten. So it
+ * **wins on y-only frames and is a no-op under pan** — bounded, never growing,
+ * the same reasoning that made Path2D caching not help pan ([PND-DECIM]).
+ *
+ * Correctness rests on the {@link ChartSeries} immutability contract: a data
+ * change mints a **new** source object (the layer re-materializes its column),
+ * so a stale entry can't be read. `boundaries` is compared by **identity** — the
+ * `<LineChart>` session-break instants are `useMemo`-stable across frames; a
+ * caller passing a fresh array each frame simply misses (safe, no benefit). `W`
+ * is `deviceBucketCount(ctx)` so a DPR / resize change re-keys. Keying on the
+ * `xScale` object (not just its `[domain, W]`) is what keeps the hit correct on
+ * a **non-affine** trading-time scale too — same scale object ⇒ identical
+ * pixel-column edges.
+ *
+ * Returns `{ series, decimated }`: `series` is the M4 polyline, or the plain
+ * culled slice when the window is too sparse to decimate ({@link decimateM4}
+ * no-ops); `decimated` says which (for the caller's draw-stats + session-run
+ * split). Callers pass the **pre-cull** source and skip their own cull — this
+ * function does it, so a cache hit skips the cull too.
+ */
+export declare function decimateM4Cached(source: ChartSeries, xScale: Scale, ctx: CanvasRenderingContext2D, k?: number, boundaries?: readonly number[]): {
+    series: ChartSeries;
+    decimated: boolean;
+};
 /**
  * Assemble the M4 polyline {@link ChartSeries} from the four binned channels.
  * Split out (pure, no canvas / pond deps) so the point emission is unit-tested
@@ -228,4 +264,84 @@ export declare function decimateOhlc(ohlc: OhlcSeries, xScale: Scale, ctx: Canva
  * reduces to `NaN` on every channel — `drawBox` skips it via `isFiniteBox`.
  */
 export declare function decimateBox(box: BoxSeries, xScale: Scale, ctx: CanvasRenderingContext2D, k?: number, visibleCount?: number): BoxSeries;
+/**
+ * One filled **envelope rect per device-pixel column** — the decimated form of a
+ * {@link BarSeries} ({@link decimateBars}). Each column `b` spans `[begin[b],
+ * end[b]]` in key space and fills the value range `[lo[b], hi[b]]`, i.e. the union
+ * of every bar in that column (their tops range over `[min, max]`, and each bar
+ * also reaches the baseline — so the union is `[min(minValue, baseline),
+ * max(maxValue, baseline)]`). An empty column carries `NaN` on `lo`/`hi` and draws
+ * nothing.
+ */
+export interface BarColumnEnvelope {
+    readonly begin: Float64Array;
+    readonly end: Float64Array;
+    readonly lo: Float64Array;
+    readonly hi: Float64Array;
+    readonly length: number;
+}
+/**
+ * Decimate a {@link BarSeries} to **one envelope rect per device-pixel column**
+ * ([PND-MARKDEC]) — the interval-mark analog of {@link decimateBand}, for the
+ * "column chart, dense in x" case (SciChart-suite finding 4: a bar column has no
+ * decimation path, so it falls off where line/area/candle don't). Once each bar's
+ * slot is narrower than ~1px (the visible bars exceed `k ×` the device-pixel
+ * column count), the individual rects overplot into a solid silhouette; this
+ * replaces them with the exact painted union: per column, `lo = min(minValue,
+ * baseline)` and `hi = max(maxValue, baseline)` — the bars' value range widened
+ * to include the baseline every bar reaches. Drawing one rect `[begin, end] ×
+ * [lo, hi]` per column reproduces that silhouette from O(W) rects instead of
+ * O(visible).
+ *
+ * Gates on the **visible** bar count (`visibleCount`, a bar's width is its slot —
+ * decimating a handful of deep-zoomed bars would render 1px slivers, the same
+ * trap the candle / box paths gate against). Returns `null` when decimation
+ * doesn't apply (below the visible-density threshold, domainless / non-invertible
+ * scale, no canvas width) — the caller then draws every visible bar. Bars are
+ * binned by their **`begin`** key (at this density `begin`/`end` sit in the same
+ * column); the envelope ignores per-bar `gapPx` and tiles the column (a few-px
+ * gap is invisible at <1px bars anyway — the standard decimation tradeoff).
+ * `baseline` is the resolved bar baseline in **value** units (from
+ * `resolveBarBaseline`), so the union is honest about the zero line.
+ */
+export declare function decimateBars(cs: BarSeries, xScale: Scale, ctx: CanvasRenderingContext2D, baseline: number, k?: number, visibleCount?: number): BarColumnEnvelope | null;
+/**
+ * Decimate a **uniform** scatter to one representative mark per occupied
+ * **pixel cell** ([PND-MARKDEC] scatter half) — the marks analog of
+ * {@link decimateBars}, but **2D**: scatter has no fill, so a line/bar's
+ * `[min, max]`-per-column envelope would erase interior points. Instead this
+ * bins the plane into `cellPx × cellPx` cells and keeps the **first** point in
+ * each occupied cell.
+ *
+ * **Why it's visually lossless (for uniform, opaque marks):** with `cellPx` set
+ * to the mark **radius**, any two points sharing a cell are at most `cellPx·√2 ≈
+ * 1.4·r` apart — less than `2·r` — so their discs overlap; drawing one paints
+ * (essentially) the pixels of both. Points in different cells are kept, so a
+ * sparse-in-y scatter reduces little (and stays exact); a dense blob collapses to
+ * ~`plotArea / cellPx²` marks regardless of N. The reduction is therefore an
+ * **unconditional** identity for overlapping uniform marks — the caller's job is
+ * only to decide when the O(visible) sweep is worth it (density gate) and that
+ * the marks are in fact uniform + opaque (data-driven size/colour or translucent
+ * fill must **not** decimate — see {@link isOpaqueColor}).
+ *
+ * `cs.x` is sorted, so the sweep visits columns left-to-right and only the
+ * **current** column's occupied rows need tracking (a `Set` cleared on each
+ * column change — bounded memory, O(visible) total). Positions are in CSS px
+ * (`xScale`/`yScale` output), matching the mark radius' units. `[vStart, vEnd)`
+ * is the pre-culled visible window (defaults to the whole series). Gaps
+ * (non-finite y) are skipped, like {@link drawScatter}.
+ */
+export declare function decimateScatter(cs: ChartSeries, xScale: Scale, yScale: Scale, cellPx: number, vStart?: number, vEnd?: number): ChartSeries;
+/**
+ * Whether `color` is fully opaque — the second precondition (beside
+ * {@link ResolvedEncoding.uniform}) for scatter decimation. A **translucent**
+ * fill accumulates opacity where marks overlap (that build-up _is_ the density
+ * signal), so collapsing overlaps would lighten the plot — decimation must not
+ * engage. Returns `false` only when it can **prove** alpha &lt; 1
+ * (`rgba(…, a<1)`, `#rrggbbaa` / `#rgba` with alpha &lt; full, or `transparent`);
+ * every other form (`#rgb` / `#rrggbb`, `rgb()`, a named colour, `hsl()`) is
+ * treated as opaque. Conservative in the safe direction: a colour it can't prove
+ * translucent still decimates, but the realistic translucent cases are caught.
+ */
+export declare function isOpaqueColor(color: string): boolean;
 //# sourceMappingURL=decimate.d.ts.map

package/dist/decimate.js

@@ -46,7 +46,8 @@
  * shrinks the point count, not a second renderer.
  */
 import { Float64Column } from 'pond-ts';
-import { scaleDomain } from './culling.js';
+import { affineOf } from './affine.js';
+import { scaleDomain, cullChartSeries } from './culling.js';
 /** The device-pixel bucket count for `ctx` — the backing buffer width, i.e.
  *  `plotWidthCss × DPR` (so buckets land at device-pixel resolution). Falls back
  *  to `0` when there is no sized canvas (a headless test ctx), which the caller
@@ -247,6 +248,74 @@ export function decimateM4(cs, xScale, ctx, k = 2, boundaries = []) {
     const { lo: mn, hi: mx, first, last, } = col.binBy(cs.x, edges, 'minMaxFirstLast');
     return m4Polyline(edges, mn, mx, first, last, buckets, breaks.length > 0 ? new Set(breaks) : undefined);
 }
+/**
+ * Stable empty boundary list for the (common) no-session-break decimation cache
+ * key — so an area / no-break line draw compares equal frame-to-frame instead of
+ * missing on a fresh default `[]`.
+ */
+const NO_BOUNDARIES = [];
+/**
+ * One-entry-per-source cache of the cull+M4-decimate result ([PND-DECKEY]),
+ * keyed on the source series (`WeakMap`) → the last `(xScale, W, k, boundaries)`
+ * it was drawn for. Evicts with the series (no leak); one entry per source keeps
+ * it bounded under pan (see {@link decimateM4Cached}).
+ */
+const m4Cache = new WeakMap();
+/**
+ * Cull `source` to the visible window and M4-decimate it, **memoized per source
+ * series** so a y-only repaint reuses the prior frame's polyline instead of
+ * re-binning O(N) points. The decimation output is a pure function of the source
+ * data, the x mapping, the device width, the threshold, and the session breaks —
+ * it **never reads the y-scale** — so it is byte-identical across every y-zoom /
+ * y-autorange frame (the ~19% mountain@1M recompute the 2026-07 bench profile
+ * flagged, finding 3: an x-only computation re-run under y-only invalidation).
+ *
+ * The cache holds **one** entry per source: a y-only frame matches the stored
+ * key → hit; a pan / x-zoom mints a fresh `xScale` (`ChartContainer` keys the
+ * scale on the x-domain, not the y-domain — so the scale object is stable under
+ * y-zoom and fresh under pan) → miss, and the single entry is overwritten. So it
+ * **wins on y-only frames and is a no-op under pan** — bounded, never growing,
+ * the same reasoning that made Path2D caching not help pan ([PND-DECIM]).
+ *
+ * Correctness rests on the {@link ChartSeries} immutability contract: a data
+ * change mints a **new** source object (the layer re-materializes its column),
+ * so a stale entry can't be read. `boundaries` is compared by **identity** — the
+ * `<LineChart>` session-break instants are `useMemo`-stable across frames; a
+ * caller passing a fresh array each frame simply misses (safe, no benefit). `W`
+ * is `deviceBucketCount(ctx)` so a DPR / resize change re-keys. Keying on the
+ * `xScale` object (not just its `[domain, W]`) is what keeps the hit correct on
+ * a **non-affine** trading-time scale too — same scale object ⇒ identical
+ * pixel-column edges.
+ *
+ * Returns `{ series, decimated }`: `series` is the M4 polyline, or the plain
+ * culled slice when the window is too sparse to decimate ({@link decimateM4}
+ * no-ops); `decimated` says which (for the caller's draw-stats + session-run
+ * split). Callers pass the **pre-cull** source and skip their own cull — this
+ * function does it, so a cache hit skips the cull too.
+ */
+export function decimateM4Cached(source, xScale, ctx, k, boundaries = NO_BOUNDARIES) {
+    const W = deviceBucketCount(ctx);
+    const cached = m4Cache.get(source);
+    if (cached !== undefined &&
+        cached.xScale === xScale &&
+        cached.W === W &&
+        cached.k === k &&
+        cached.boundaries === boundaries) {
+        return cached;
+    }
+    const culled = cullChartSeries(source, xScale);
+    const series = decimateM4(culled, xScale, ctx, k, boundaries);
+    const entry = {
+        xScale,
+        W,
+        k,
+        boundaries,
+        series,
+        decimated: series !== culled,
+    };
+    m4Cache.set(source, entry);
+    return entry;
+}
 /** Shared empty break-set for the common (no session-break) case. */
 const NO_BREAKS = new Set();
 /**
@@ -475,4 +544,175 @@ export function decimateBox(box, xScale, ctx, k = 2, visibleCount = box.length)
         ...(box.hasMedian !== undefined ? { hasMedian: box.hasMedian } : {}),
     };
 }
+/**
+ * Decimate a {@link BarSeries} to **one envelope rect per device-pixel column**
+ * ([PND-MARKDEC]) — the interval-mark analog of {@link decimateBand}, for the
+ * "column chart, dense in x" case (SciChart-suite finding 4: a bar column has no
+ * decimation path, so it falls off where line/area/candle don't). Once each bar's
+ * slot is narrower than ~1px (the visible bars exceed `k ×` the device-pixel
+ * column count), the individual rects overplot into a solid silhouette; this
+ * replaces them with the exact painted union: per column, `lo = min(minValue,
+ * baseline)` and `hi = max(maxValue, baseline)` — the bars' value range widened
+ * to include the baseline every bar reaches. Drawing one rect `[begin, end] ×
+ * [lo, hi]` per column reproduces that silhouette from O(W) rects instead of
+ * O(visible).
+ *
+ * Gates on the **visible** bar count (`visibleCount`, a bar's width is its slot —
+ * decimating a handful of deep-zoomed bars would render 1px slivers, the same
+ * trap the candle / box paths gate against). Returns `null` when decimation
+ * doesn't apply (below the visible-density threshold, domainless / non-invertible
+ * scale, no canvas width) — the caller then draws every visible bar. Bars are
+ * binned by their **`begin`** key (at this density `begin`/`end` sit in the same
+ * column); the envelope ignores per-bar `gapPx` and tiles the column (a few-px
+ * gap is invisible at <1px bars anyway — the standard decimation tradeoff).
+ * `baseline` is the resolved bar baseline in **value** units (from
+ * `resolveBarBaseline`), so the union is honest about the zero line.
+ */
+export function decimateBars(cs, xScale, ctx, baseline, k = 2, visibleCount = cs.length) {
+    if (!shouldDecimateCount(visibleCount, ctx, k))
+        return null;
+    const dom = scaleDomain(xScale);
+    if (dom === null || dom[1] <= dom[0])
+        return null;
+    const invert = scaleInvert(xScale);
+    const plotWidthCss = scaleRangeWidth(xScale);
+    if (invert === null || plotWidthCss === null)
+        return null;
+    const W = deviceBucketCount(ctx);
+    const edges = pixelEdges(invert, plotWidthCss, W);
+    // Per-column min/max of the bar values, binned by the bar's begin key — two O(n)
+    // walks, like decimateBand. An empty column reduces to NaN on both.
+    const col = new Float64Column(cs.y, cs.length);
+    const vMin = col.binBy(cs.begin, edges, 'min');
+    const vMax = col.binBy(cs.begin, edges, 'max');
+    const begin = new Float64Array(W);
+    const end = new Float64Array(W);
+    const lo = new Float64Array(W);
+    const hi = new Float64Array(W);
+    for (let b = 0; b < W; b += 1) {
+        begin[b] = edges[b];
+        end[b] = edges[b + 1];
+        const mn = vMin[b];
+        if (Number.isFinite(mn)) {
+            // Widen to the baseline so the rect spans exactly the painted union (each
+            // bar reaches the baseline). One-signed data ⇒ one edge is the baseline ⇒
+            // the rect is the tallest bar, unchanged.
+            lo[b] = Math.min(mn, baseline);
+            hi[b] = Math.max(vMax[b], baseline);
+        }
+        else {
+            lo[b] = NaN; // empty column — drawBars skips it
+            hi[b] = NaN;
+        }
+    }
+    return { begin, end, lo, hi, length: W };
+}
+/**
+ * Decimate a **uniform** scatter to one representative mark per occupied
+ * **pixel cell** ([PND-MARKDEC] scatter half) — the marks analog of
+ * {@link decimateBars}, but **2D**: scatter has no fill, so a line/bar's
+ * `[min, max]`-per-column envelope would erase interior points. Instead this
+ * bins the plane into `cellPx × cellPx` cells and keeps the **first** point in
+ * each occupied cell.
+ *
+ * **Why it's visually lossless (for uniform, opaque marks):** with `cellPx` set
+ * to the mark **radius**, any two points sharing a cell are at most `cellPx·√2 ≈
+ * 1.4·r` apart — less than `2·r` — so their discs overlap; drawing one paints
+ * (essentially) the pixels of both. Points in different cells are kept, so a
+ * sparse-in-y scatter reduces little (and stays exact); a dense blob collapses to
+ * ~`plotArea / cellPx²` marks regardless of N. The reduction is therefore an
+ * **unconditional** identity for overlapping uniform marks — the caller's job is
+ * only to decide when the O(visible) sweep is worth it (density gate) and that
+ * the marks are in fact uniform + opaque (data-driven size/colour or translucent
+ * fill must **not** decimate — see {@link isOpaqueColor}).
+ *
+ * `cs.x` is sorted, so the sweep visits columns left-to-right and only the
+ * **current** column's occupied rows need tracking (a `Set` cleared on each
+ * column change — bounded memory, O(visible) total). Positions are in CSS px
+ * (`xScale`/`yScale` output), matching the mark radius' units. `[vStart, vEnd)`
+ * is the pre-culled visible window (defaults to the whole series). Gaps
+ * (non-finite y) are skipped, like {@link drawScatter}.
+ */
+export function decimateScatter(cs, xScale, yScale, cellPx, vStart = 0, vEnd = cs.length) {
+    const cell = cellPx > 0 ? cellPx : 1;
+    // Affine fast path ([PND-AFFINE]) for the per-point pixel mapping the sweep
+    // needs — an inline `k·v + b` over the typed arrays instead of a d3-scale
+    // closure per point (each axis independently; a non-affine axis, e.g. a
+    // real-gap trading x, falls back to the exact scale call). Without this the
+    // sweep would re-introduce the per-point d3-scale cost the line/area paths
+    // shed, making the decimation's own cost dominate.
+    const ax = affineOf(xScale);
+    const ay = affineOf(yScale);
+    const outX = [];
+    const outY = [];
+    let curCol = Number.NaN;
+    const rows = new Set();
+    for (let i = vStart; i < vEnd; i += 1) {
+        const y = cs.y[i];
+        if (!Number.isFinite(y))
+            continue; // gap — no mark
+        const xv = cs.x[i];
+        const px = ax !== null ? ax.k * xv + ax.b : xScale(xv);
+        const col = Math.floor(px / cell);
+        if (col !== curCol) {
+            rows.clear();
+            curCol = col;
+        }
+        const py = ay !== null ? ay.k * y + ay.b : yScale(y);
+        const row = Math.floor(py / cell);
+        if (!rows.has(row)) {
+            rows.add(row);
+            outX.push(xv);
+            outY.push(y);
+        }
+    }
+    return {
+        x: Float64Array.from(outX),
+        y: Float64Array.from(outY),
+        length: outX.length,
+    };
+}
+/**
+ * Whether `color` is fully opaque — the second precondition (beside
+ * {@link ResolvedEncoding.uniform}) for scatter decimation. A **translucent**
+ * fill accumulates opacity where marks overlap (that build-up _is_ the density
+ * signal), so collapsing overlaps would lighten the plot — decimation must not
+ * engage. Returns `false` only when it can **prove** alpha &lt; 1
+ * (`rgba(…, a<1)`, `#rrggbbaa` / `#rgba` with alpha &lt; full, or `transparent`);
+ * every other form (`#rgb` / `#rrggbb`, `rgb()`, a named colour, `hsl()`) is
+ * treated as opaque. Conservative in the safe direction: a colour it can't prove
+ * translucent still decimates, but the realistic translucent cases are caught.
+ */
+export function isOpaqueColor(color) {
+    const c = color.trim().toLowerCase();
+    if (c === 'transparent')
+        return false;
+    // rgb/rgba/hsl/hsla, both syntaxes: legacy comma (`rgba(r,g,b,a)`) and modern
+    // slash (`rgb(r g b / a)` / `hsl(h s l / a)`). Extract the alpha either way.
+    const fn = /^(?:rgba?|hsla?)\(([^)]+)\)$/.exec(c);
+    if (fn) {
+        const body = fn[1];
+        const slash = body.split('/');
+        if (slash.length === 2) {
+            const a = parseFloat(slash[1].trim()); // modern: `… / <alpha>`
+            return !(Number.isFinite(a) && a < 1);
+        }
+        const parts = body.split(',').map((p) => p.trim());
+        if (parts.length >= 4) {
+            const a = parseFloat(parts[3]); // legacy: 4th component is alpha
+            return !(Number.isFinite(a) && a < 1);
+        }
+        return true; // 3-component rgb/hsl → opaque
+    }
+    const hex = /^#([0-9a-f]{3,8})$/.exec(c);
+    if (hex) {
+        const h = hex[1];
+        if (h.length === 8)
+            return parseInt(h.slice(6, 8), 16) === 255;
+        if (h.length === 4)
+            return parseInt(h[3] + h[3], 16) === 255;
+        return true; // #rgb / #rrggbb
+    }
+    return true; // named / unknown → opaque
+}
 //# sourceMappingURL=decimate.js.map

package/dist/encoding.d.ts

@@ -62,6 +62,15 @@ export interface ResolvedEncoding {
     radiusAt(i: number): number;
     /** This point's fill colour (base colour if unencoded / non-finite). */
     colorAt(i: number): string;
+    /**
+     * `true` when **neither** radius nor colour is data-driven — every mark is the
+     * same fixed size and colour (`radiusAt`/`colorAt` ignore their index). This is
+     * the precondition for lossless occupancy **decimation** (PND-MARKDEC scatter
+     * half): only same-size, same-colour marks can be collapsed where they overlap
+     * without changing the picture. A `{column, range}` on either channel makes it
+     * `false`, and the scatter draws every point.
+     */
+    readonly uniform: boolean;
 }
 /** A numeric column read into a `Float64Array` (gaps as NaN), by name. */
 export type ColumnReader = (column: string) => Float64Array;

package/dist/encoding.js

@@ -139,6 +139,10 @@ export function resolveEncoding(cs, baseRadius, baseColor, radius, color, readCo
             };
         }
     }
-    return { radiusAt, colorAt };
+    // Uniform iff both channels are fixed: radius a number/omitted and no colour
+    // encoding. Data-driven either side (`{column, range}`) makes every mark
+    // potentially distinct, so decimation must not collapse them.
+    const uniform = (radius === undefined || typeof radius === 'number') && color === undefined;
+    return { radiusAt, colorAt, uniform };
 }
 //# sourceMappingURL=encoding.js.map

package/dist/index.d.ts

@@ -3,9 +3,11 @@
  *
  * Canvas-rendered, streaming-first time-series charts with a
  * react-timeseries-charts-style declarative layout. The architecture (hard
- * layers: adapter → typed-array store → decimator → chunked Path2D cache →
- * canvas renderer → React shell) is documented in the charts RFC at
- * `docs/rfcs/charts.md`; the milestone plan lives in `PLAN.md`.
+ * layers: adapter → typed-array store → decimator → canvas renderer → React
+ * shell) is documented in the charts RFC at `docs/rfcs/charts.md`; the
+ * milestone plan lives in `PLAN.md`. (A Path2D path cache was explored and
+ * deferred — it doesn't help the pan case, which re-decimates every frame; see
+ * the [PND-DECIM] floor decision.)
  *
  * **M1 — rendering spine.** The layout shell + the first draw layer:
  * `<ChartContainer>` (time axis) → `<ChartRow>` (y-axis + canvas) →
@@ -75,4 +77,5 @@ export type { ChartThemeOverrides, VarReader } from './css-theme.js';
 export { useChartTheme } from './useChartTheme.js';
 export type { UseChartThemeOptions } from './useChartTheme.js';
 export type { CursorMode, TrackerInfo, TrackerSample, SelectInfo, } from './context.js';
+export type { DrawStatsFrame, LayerDrawInfo } from './context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,9 +3,11 @@
  *
  * Canvas-rendered, streaming-first time-series charts with a
  * react-timeseries-charts-style declarative layout. The architecture (hard
- * layers: adapter → typed-array store → decimator → chunked Path2D cache →
- * canvas renderer → React shell) is documented in the charts RFC at
- * `docs/rfcs/charts.md`; the milestone plan lives in `PLAN.md`.
+ * layers: adapter → typed-array store → decimator → canvas renderer → React
+ * shell) is documented in the charts RFC at `docs/rfcs/charts.md`; the
+ * milestone plan lives in `PLAN.md`. (A Path2D path cache was explored and
+ * deferred — it doesn't help the pan case, which re-decimates every frame; see
+ * the [PND-DECIM] floor decision.)
  *
  * **M1 — rendering spine.** The layout shell + the first draw layer:
  * `<ChartContainer>` (time axis) → `<ChartRow>` (y-axis + canvas) →

package/dist/line.d.ts

@@ -1,10 +1,24 @@
 import { type CurveFactory } from 'd3-shape';
 import type { ChartSeries } from './data.js';
 import type { LineStyle } from './theme.js';
+import type { LayerDrawStats } from './context.js';
 import { type DecimateOption } from './decimate.js';
+import { type Affine } from './affine.js';
 import { type GapMode } from './gaps.js';
 /** Maps a data value to a pixel coordinate (a d3 scale is assignable to this). */
 export type Scale = (value: number) => number;
+/**
+ * Stroke one run of `ys` (aligned index-for-index with `xs`) through the affine
+ * pixel maps `ax` / `ay` — the [PND-AFFINE] fast path. Replicates d3-shape's
+ * `curveLinear` + `.defined(Number.isFinite)` behaviour exactly: a non-finite
+ * value lifts the pen (the next finite point `moveTo`s a fresh subpath), a
+ * finite value `lineTo`s (or `moveTo`s when the pen is up), so a gap breaks and
+ * a lone point draws nothing — the same op sequence the generator emits, minus
+ * the per-point `scale()` + d3-shape closures. The caller brackets
+ * `beginPath`/`stroke`; `xs`/`ys` are the run (a `subarray` view, so index 0 is
+ * the run start). Used for lines and for the area outline.
+ */
+export declare function strokeAffinePolyline(ctx: CanvasRenderingContext2D, xs: Float64Array, ys: Float64Array, ax: Affine, ay: Affine): void;
 /**
  * The y-scale's domain lower bound (the axis floor) in pixels — where the
  * `step` / `fade` gap bridges drop to. The runtime `yScale` is a d3
@@ -51,7 +65,7 @@ export declare function yExtent(cs: ChartSeries): [number, number] | null;
  * the NaN **data** gaps (`gaps`) handled within each run. With no boundaries the
  * output is identical to a single-pass draw.
  */
-export declare function drawLine(ctx: CanvasRenderingContext2D, cs: ChartSeries, xScale: Scale, yScale: Scale, style: LineStyle, curve?: CurveFactory, gaps?: GapMode, gapConnectorOpacity?: number, boundaries?: readonly number[], decimate?: DecimateOption): void;
+export declare function drawLine(ctx: CanvasRenderingContext2D, cs: ChartSeries, xScale: Scale, yScale: Scale, style: LineStyle, curve?: CurveFactory, gaps?: GapMode, gapConnectorOpacity?: number, boundaries?: readonly number[], decimate?: DecimateOption): LayerDrawStats;
 /**
  * Split a sorted columnar x-axis into contiguous index runs `[start, endEx)`,
  * cutting wherever a `boundaries` instant falls in `(x[i-1], x[i]]` — i.e. a