@pond-ts/react 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -7,7 +7,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 file covers both packages. Pre-1.0: minor bumps may include new features and
 type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.24.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.26.0...HEAD
+[0.26.0]: https://github.com/pjm17971/pond-ts/compare/v0.25.0...v0.26.0
+[0.25.0]: https://github.com/pjm17971/pond-ts/compare/v0.24.0...v0.25.0
 [0.24.0]: https://github.com/pjm17971/pond-ts/compare/v0.23.0...v0.24.0
 [0.23.0]: https://github.com/pjm17971/pond-ts/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/pjm17971/pond-ts/compare/v0.21.0...v0.22.0
@@ -18,6 +20,73 @@ type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.26.0] — 2026-06-15
+
+### Changed
+
+- **`rolling(...)` now builds its output columns directly instead of
+  materializing events.** The rolling family was the last batch operator still
+  assembling a row per event and re-validating/re-packing it through the
+  constructor; it now reads the key axis and source values straight off the
+  columnar store and writes the result columns via trusted construction. The
+  result is unchanged for the common (scalar) cases. Measured: `rolling` with
+  `avg`/`sum` ~2.2–2.7× faster; rolling `stdev` on 100k events ~3.3–7.3×
+  (a 1-event window 45.7 ms → 6.3 ms); partitioned rolling ~1.8×.
+  `baseline` / `outliers` (which delegate to `rolling`) inherit the speedup.
+  - **Behavior note — `array` columns:** an identity-comparing reducer (`keep`,
+    or a custom reducer using `===` on the cell) on an `array`-kind source
+    column now compares the value stored in the column, not the original object
+    reference passed at construction. Two rows given the *same* array object
+    therefore read as distinct. Scalar columns (number / string / boolean) are
+    unaffected. A non-finite or wrong-kind reducer result is still rejected with
+    a `ValidationError`, exactly as the constructor's intake did.
+
+## [0.25.0] — 2026-06-15
+
+### Changed
+
+- **Reducers now treat non-finite numerics (`NaN` / `±Infinity`) as missing —
+  they are skipped — uniformly across every built-in reducer and all four
+  execution paths (`reduce`, the columnar fast path, `aggregate`/bucket, and
+  `rolling`/live).** Previously the paths disagreed on non-finite input: e.g.
+  `min`/`max` returned a position-dependent wrong extreme on the batch/columnar
+  paths but the true extreme on aggregate/rolling; `sum`/`avg` propagated
+  `NaN`. Non-finite can't enter via the row API (intake rejects it) — it only
+  arises inside computed columns (`cumulative` overflow, `diff`/`rate`
+  overflow, `collapse`, trusted construction) — so this only changes results
+  for those degenerate values, and makes every path agree. The three-layer
+  contract: **intake** stays strict (rejects non-finite), **computed writers**
+  stay permissive (pack honest non-finite), **reducers** are robust (skip it).
+  A standing parity-matrix test now pins all paths together. See
+  `docs/notes/reducer-nan-policy.md`. This also resolves the `aggregate('stdev')`
+  divergence class and the `min`/`max` NaN-laundering bug.
+- Internal: `Float64Column` gained an `allFinite` fast-path flag (data-derived
+  at construction, conservative-by-default) so reducers skip the per-element
+  finite check on provably-finite columns — keeping the policy's cost off the
+  hot path (min/max/count stay at their pre-policy speed).
+
+### Fixed
+
+- **`rolling(window, { x: 'stdev' })` is now numerically stable.** It was the
+  last batch stdev path still on the one-pass `Σx²/n − mean²`, which cancels
+  catastrophically on near-equal large values (`[1e10, 1e10+1, …]` → `0`
+  instead of ≈1.118, or a negative variance → `NaN`) and drifts on trending
+  data (cumulative distance, elevation). It now uses Welford's online variance
+  with an order-independent **delete** — deviation-space, so no cancellation,
+  and removal **by value**, which keeps it correct under the live layer's
+  `reorder`-mode eviction (a positional/FIFO remove would have broken it; the
+  documented "stdev is reorder-safe" contract is preserved). Rolling-stdev
+  values shift in the last ULPs (now correct); the path stays O(1) and within
+  run-noise of the old one-pass, and a single-element window now reports exactly
+  `0` at any magnitude. Like any subtractive sliding variance, evicting an
+  outlier far outside the residual spread loses precision — negligible until the
+  evicted point is ~1e7–1e8× the residual stdev, far beyond realistic data.
+- A standing differential-fuzz parity suite now pins every built-in reducer's
+  execution paths (columnar fast path vs `bucket` vs `rolling`, and the FIFO
+  sliding window vs a from-scratch recompute) against silent drift across
+  randomized magnitudes and window sizes — the class of bug behind the stdev
+  and `min`/`max` divergences.
+
 ## [0.24.0] — 2026-06-14
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/react",
-  "version": "0.24.0",
+  "version": "0.26.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.24.0",
+    "pond-ts": "^0.26.0",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {