@pond-ts/charts 0.51.0 → 0.52.0

package/CHANGELOG.md

@@ -8,7 +8,8 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 tag, so this file covers them all. Pre-1.0: minor bumps may include new features
 and type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pond-ts/pond/compare/v0.51.0...HEAD
+[Unreleased]: https://github.com/pond-ts/pond/compare/v0.52.0...HEAD
+[0.52.0]: https://github.com/pond-ts/pond/compare/v0.51.0...v0.52.0
 [0.51.0]: https://github.com/pond-ts/pond/compare/v0.50.0...v0.51.0
 [0.50.0]: https://github.com/pond-ts/pond/compare/v0.49.0...v0.50.0
 [0.49.0]: https://github.com/pond-ts/pond/compare/v0.48.1...v0.49.0
@@ -51,6 +52,79 @@ and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.52.0] — 2026-07-23
+
+### Changed
+
+- **core / financial:** **Market-scale studies are now typed-array fast**
+  (the "SMA/EMA at 1M bars costs hundreds of ms" report). Three cuts along
+  the same path, all behaviour-preserving (identical values, warm-ups,
+  missing-cell semantics, and rejection errors; every fast path falls back
+  to the original sweep when it doesn't apply):
+  - **`smooth('ema')` columnar fast path** — on a packed numeric source
+    column the EMA recurrence runs straight off the typed buffer into a
+    typed result column via trusted construction (key + untouched columns
+    pass through zero-copy), replacing the per-row Event/tuple rebuild +
+    full-series intake re-pack. 1M rows: **530 ms → 4.4 ms (~120×)**.
+  - **`rolling({ count })` numeric fast path** — an all-built-in numeric
+    mapping over packed sources feeds the shared incremental reducer states
+    directly from the typed buffers and writes snapshots into typed columns
+    (no per-row snapshot arrays, no boxed accumulators, no post-pass
+    assert/re-pack). 1M rows, `avg`: **135 ms → 32 ms (~4×)**.
+  - **financial kernel reads columns, not events** — `rollingColumns` /
+    `columnValues` now read study inputs/outputs off the public column API
+    instead of materializing `series.events` (an Event + data object per
+    row, ~400 ms of pure overhead at 1M rows).
+  - End-to-end at 1M bars: `ema()` **603 ms → 2.5 ms (~240×)**, `sma()`
+    **569 ms → 56 ms (~10×)**, `bollinger()` **748 ms → 162 ms (~4.6×)**.
+    Durable benchmarks: `packages/core/scripts/perf-smooth-ema.mjs`,
+    `packages/financial/scripts/perf-studies.mjs`.
+
+### Added
+
+- **core:** **`TimeSeries.fromArrow(table, options?)` — ingest a decoded Apache
+  Arrow `Table`.** pond stays zero-dependency: bring your own Arrow
+  (`tableFromIPC(...)`) and hand the `Table` in; the input is duck-typed against
+  a small structural surface (`ArrowTableLike` / `ArrowVectorLike` / …, all
+  exported). Ingest is the zero-copy path — every `Float64` column's backing
+  `Float64Array` is adopted as-is (`Float32`/int columns convert; int64 value
+  columns recombine BigInt-free), and the schema is derived from the Arrow
+  fields. The time key is converted **BigInt-free**: Arrow's idiomatic int64
+  timestamps are recombined from their two int32 halves rather than
+  `Number(bigint)` per row — measured **~11× faster** on the time column (0.6ms
+  vs 6.8ms at 500k rows; `scripts/perf-from-arrow.mjs`). Options: `time` (key
+  column, default the `'time'` field), `timeUnit` (default read from the Arrow
+  Arrow type family — a `Timestamp`'s raw-unit int64 is scaled by its
+  `TimeUnit`; `Date32`/`Date64` arrive already normalized to epoch-ms and pass
+  through; overridable), `columns` (subset, in order), `name`, `sort`. Numeric
+  **and string** columns are supported — string columns (Arrow
+  `Utf8`) become dict-encoded `StringColumn`s; any other Arrow type
+  (list/struct) throws, naming it. A null time key throws; numeric nulls map to
+  `NaN` and string nulls to missing.
+- **core:** **`TimeSeries.fromColumns` / `ValueSeries.fromColumns` now accept
+  `string` value columns** (previously numeric-only), packed to dict-encoded
+  `StringColumn`s (`null`/`undefined` → missing) — the shared columnar-ingress
+  engine now dispatches on the schema kind. Other value kinds (`boolean`,
+  arrays) still throw.
+- **charts:** **`<ScatterChart decimate>` — dense scatter plots now decimate**
+  (PND-MARKDEC scatter half — the last un-decimated mark type). **Default
+  `true`.** When the marks are **uniform** (fixed size + colour, no data-driven
+  `radius`/`color`), **opaque**, and denser than the pixel grid, overlapping
+  marks collapse to one representative per **mark-radius cell** via a 2D
+  pixel-**occupancy** sweep. Scatter has no fill, so a line/bar's per-column
+  `[min, max]` envelope would erase interior points — the occupancy grid keeps
+  one mark per occupied cell instead, which is **visually lossless** for uniform
+  opaque marks at that density (same-cell marks overlap). Interaction (hover /
+  click / tracker) still reads **every source point**; the per-point selection
+  ring + labels are suppressed only on the decimated (dense) path. A
+  **translucent** fill (density-encoded — overlap _should_ build up) or a
+  data-driven size/colour keeps the full draw. `decimate={false}` draws every
+  mark; `{ threshold }` tunes the trigger. The occupancy sweep uses the affine
+  fast path for the per-point pixel mapping. Measured (SciChart-suite
+  point-update, real browser): **100k 18 → 73 fps (4×)**, and the ladder now
+  runs to **10M** points (previously dead by 1M). `drawScatter` now returns
+  `LayerDrawStats` (visible via `onDrawStats`).
+
 ## [0.51.0] — 2026-07-22
 
 ### Changed

package/dist/ScatterChart.d.ts

@@ -1,6 +1,7 @@
 import { ValueSeries } from 'pond-ts';
 import type { SeriesSchema, TimeSeries, ValueSeriesSchema } from 'pond-ts';
 import { type ColorEncoding, type RadiusEncoding } from './encoding.js';
+import type { DecimateOption } from './decimate.js';
 export interface ScatterChartProps<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema> {
     /**
      * The source series. A `TimeSeries` scatters against the time axis; a
@@ -85,6 +86,16 @@ export interface ScatterChartProps<S extends SeriesSchema = SeriesSchema, VS ext
      * together, so a nudged point still selects.
      */
     offset?: number;
+    /**
+     * Collapse dense, **uniform** marks to one representative per pixel cell —
+     * lossless at that density, so a scatter of 100k+ points stays interactive.
+     * **Default `true`.** It engages only when the marks are a fixed size + colour
+     * (no data-driven `radius`/`color`), the fill is opaque, and the visible points
+     * are denser than the pixel grid; otherwise every point draws. Interaction
+     * (hover / click / tracker) always reads the source points. `decimate={false}`
+     * draws every mark; `{ threshold }` tunes the samples-per-pixel trigger.
+     */
+    decimate?: DecimateOption;
     /**
      * This layer's `<Legend>` row: `false` ⇒ no row (opt out), a string ⇒ the
      * row's display name. **Omitted ⇒ a row named by the layer's readout
@@ -126,5 +137,5 @@ export interface ScatterChartProps<S extends SeriesSchema = SeriesSchema, VS ext
  * </Layers>
  * ```
  */
-export declare function ScatterChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, column, as: semantic, id, axis, radius, color, label, offset, legend, index, }: ScatterChartProps<S, VS>): null;
+export declare function ScatterChart<S extends SeriesSchema = SeriesSchema, VS extends ValueSeriesSchema = ValueSeriesSchema>({ series, column, as: semantic, id, axis, radius, color, label, offset, decimate, legend, index, }: ScatterChartProps<S, VS>): null;
 //# sourceMappingURL=ScatterChart.d.ts.map

