@pond-ts/react 0.50.0 → 0.52.0

package/CHANGELOG.md

@@ -8,7 +8,9 @@ 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.50.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
 [0.48.1]: https://github.com/pond-ts/pond/compare/v0.48.0...v0.48.1
@@ -50,6 +52,190 @@ 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
+
+- **charts:** **`trackerPosition` is now a _followed_ position, not a hard pin —
+  enabling cross-chart cursor sync.** A live local hover wins over
+  `trackerPosition`, so the chart under the pointer shows its own cursor while
+  any chart without a local pointer follows the controlled time (mapped through
+  its own `xScale`, so it's correct across different zooms). This makes
+  **multi-chart dashboard cursor sync** fall out of the plain props: give every
+  `<ChartContainer>` the same `trackerPosition={sharedTime}` and set `sharedTime`
+  from each one's `onTrackerChanged` (clear it to `null` on the group's
+  `onPointerLeave`) — no "which chart is active" bookkeeping. **Behaviour
+  change:** previously a numeric `trackerPosition` overrode local hover, and
+  `trackerPosition={null}` force-hid the cursor; now `null` and `undefined` are
+  equivalent ("no controlled position") and a hovered chart always tracks its
+  pointer. To force a chart to never show a cursor, use `cursor="none"`. See the
+  "Synced cursors across charts" story. No type change (`number | null`).
+- **charts:** **Line / area draw is ~3× faster on stroke-bound frames**
+  (PND-AFFINE / PND-GRADX; 2026-07 external-bench profile). When the curve is
+  linear and both scales are affine (every y axis is `scaleLinear`; x is
+  `scaleLinear` / `scaleTime` / the gap-free default time axis), `drawLine` and
+  `drawArea` now map points with an inline `k·v + b` over the typed arrays
+  instead of a per-point d3-scale closure + d3-shape generator — a **visually
+  identical** draw (guarded by the decimation pixel-identity and per-layer
+  visual-regression e2e). A real-gap trading-time axis, or a non-linear curve,
+  transparently keeps the exact d3 path. Measured on a JS-only micro-bench
+  (`scripts/perf-affine.mjs`): line 1M 60.4 → 19.0 ms (3.2×), area 1M 132 →
+  38 ms (3.5×). Separately, the area fill gradient's full-series value extent is
+  now memoized per column buffer, so a y-zoom / pan repaint no longer re-walks
+  the whole series to find the gradient span. No API change.
+- **charts:** **A y-zoom / y-autorange repaint no longer re-decimates line /
+  area layers** (PND-DECKEY; same 2026-07 profile, finding 3). The M4
+  decimation output is a pure function of the source data, x-domain, device
+  width, threshold, and session breaks — it never reads the y-scale — so it is
+  identical across every y-only frame. `drawLine` / `drawArea` now memoize the
+  cull+decimate result per source series (one entry, keyed on the x-scale
+  object + width + threshold + breaks), so a y-zoom / live y-autorange frame
+  reuses the prior polyline instead of re-binning O(N) points; a pan / x-zoom
+  mints a fresh x-scale and correctly recomputes. Measured
+  (`scripts/perf-deckey.mjs`): the ~5 ms/frame decimation walk at 1M points is
+  eliminated on every y-only frame. No API change.
+
+### Added
+
+- **charts:** **`<BarChart decimate>` — dense column charts now decimate**
+  (PND-MARKDEC; 2026-07 profile, finding 4 — "column dead by 5M"). **Default
+  `true`**: once the visible **single-series** bars are denser than ~2 per device
+  pixel (each slot < ~1px), they're drawn as one per-column **envelope** rect —
+  the exact painted union `[min(value, baseline), max(value, baseline)]` of each
+  pixel column — instead of every bar, so a 100k–5M-bar column chart stays
+  interactive. **Visually lossless** at that density (a perf knob, not a style);
+  interaction still reads the source bars (`barAt`), and the per-bar
+  selection/hover highlight is suppressed only when decimated (a <1px bar's ring
+  isn't visible anyway). `decimate={false}` draws every bar; `{ threshold }`
+  tunes the samples-per-pixel factor. No-op for a stacked / multi-group
+  histogram (the low-count categorical path). `drawBars` now returns
+  `LayerDrawStats` (visible via `onDrawStats`). Measured
+  (`scripts/perf-markdec.mjs`, JS-only): the bar draw at 5M points drops
+  485 → 26 ms (18.9×), 100k drops 9.7 → 0.9 ms (10.7×) — with the larger
+  rasterization win on top, browser-side.
+- **charts:** **`panZoom` is now a three-way mode + a `bounds` extent.**
+  `<ChartContainer panZoom>` takes `'none'` / `'pan'` / `'panZoom'` (drag-only
+  vs. drag+wheel), with the old boolean kept as shorthand (`true` ⇒ `'panZoom'`,
+  `false` ⇒ `'none'`) — so existing charts are unchanged. A new `bounds`
+  (`[min, max]`) prop fences pan/zoom to an **outer** extent (panning into an
+  edge stops there keeping its span; zoom-out is capped at the whole span), the
+  companion
+  to the existing `minDuration` zoom-in floor — together they pin the reachable
+  window between an inner and outer bound. On a trading-time axis `bounds`
+  clamps in wall-clock ms. Purely additive; no type narrowing.
+- **charts:** **Draw-cost + decimation observability** — `<ChartContainer
+onDrawStats>` (PND-DECOBS; dashboard A/B friction, 2026-07-21). Fires a
+  `DrawStatsFrame` once per row-canvas repaint (keyed by an opaque `rowKey` for
+  multi-row attribution), one `LayerDrawInfo` per layer carrying its `as`,
+  measured `drawMs`, and — for a decimating layer (line / area / band / candle /
+  box) — `sourceCount` / `drawnCount` / `decimated`.
+  Compare `drawnCount` to `sourceCount` to see whether M4 engaged; read `drawMs`
+  for per-layer render cost. **Zero-overhead when unused** — the render loop
+  skips per-layer timing entirely unless a consumer subscribes. New exports:
+  `DrawStatsFrame`, `LayerDrawInfo`.
+
+### Fixed
+
+- **charts:** hovering no longer repaints the row data canvas on every cursor
+  mousemove. The container frame minted a fresh `timeRange` array identity per
+  rebuild (and the frame rebuilds per cursor move), which the Layers draw
+  callback — depending on `container.timeRange` — read as a domain change:
+  each hover frame re-fired the canvas draw effect, including per-layer M4
+  re-decimation (measured 105 repaints per 122 mousemove events; with
+  `decimate` off, hover fell to ~10 fps). The tuple is now identity-stable on
+  its endpoints, restoring the SVG-overlay cursor contract (0 repaints, full
+  frame rate while hovering). Found running uPlot's bench protocol against
+  pond-charts; guarded by a new hover-sweep perf invariant in
+  `e2e/perf-invariants.spec.ts`.
+- **charts:** hovering no longer re-renders cursor-independent components
+  (both `YAxis`, `Bar`/`Box`). The cursor position was a `ContainerFrame`
+  field, so every mousemove re-identified the whole (~50-field) frame and
+  re-rendered **all** its context consumers — even ones that never read the
+  cursor. The per-move cursor state (`cursorX`/`cursorY`/`cursorRowKey`) now
+  lives in a dedicated `CursorContext`; the frame stays identity-stable across
+  a hover, so only the genuine cursor consumers (the `Layers` overlay,
+  `XAxis` crosshair pill, `Legend` values) re-render. Measured: 4 → 2 React
+  commits per mousemove, ~25% less hover script time on the uPlot-bench
+  workload (the win scales with axis/row count). No API change — the split
+  types are internal (`PND-HOVCTX`, follow-up to the repaint fix above).
+- **charts:** corrected the `@pond-ts/charts` package-header doc comment, which
+  described a "chunked Path2D cache" render stage that was explored and
+  **deferred**, never built (it doesn't help the pan case, which re-decimates
+  every frame). The stale comment had misled a consumer's perf investigation.
+
 ## [0.50.0] — 2026-07-21
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/react",
-  "version": "0.50.0",
+  "version": "0.52.0",
   "description": "React hooks for pond-ts live time series",
   "license": "MIT",
   "repository": {
@@ -33,7 +33,7 @@
     "test:runtime": "vitest run"
   },
   "peerDependencies": {
-    "pond-ts": "^0.50.0",
+    "pond-ts": "^0.52.0",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {