@pond-ts/react 0.20.0 → 0.22.0

package/CHANGELOG.md

@@ -7,13 +7,116 @@ 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.20.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.22.0...HEAD
+[0.22.0]: https://github.com/pjm17971/pond-ts/compare/v0.21.0...v0.22.0
+[0.21.0]: https://github.com/pjm17971/pond-ts/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/pjm17971/pond-ts/compare/v0.19.0...v0.20.0
 [0.19.0]: https://github.com/pjm17971/pond-ts/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/pjm17971/pond-ts/compare/v0.17.1...v0.18.0
 
 ## [Unreleased]
 
+## [0.22.0] — 2026-06-12
+
+### Changed
+
+- **`asTime` / `asTimeRange` / `asInterval` are now column-native.** They
+  reinterpret the key's kind (a "rekey") straight off the existing key's
+  `begin` / `end` buffers instead of materializing events — value columns pass
+  through by reference. `asTimeRange` and `asTime` with `begin` / `end` reuse
+  the key buffer zero-copy (≈ **9×** faster on a build → rekey → read pipeline);
+  `asTime({ at: 'center' })` adds one midpoint pass; `asInterval` builds the
+  label column (string → `StringColumn`, number → `Float64Column`, inferred
+  from the first label and required consistent across rows). `asTime` with
+  `center` / `end` throws if anchoring a source with overlapping extents would
+  produce a non-monotonic time axis (preserving the prior validation — `begin`
+  is always sorted and is exempt).
+- **Breaking: `asInterval`'s label function now receives the interval's
+  `TimeRange` (its `[begin, end]` extent) and index — not the whole `Event`.**
+  The canonical form is unchanged: `series.asInterval(range => range.begin())`
+  works exactly as before (both `Event` and `TimeRange` expose `begin()` /
+  `end()`). Only a label fn that read a _value column_ off the event (e.g.
+  `event => event.get('label')`) needs rewriting — compute the label before
+  `asInterval`, or derive it from the extent. The constant form
+  (`asInterval('bucket')` / `asInterval(42)`) is unaffected. (Pre-1.0 minor;
+  this is the change that lets the function form stay on the columnar path.)
+
+### Fixed
+
+- **`mapColumns` rejects a non-finite numeric result at write.** A mapper on a
+  `number` column that returns `NaN` or `±Infinity` now throws a `RangeError`,
+  consistent with construction intake (which already rejects non-finite
+  numbers). Previously the value was packed into the column, where the reduce
+  fast path and the row path could disagree on the same bucket (e.g.
+  `aggregate('min')` returning a different result depending on which path ran).
+  A stored `NaN` is still a defined value the mapper sees — map it to a finite
+  number, or to `undefined` (missing), to clean it. (Closes a hole introduced
+  alongside `mapColumns` in 0.21.0.)
+- **`aggregate('stdev')` is now numerically stable and path-independent.** The
+  bucketed row path (`bucketState`) used a one-pass `sq/n − mean²` accumulator
+  that cancels catastrophically on near-equal large-magnitude values —
+  returning `0` (e.g. `[1e10, 1e10+1, 1e10+2, 1e10+3]` → `0` instead of
+  `≈1.118`), or a negative variance whose `sqrt` is `NaN` that the validating
+  constructor then rejected with a throw. Because the columnar fast path is
+  all-or-nothing, an unrelated mapping (e.g. a `count` over a string column)
+  could silently flip the _same_ series' stdev. All three batch paths (`reduce`,
+  `reduceColumn`, `bucketState`) now share **one Welford recurrence** — O(1) per
+  element, no buffer (so the live aggregation path that shares `bucketState`
+  stays O(1)), `m2 ≥ 0` by construction — so they agree regardless of magnitude.
+  (Even the prior two-pass `Σv/n`-then-deviations drifted ~8.7% from the true
+  value at `2^52`, where the summed mean rounds — so unifying on Welford, not
+  two-pass, was necessary.) **Correction:** 0.21.0's columnar `aggregate()` fast
+  path (#186) was described as "signature + semantics unchanged", but it did
+  change released `stdev` output for fast-path-qualifying aggregates; this fix
+  makes every path agree. (`rolling`/`smooth` stdev keep the one-pass form for
+  now — a separate, deferred item.)
+
+## [0.21.0] — 2026-06-11
+
+### Added
+
+- **`TimeSeries.mapColumns({ col: (value) => newValue })`** — a per-cell column
+  value transform. The column-scoped counterpart of the event-based `map()`:
+  where `map(schema, event => newEvent)` rebuilds whole rows through an
+  arbitrary closure (and can change the schema/key), `mapColumns` transforms
+  individual columns' values in place, reading the columns directly (no
+  per-row `Event`) so it stays on the fast columnar path. Same kind in/out
+  (number→number, string→string, …), so the schema is unchanged; missing cells
+  carry (the mapper isn't called on `undefined`). ~5–6× faster than the
+  `map()` workaround on a build → transform → read pipeline.
+
+### Changed
+
+- **`select` / `rename` / `slice` / `cumulative` / `diff` / `rate` /
+  `pctChange` / `fill` / `shift` / `collapse` are now column-native.** They
+  reshape the columnar store directly instead of materializing events, so the
+  columnar construction win is preserved through these transforms — build →
+  transform → read pipelines run several× faster (~7–10× for `select` /
+  `rename` / `slice`; ~5–7× for the `cumulative` / `diff` / `rate` / `fill` /
+  `shift` / `collapse` folds). No API change for type-correct callers (one
+  narrow `fill` behavior change is noted under Fixed). `cumulative` / `diff` /
+  `rate` / `pctChange` / `fill` / `shift` / `collapse` are also the first
+  operators extracted into `batch/operators/` (internal refactor); `fill`
+  rebuilds only the columns it actually changes; `slice` normalizes
+  `Array.prototype.slice` semantics onto a zero-copy `withRowRange` reshape;
+  `collapse` reads only the keyed columns and passes the kept columns through
+  by reference.
+
+### Fixed
+
+- **`rename` now rejects target-name collisions** (e.g. renaming `a` → `b`
+  when `b` already exists) with a clear error, instead of silently producing a
+  duplicate-named schema. Also fixes a prototype-chain bug where a column named
+  `toString` (or another `Object.prototype` member) could be corrupted during
+  a rename.
+- **`fill` now throws on a kind-mismatched literal** (e.g.
+  `fill({ value: 'banana' })` where `value` is numeric — type-allowed because
+  mapping values are the broad `FillStrategy | ScalarValue`) with a clear
+  `RangeError` naming the column, instead of silently producing an
+  internally-inconsistent series (the old events path returned the literal
+  from `.get()` while the numeric column read `NaN`). The throw is
+  gap-dependent — it only fires when the literal would actually be placed.
+
 ## [0.20.0] — 2026-06-04
 
 Two internal performance improvements driven by the dashboard experiment at

package/package.json

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