package/dist/ScatterChart.js

@@ -34,7 +34,7 @@ import { useSlotKey } from './use-slot-key.js';
  * </Layers>
  * ```
  */
-export function ScatterChart({ series, column, as: semantic, id, axis, radius, color, label, offset = 0, legend, index = 0, }) {
+export function ScatterChart({ series, column, as: semantic, id, axis, radius, color, label, offset = 0, decimate = true, legend, index = 0, }) {
     const container = useContext(ContainerContext);
     if (container === null) {
         throw new Error('<ScatterChart> must be rendered inside a <ChartContainer>');
@@ -131,7 +131,7 @@ export function ScatterChart({ series, column, as: semantic, id, axis, radius, c
                 : {
                     hitTest: (px, py, xScale, yScale) => hitTestScatter(cs, px, py, xScale, yScale, encoding, keyAt, id, seriesLabel, offset),
                 }),
-            draw: (ctx, xScale, yScale) => drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, labelAt, font, container.selected, id, offset),
+            draw: (ctx, xScale, yScale) => drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, labelAt, font, container.selected, id, offset, decimate),
         },
         axisId: axis,
         index,
@@ -148,6 +148,7 @@ export function ScatterChart({ series, column, as: semantic, id, axis, radius, c
         font,
         container.selected,
         offset,
+        decimate,
         axis,
         index,
     ]);

package/dist/decimate.d.ts

@@ -305,4 +305,43 @@ export interface BarColumnEnvelope {
  * `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 < 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,6 +46,7 @@
  * shrinks the point count, not a second renderer.
  */
 import { Float64Column } from 'pond-ts';
+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
@@ -606,4 +607,112 @@ export function decimateBars(cs, xScale, ctx, baseline, k = 2, visibleCount = cs
     }
     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/scatter.d.ts

@@ -2,7 +2,8 @@ import type { ChartSeries } from './data.js';
 import type { Scale } from './line.js';
 import type { ScatterStyle } from './theme.js';
 import type { ResolvedEncoding } from './encoding.js';
-import type { SelectInfo } from './context.js';
+import type { SelectInfo, LayerDrawStats } from './context.js';
+import { type DecimateOption } from './decimate.js';
 /**
  * Index of the point in `cs` **nearest** `time` by `|x − time|`, restricted to
  * finite points, or `-1` if none. `cs.x` is the sorted time axis, so a binary
@@ -52,7 +53,7 @@ export declare function scatterExtent(cs: ChartSeries): [number, number] | null;
 export declare function drawScatter(ctx: CanvasRenderingContext2D, cs: ChartSeries, xScale: Scale, yScale: Scale, style: ScatterStyle, encoding: ResolvedEncoding, keyAt: (i: number) => number, labelAt: ((i: number) => string | undefined) | undefined, font: {
     readonly family: string;
     readonly size: number;
-}, selected: SelectInfo | null, seriesId: string | undefined, offsetPx?: number): void;
+}, selected: SelectInfo | null, seriesId: string | undefined, offsetPx?: number, decimate?: DecimateOption): LayerDrawStats;
 /**
  * Hit-test plot-pixel `(qx, qy)` against the scatter's points — the topmost
  * point whose circle contains the click, or `null`. "Topmost" = the

package/dist/scatter.js

@@ -1,4 +1,5 @@
 import { visiblePointRange } from './culling.js';
+import { shouldDecimateCount, decimateScatter, isOpaqueColor, } from './decimate.js';
 /**
  * Scatter geometry + the canvas draw — pure, like {@link drawLine} /
  * {@link drawBand}, so the recording-mock tests assert the op sequence and the
@@ -117,7 +118,7 @@ export function scatterExtent(cs) {
  *                of the selection match. A point lights only when the selection's
  *                `id` matches, keyed to the sample by its `key`.
  */
-export function drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, labelAt, font, selected, seriesId, offsetPx = 0) {
+export function drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, labelAt, font, selected, seriesId, offsetPx = 0, decimate = true) {
     ctx.save();
     // The selection only lights up a point of *this* series; resolve the key once.
     // A no-id (non-selectable) layer passes `undefined` and never matches.
@@ -158,9 +159,64 @@ export function drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, lab
     const [vStart, vEnd] = pad > 0
         ? visiblePointRange(cs.x, cs.length, xScale, pad)
         : [w0Start, w0End];
+    // [PND-MARKDEC] scatter decimation. When the marks are **uniform** (fixed
+    // size + colour), **opaque**, and denser than the pixel grid, collapse each
+    // overlapping cluster to one representative per mark-radius cell (2D
+    // occupancy — {@link decimateScatter}). Visually lossless at that density, and
+    // O(visible). Interaction is unaffected ({@link hitTestScatter} still walks
+    // every source point); the selection ring and per-point labels are dropped on
+    // this path — both are illegible under a dense blob — matching the decimated
+    // bar path. Data-driven size/colour (`!encoding.uniform`) or a translucent
+    // fill (density-encoded, where overlap *should* build up) keep the full draw.
+    const visibleCount = vEnd - vStart;
+    const k = typeof decimate === 'object' && decimate.threshold !== undefined
+        ? decimate.threshold
+        : 2;
+    if (decimate !== false &&
+        encoding.uniform &&
+        shouldDecimateCount(visibleCount, ctx, k) &&
+        isOpaqueColor(encoding.colorAt(vStart))) {
+        const r = encoding.radiusAt(vStart);
+        const dec = decimateScatter(cs, xScale, yScale, Math.max(1, r), vStart, vEnd);
+        // Only take the decimated pass if it actually shrank the work (a sparse-in-y
+        // scatter over the threshold may not overlap — then the full draw is fine,
+        // and keeps its selection ring + labels). Compare against the **finite**
+        // visible count, not `vEnd - vStart`: `decimateScatter` skips gaps, so the
+        // raw span would falsely read as a reduction on any gappy series (and wrongly
+        // suppress the ring / labels with zero cell collisions).
+        let finite = 0;
+        for (let i = vStart; i < vEnd; i += 1)
+            if (isPoint(cs, i))
+                finite += 1;
+        if (dec.length < finite) {
+            ctx.fillStyle = encoding.colorAt(vStart);
+            const outlined = style.outlineWidth > 0;
+            if (outlined) {
+                ctx.lineWidth = style.outlineWidth;
+                ctx.strokeStyle = style.outline;
+            }
+            for (let j = 0; j < dec.length; j += 1) {
+                const px = xScale(dec.x[j]) + offsetPx;
+                const py = yScale(dec.y[j]);
+                ctx.beginPath();
+                ctx.arc(px, py, r, 0, Math.PI * 2);
+                ctx.fill();
+                if (outlined)
+                    ctx.stroke();
+            }
+            ctx.restore();
+            return {
+                sourceCount: cs.length,
+                drawnCount: dec.length,
+                decimated: true,
+            };
+        }
+    }
+    let drawn = 0;
     for (let i = vStart; i < vEnd; i += 1) {
         if (!isPoint(cs, i))
             continue;
+        drawn += 1;
         // `offsetPx` nudges the whole scatter in pixel space (zoom-stable) — for
         // pairing same-key marks (call/put at one strike) beside each other.
         const px = xScale(cs.x[i]) + offsetPx;
@@ -212,6 +268,10 @@ export function drawScatter(ctx, cs, xScale, yScale, style, encoding, keyAt, lab
         }
     }
     ctx.restore();
+    // Full draw (no decimation): every finite mark in the visible window drew.
+    // `drawnCount < sourceCount` here reflects viewport **culling**, not
+    // decimation (`decimated: false`).
+    return { sourceCount: cs.length, drawnCount: drawn, decimated: false };
 }
 /** Gap (px) between a point's edge and its label text. */
 const LABEL_GAP = 4;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/charts",
-  "version": "0.51.0",
+  "version": "0.52.0",
   "private": false,
   "description": "Canvas-rendered, streaming-first time-series charts for pond-ts",
   "license": "MIT",
@@ -38,8 +38,8 @@
     "perf": "PERF_BENCH=1 playwright test perf.spec.ts --workers=1"
   },
   "peerDependencies": {
-    "@pond-ts/react": "^0.51.0",
-    "pond-ts": "^0.51.0",
+    "@pond-ts/react": "^0.52.0",
+    "pond-ts": "^0.52.0",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {