pond-ts 0.23.0 → 0.25.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.23.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.25.0...HEAD
+[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
 [0.21.0]: https://github.com/pjm17971/pond-ts/compare/v0.20.0...v0.21.0
@@ -17,6 +19,99 @@ type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [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
+
+- **`TimeSeries.timeRange()` is now a columnar key-axis read instead of a
+  reduce over materialized events.** Behavior is unchanged, but the old
+  implementation materialized every `Event` on its first call — and because
+  `aggregate()` defaults its `range` to `series.timeRange()`, a one-shot
+  `aggregate()` paid full event materialization before the columnar fast
+  path could run, erasing the win. The new path reads the key column's
+  begin/end axis directly: O(1) for time-keyed series, a typed-array scan
+  for range/interval-keyed series, with no event materialization. Measured
+  on 1M rows: `timeRange()` itself ~407 ms → ~0.002 ms (time-keyed); cold
+  `aggregate()` with a defaulted range ~387 ms → ~6 ms (~63×). Every
+  `timeRange()` / `overlaps` / `contains` / `intersection` caller benefits.
+  (Audit v2 §3.3.)
+- **`aggregate()` now takes the columnar fast path when a mapping mixes
+  numeric reducers with `first` / `last`.** Previously a single `first` or
+  `last` column (they have no numeric `reduceColumn`) bailed the entire call
+  to the row path. They now qualify via a boundary scan — the first/last
+  _defined_ cell, on any column kind. Behavior is unchanged. The big
+  beneficiary is **partitioned `aggregate`**, which auto-injects a `'first'`
+  reducer for the partition column and so was excluded from the fast path on
+  every call (audit v2 §3.2/§3.3). Measured on 1M rows, flat
+  `{ cpu: 'avg', host: 'first' }`: ~37.7 ms → ~4.8 ms (~7.8×); the
+  pure-numeric path is unchanged. (The remaining `partitionBy` materialization
+  cost is addressed separately by the columnar `partitionBy` split.)
+- **`partitionBy(...)` now splits the columnar store directly instead of
+  materializing events.** `collect()` / the per-partition sugar methods
+  (`fill` / `diff` / `rolling` / …) and `toMap()` previously walked
+  `this.events` to bucket rows, then rebuilt each partition via `fromEvents`
+  (re-validating + re-packing) — silently re-paying the event-materialization
+  tax the columnar wave removed, and making `partitionBy(host).fill().collect()`
+  the #1 batch hotspot. They now group row indices off the store and gather
+  each partition via a zero-materialization columnar selection. Behavior is
+  unchanged (partition order, the `' undefined'` missing-key bucket, composite
+  keys, and declared `groups` all preserved). Measured on 100k rows / 64
+  partitions: `toMap()` ~389 → ~25 ns/row (~15×, no event materialization at
+  all); `diff().collect()` ~2×; `fill(hold).collect()` ~1.7× (the residual is
+  `TimeSeries.concat` still materializing to re-sort — a separate follow-up).
+  Declared-`groups` membership is validated by the same columnar scan, so that
+  path is materialization-free too (~331 → ~33 ns/row). **Behavior note:**
+  per-partition sub-series from `toMap()` / `apply()` now lazily materialize
+  their own `Event` objects rather than reusing the source's instances — cell
+  values are identical; only object identity differs (`collect()`, which
+  returns the source unchanged, is unaffected). (Audit v2 §3.2.)
+
 ## [0.23.0] — 2026-06-13
 
 ### Added

package/README.md

@@ -152,20 +152,24 @@ const points = series.sample({ reservoir: { size: 500 } }).toRows();
 
 ## Performance
 
-pond-ts is **7.6x faster** than pondjs on average across all comparable
-operations, with no regressions. The advantage grows with data size.
-
-| Category          | Speedup (N=16k) | Notes                                         |
-| ----------------- | --------------- | --------------------------------------------- |
-| **Aggregation**   | 25–32x          | O(N+B) bucketing vs O(N×B) Pipeline           |
-| **Alignment**     | 32x             | Forward cursor vs repeated binary search      |
-| **Rate/diff**     | 18x             | Direct array walk vs Pipeline materialization |
-| **Fill**          | 10–11x          | Single-pass vs Pipeline per strategy          |
-| **Transforms**    | 3–16x           | Pre-validated constructor skips re-validation |
-| **Construction**  | 7x              | Plain objects vs ImmutableJS wrapping         |
-| **Statistics**    | 7–9x            | Direct computation vs ImmutableJS iteration   |
-| **Serialization** | 4x              | Simpler internal representation               |
-| **Event access**  | 23x             | Array indexing vs ImmutableJS `get()`         |
+pond-ts is faster on **every** comparable operation, with no regressions —
+a **~17x** geometric-mean speedup across the measurable ops, plus a handful
+of transforms (`select` / `rename`) that are **effectively instant** (O(1)
+column rebinds, below the timer's resolution). The advantage grows with data
+size.
+
+| Category          | Speedup (N=16k)                                      | Notes                                         |
+| ----------------- | ---------------------------------------------------- | --------------------------------------------- |
+| **Rate**          | ~120x                                                | Single columnar walk vs Pipeline              |
+| **Fill**          | 77–87x                                               | Single columnar pass vs Pipeline per strategy |
+| **Aggregation**   | 57–82x                                               | O(N+B) bucketing vs O(N×B) Pipeline           |
+| **Statistics**    | 18–80x                                               | Typed-array reduce vs ImmutableJS iteration   |
+| **Alignment**     | 42x                                                  | Forward cursor vs repeated binary search      |
+| **Construction**  | 13x                                                  | Columnar intake vs ImmutableJS wrapping       |
+| **Chained**       | 8x                                                   | Derived constructors vs per-step Pipeline     |
+| **Transforms**    | `select`/`rename` instant; `collapse` 30x; `map` ~4x | Column reshapes vs Pipeline                   |
+| **Event access**  | 6x                                                   | Array indexing vs ImmutableJS `get()`         |
+| **Serialization** | 4x                                                   | Lightweight columnar representation           |
 
 See the [full benchmark results](website/docs/reference/benchmarks.mdx)
 for detailed numbers. Run locally:

package/dist/batch/aggregate-columns.d.ts

@@ -34,30 +34,6 @@ export type AggregateColumnSpec = {
  * same `mapping` shape produces the same schema.
  */
 export declare function normalizeAggregateColumns<S extends SeriesSchema>(schema: S, mapping: AggregateMap<S> | AggregateOutputMap<S>): AggregateColumnSpec[];
-/**
- * **Phase 4.7 step 3B — columnar fast path for time-keyed `aggregate()`.**
- * On sorted time-keyed data each bucket is a contiguous index range, so
- * when every mapped column is a built-in numeric reducer with a
- * `reduceColumn` fast path over a **packed `Float64Column`** source, each
- * bucket reduces straight off the typed-array slice — skipping the
- * `series.events` materialization and the per-cell `state.add` walk the
- * row path pays. Reuses the shipped step-3A `reduceColumn` kernels
- * (sum/min/max/avg 59–73×, stdev 35×, median/p95 3.4×) per bucket.
- *
- * Returns `null` — caller takes the unchanged row path — when any column
- * doesn't qualify: a custom-function reducer, a reducer with no
- * `reduceColumn` (`first` / `last` / `unique` / `top` / `samples`), or a
- * non-numeric / chunked / missing source column. All-or-nothing per call
- * keeps the bucket walk single-pass; mixed mappings fall back wholesale.
- *
- * `begins` is the key column's begin axis (sorted, identical row order to
- * the value columns — both read straight off the store). Bucketing
- * replicates the row path exactly: `cursor` carries across buckets, and a
- * bucket owns `[start, scan)` where `begins[i] ∈ [bucket.begin,
- * bucket.end)`. Empty buckets reduce an empty slice — the reducer's
- * empty-input result (the step-3A parity contract guarantees this matches
- * a zero-`add` bucket snapshot).
- */
 export declare function tryAggregateColumnarTimeKeyed<B extends {
     begin(): number;
     end(): number;

package/dist/batch/aggregate-columns.js

@@ -73,45 +73,34 @@ export function normalizeAggregateColumns(schema, mapping) {
     }
     return normalized;
 }
-/**
- * **Phase 4.7 step 3B — columnar fast path for time-keyed `aggregate()`.**
- * On sorted time-keyed data each bucket is a contiguous index range, so
- * when every mapped column is a built-in numeric reducer with a
- * `reduceColumn` fast path over a **packed `Float64Column`** source, each
- * bucket reduces straight off the typed-array slice — skipping the
- * `series.events` materialization and the per-cell `state.add` walk the
- * row path pays. Reuses the shipped step-3A `reduceColumn` kernels
- * (sum/min/max/avg 59–73×, stdev 35×, median/p95 3.4×) per bucket.
- *
- * Returns `null` — caller takes the unchanged row path — when any column
- * doesn't qualify: a custom-function reducer, a reducer with no
- * `reduceColumn` (`first` / `last` / `unique` / `top` / `samples`), or a
- * non-numeric / chunked / missing source column. All-or-nothing per call
- * keeps the bucket walk single-pass; mixed mappings fall back wholesale.
- *
- * `begins` is the key column's begin axis (sorted, identical row order to
- * the value columns — both read straight off the store). Bucketing
- * replicates the row path exactly: `cursor` carries across buckets, and a
- * bucket owns `[start, scan)` where `begins[i] ∈ [bucket.begin,
- * bucket.end)`. Empty buckets reduce an empty slice — the reducer's
- * empty-input result (the step-3A parity contract guarantees this matches
- * a zero-`add` bucket snapshot).
- */
 export function tryAggregateColumnarTimeKeyed(begins, getColumn, buckets, columns) {
     const plans = [];
     for (const spec of columns) {
         if (typeof spec.reducer !== 'string')
             return null; // custom function
         const def = resolveReducer(spec.reducer);
-        if (def.reduceColumn === undefined)
-            return null; // first/last/unique/...
         const source = getColumn(spec.source);
-        if (source === undefined ||
-            source.kind !== 'number' ||
-            source.storage !== 'packed') {
-            return null; // non-numeric / chunked / missing source
+        if (source === undefined)
+            return null; // missing source
+        if (def.definedBoundary !== undefined) {
+            // `first` / `last`: pick the first/last *defined* cell in the bucket
+            // via a boundary scan over any column kind / storage (`col.read(i)`).
+            // This is what lets a partitioned `aggregate` — whose auto-injected
+            // partition-column reducer is `'first'` — take the fast path instead
+            // of bailing the whole call for lack of a numeric `reduceColumn`.
+            plans.push({
+                kind: 'boundary',
+                column: source,
+                which: def.definedBoundary,
+            });
+            continue;
         }
-        plans.push({ column: source, reduce: def.reduceColumn });
+        if (def.reduceColumn === undefined)
+            return null; // unique / top / samples / keep
+        if (source.kind !== 'number' || source.storage !== 'packed') {
+            return null; // non-numeric / chunked numeric source
+        }
+        plans.push({ kind: 'reduce', column: source, reduce: def.reduceColumn });
     }
     const n = begins.length;
     let cursor = 0;
@@ -130,7 +119,41 @@ export function tryAggregateColumnarTimeKeyed(begins, getColumn, buckets, column
         const reduced = new Array(plans.length);
         for (let p = 0; p < plans.length; p += 1) {
             const plan = plans[p];
-            reduced[p] = plan.reduce(plan.column.sliceByRange(start, scan));
+            if (plan.kind === 'reduce') {
+                reduced[p] = plan.reduce(plan.column.sliceByRange(start, scan));
+            }
+            else if (plan.which === 'first') {
+                // First defined cell in [start, scan); scans past missing cells and
+                // past non-finite numeric cells (reducer non-finite policy,
+                // docs/notes/reducer-nan-policy.md — a NaN/±Inf numeric is "not a
+                // contributor", matching the row path's `defined` filter).
+                let value;
+                for (let i = start; i < scan; i += 1) {
+                    const cell = plan.column.read(i);
+                    if (cell === undefined)
+                        continue;
+                    if (typeof cell === 'number' && !Number.isFinite(cell))
+                        continue;
+                    value = cell;
+                    break;
+                }
+                reduced[p] = value;
+            }
+            else {
+                // Last defined cell in [start, scan); scans backward past missing and
+                // past non-finite numeric cells (see the 'first' branch above).
+                let value;
+                for (let i = scan - 1; i >= start; i -= 1) {
+                    const cell = plan.column.read(i);
+                    if (cell === undefined)
+                        continue;
+                    if (typeof cell === 'number' && !Number.isFinite(cell))
+                        continue;
+                    value = cell;
+                    break;
+                }
+                reduced[p] = value;
+            }
         }
         rows[b] = Object.freeze([bucket, ...reduced]);
     }

package/dist/batch/partitioned-time-series.d.ts

@@ -196,8 +196,6 @@ export declare class PartitionedTimeSeries<S extends SeriesSchema, K extends str
     toMap(): Map<K, TimeSeries<S>>;
     toMap<R extends SeriesSchema>(transform: (group: TimeSeries<S>) => TimeSeries<R>): Map<K, TimeSeries<R>>;
     toMap<R>(transform: (group: TimeSeries<S>) => R): Map<K, R>;
-    private static partitionKeyOf;
-    private static bucketByPartition;
     private static applyToSource;
     private rewrap;
     /**

package/dist/batch/partitioned-time-series.js

@@ -88,17 +88,17 @@ export class PartitionedTimeSeries {
             this.validateGroupMembership();
         }
     }
-    // Validate that every event's partition value appears in the
-    // declared groups. Mirrors the partition encoder so the comparison
-    // accepts the same string forms toMap will produce as keys.
+    // Validate that every partition value appears in the declared groups.
+    // Scans the partition column columnar-natively via `_distinctPartitionKeys`
+    // (no event materialization — same encoding `toMap` produces), so the
+    // declared-`groups` path is materialization-free like the rest of the
+    // split.
     validateGroupMembership() {
         if (!this.groups)
             return;
         const col = this.by[0];
         const declared = new Set(this.groups);
-        const keyOf = PartitionedTimeSeries.partitionKeyOf(this.by);
-        for (const event of this.source.events) {
-            const key = keyOf(event);
+        for (const key of this.source._distinctPartitionKeys(this.by)) {
             if (!declared.has(key)) {
                 // Decode the encoder's leading-space sentinel so the message
                 // shows the user-facing concept, not the internal encoding.
@@ -205,96 +205,54 @@ export class PartitionedTimeSeries {
     }
     toMap(transform) {
         const result = new Map();
-        const buckets = this.source.events.length === 0
+        // Columnar partition split — each sub-series is gathered straight off
+        // the store, no event materialization (the old path rebuilt every
+        // partition via `fromEvents`). Map order = first-encountered partition.
+        const partitions = this.source.length === 0
             ? new Map()
-            : PartitionedTimeSeries.bucketByPartition(this.source, this.by);
+            : this.source._partitionByColumns(this.by);
         if (this.groups) {
             // Declared-order iteration. Empty groups produce empty
             // TimeSeries entries (consistent with pivotByGroup's typed
             // groups behavior, which emits a column for every declared
             // value even when no events match).
             for (const g of this.groups) {
-                const events = buckets.get(g) ?? [];
-                const sub = TimeSeries.fromEvents(events, {
-                    schema: this.source.schema,
-                    name: this.source.name,
-                });
+                const sub = partitions.get(g) ??
+                    TimeSeries.fromEvents([], {
+                        schema: this.source.schema,
+                        name: this.source.name,
+                    });
                 result.set(g, transform ? transform(sub) : sub);
             }
             return result;
         }
         // Insertion-order iteration (matches the order each partition was
         // first encountered in the source events).
-        for (const [key, events] of buckets) {
-            const sub = TimeSeries.fromEvents(events, {
-                schema: this.source.schema,
-                name: this.source.name,
-            });
+        for (const [key, sub] of partitions) {
             result.set(key, transform ? transform(sub) : sub);
         }
         return result;
     }
-    // Build the encoder that produces a string key for an event given
-    // the partition columns. Single-column case avoids the JSON encoding
-    // overhead. Multi-column uses JSON.stringify to guarantee no key
-    // collisions on values containing separators (e.g. region names with
-    // spaces) — a naive `parts.join('|')` would collide. `undefined` in a
-    // single-column key becomes the literal `' undefined'` (with the
-    // leading space ensuring it can never collide with a string column
-    // whose value is the literal `'undefined'`).
-    static partitionKeyOf(by) {
-        if (by.length === 1) {
-            const col = by[0];
-            return (event) => {
-                const v = event.data()[col];
-                return v === undefined ? ' undefined' : `${String(v)}`;
-            };
-        }
-        return (event) => {
-            const data = event.data();
-            const parts = new Array(by.length);
-            for (let i = 0; i < by.length; i += 1) {
-                parts[i] = data[by[i]] ?? null;
-            }
-            return JSON.stringify(parts);
-        };
-    }
-    // Group source events into buckets keyed by partition value. Returned
-    // Map iteration order = insertion order, which matches the order
-    // partitions were first seen in the source events array.
-    static bucketByPartition(source, by) {
-        const keyOf = PartitionedTimeSeries.partitionKeyOf(by);
-        const buckets = new Map();
-        for (const event of source.events) {
-            const key = keyOf(event);
-            let bucket = buckets.get(key);
-            if (!bucket) {
-                bucket = [];
-                buckets.set(key, bucket);
-            }
-            bucket.push(event);
-        }
-        return buckets;
-    }
     // Internal helper used by both `apply` (terminal) and the sugar
     // methods (which re-wrap the result back into a partitioned view).
     static applyToSource(source, by, fn) {
         // Empty source: apply fn to an empty group so the output schema
         // and name come from fn, not from inferring R structurally.
-        if (source.events.length === 0) {
+        if (source.length === 0) {
             const empty = TimeSeries.fromEvents([], {
                 schema: source.schema,
                 name: source.name,
             });
             return fn(empty);
         }
-        const buckets = PartitionedTimeSeries.bucketByPartition(source, by);
+        // Columnar partition split — no event materialization. The old path
+        // walked `source.events` to bucket, then rebuilt each partition via
+        // `fromEvents` (re-validating + re-packing), silently re-paying the
+        // 495 ns/row tax the columnar wave removed. `_partitionByColumns`
+        // gathers each partition straight off the store (audit v2 §3.2).
+        const partitions = source._partitionByColumns(by);
         const transformed = [];
-        for (const events of buckets.values()) {
-            const sub = TimeSeries.fromEvents(events, {
-                schema: source.schema,
-                name: source.name,
-            });
+        for (const sub of partitions.values()) {
             transformed.push(fn(sub));
         }
         return TimeSeries.concat(transformed);

package/dist/batch/time-series.js

@@ -12,10 +12,10 @@ import { TimeRange } from '../core/time-range.js';
 import { compareEventKeys } from '../core/temporal.js';
 import { PartitionedTimeSeries } from './partitioned-time-series.js';
 import { Sequence } from '../sequence/sequence.js';
-import { IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, float64ColumnFromArray, stringColumnFromArray, withColumnsRenamed, withColumnsSelected, withKeyColumn, withRowRange, } from '../columnar/index.js';
+import { IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, float64ColumnFromArray, stringColumnFromArray, withColumnsRenamed, withColumnsSelected, withKeyColumn, withRowRange, withRowSelection, } from '../columnar/index.js';
 import { SeriesStore } from '../live/series-store.js';
 import { parseDuration } from '../core/duration.js';
-import { resolveReducer, } from '../reducers/index.js';
+import { resolveReducer, bucketStateFor, rollingStateFor, } from '../reducers/index.js';
 // JSON ↔ typed-row primitives live in `./json.js`. Both `TimeSeries`
 // and `LiveSeries` reach for them; extracted to break the import cycle
 // that would otherwise form (Event needs them, TimeSeries imports
@@ -274,7 +274,11 @@ function bucketOverlapsHalfOpen(bucket, event) {
     return event.begin() < bucket.end() && bucket.begin() < event.end();
 }
 function aggregateValues(operation, values) {
-    const defined = values.filter((value) => value !== undefined);
+    // Non-finite numerics (NaN / ±Inf) are treated as missing — excluded from
+    // both `defined` and `numeric` so every built-in reducer skips them exactly
+    // as it skips a missing cell. See docs/notes/reducer-nan-policy.md.
+    const defined = values.filter((value) => value !== undefined &&
+        (typeof value !== 'number' || Number.isFinite(value)));
     const numeric = defined.filter((value) => typeof value === 'number');
     return resolveReducer(operation).reduce(defined, numeric);
 }
@@ -315,7 +319,9 @@ function applyAggregateReducer(reducer, values) {
 // LivePartitionedSyncRolling) share the same normalisation. See the
 // import below.
 function createAggregateBucketState(operation) {
-    return resolveReducer(operation).bucketState();
+    // Delegates to the shared factory so the non-finite skip policy
+    // (docs/notes/reducer-nan-policy.md) applies uniformly to batch + live.
+    return bucketStateFor(operation);
 }
 /**
  * Resolve the output column kind for an `arrayAggregate` call. Numeric
@@ -336,7 +342,9 @@ function resolveArrayAggregateKind(reducer, explicitKind) {
     return 'string';
 }
 function createRollingReducerState(operation) {
-    return resolveReducer(operation).rollingState();
+    // Delegates to the shared factory so the non-finite skip policy
+    // (docs/notes/reducer-nan-policy.md) applies uniformly to batch + live.
+    return rollingStateFor(operation);
 }
 function duplicateValueColumnNames(schemas) {
     const counts = new Map();
@@ -710,6 +718,98 @@ export class TimeSeries {
         };
         return new TimeSeries(trustedInput);
     }
+    /**
+     * @internal Per-row partition-key encoder, mirroring the (removed)
+     * event-based `partitionKeyOf` exactly: single column → `String(value)`,
+     * or `' undefined'` (leading space, so it can't collide with the literal
+     * string `'undefined'`) for a missing cell; composite → `JSON.stringify`
+     * of the cells with a `?? null` fallback. Reads cells by index off the
+     * store — no event materialization; array cells stringify as the event
+     * path did. Shared by `_partitionByColumns` and `_distinctPartitionKeys`
+     * so the encoding can't drift between the split and the declared-`groups`
+     * membership check.
+     */
+    #partitionKeyEncoder(by) {
+        const store = this.#store.store;
+        if (by.length === 1) {
+            // Single-column fast path — no per-row array allocation.
+            const col = store.columns.get(by[0]);
+            return (i) => {
+                const value = col.read(i);
+                return value === undefined ? ' undefined' : `${String(value)}`;
+            };
+        }
+        const cols = by.map((name) => store.columns.get(name));
+        const parts = new Array(cols.length);
+        return (i) => {
+            for (let c = 0; c < cols.length; c += 1) {
+                parts[c] = cols[c].read(i) ?? null;
+            }
+            return JSON.stringify(parts);
+        };
+    }
+    /**
+     * @internal Columnar partition split — groups row indices by the partition
+     * key (see {@link TimeSeries.#partitionKeyEncoder}), gathers each group via
+     * `withRowSelection`, and wraps it as a trusted-store `TimeSeries`, with
+     * **no event materialization**. The columnar dual of the old
+     * `fromEvents`-per-bucket split that `PartitionedTimeSeries` paid through
+     * `this.events`. First-encountered partition order is preserved (Map
+     * insertion order), matching the previous `bucketByPartition`.
+     *
+     * **Identity note:** each sub-series lazily materializes its own `Event`
+     * objects from the gathered store — it does NOT reuse the source's `Event`
+     * instances (the old `fromEvents` path did). Cell values are identical;
+     * only object identity differs, and only for the no-transform paths
+     * (`toMap()` / `apply(g => g)`). `collect()` returns the source unchanged,
+     * so it is unaffected. This is the deliberate cost of skipping
+     * materialization.
+     *
+     * Used by `PartitionedTimeSeries` (`collect` / sugar via `applyToSource`,
+     * and `toMap`).
+     */
+    _partitionByColumns(by) {
+        const columnarStore = this.#store.store;
+        const length = columnarStore.length;
+        const encode = this.#partitionKeyEncoder(by);
+        const groups = new Map();
+        for (let i = 0; i < length; i += 1) {
+            const key = encode(i);
+            let indices = groups.get(key);
+            if (indices === undefined) {
+                indices = [];
+                groups.set(key, indices);
+            }
+            indices.push(i);
+        }
+        const result = new Map();
+        for (const [key, rowIndices] of groups) {
+            const sub = withRowSelection(columnarStore, new Int32Array(rowIndices));
+            result.set(key, TimeSeries.#fromTrustedStore(this.name, this.schema, sub));
+        }
+        return result;
+    }
+    /**
+     * @internal Distinct partition keys in first-encountered order, encoded by
+     * {@link TimeSeries.#partitionKeyEncoder} (identical to
+     * `_partitionByColumns`). Scans the partition columns off the store — no
+     * event materialization. Used by `PartitionedTimeSeries`'s declared-`groups`
+     * membership check so that path is materialization-free too.
+     */
+    _distinctPartitionKeys(by) {
+        const length = this.#store.store.length;
+        const encode = this.#partitionKeyEncoder(by);
+        const seen = new Set();
+        const keys = [];
+        for (let i = 0; i < length; i += 1) {
+            const key = encode(i);
+            if (!seen.has(key)) {
+                seen.add(key);
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
     /**
      * Example: `series.events`. Returns the full event array.
      *
@@ -2401,12 +2501,37 @@ export class TimeSeries {
     }
     /** Example: `series.timeRange()`. Returns the overall temporal extent of the series, if the series is not empty. */
     timeRange() {
-        const first = this.first();
-        if (!first) {
+        // Columnar key-axis read. The old implementation reduced over
+        // `this.events`, materializing every Event (the ~495 ns/row + heap
+        // tax) on every call — including the cold `aggregate()` default
+        // range, which erased the 3B fast-path win for one-shot pipelines.
+        const key = this.keyColumn();
+        const n = key.length;
+        if (n === 0) {
             return undefined;
         }
-        const start = first.begin();
-        const end = this.events.reduce((maxEnd, event) => Math.max(maxEnd, event.end()), first.end());
+        // `begin` is sorted non-decreasing (the intake invariant) for every
+        // key kind, so the minimum start is always `begin[0]`.
+        const start = key.begin[0];
+        let end;
+        if (key.kind === 'time') {
+            // Point-in-time keys: `end === begin`, and begin is sorted, so the
+            // maximum end is the final begin. O(1).
+            end = key.begin[n - 1];
+        }
+        else {
+            // Range / interval keys: `begin[i] <= end[i]` per row, but `end` is
+            // NOT monotonic (a long early event can outlast the final row), so
+            // the max end needs a scan — a typed-array scan, not Event
+            // materialization. Seeds with `end[0]` and maxes the rest, matching
+            // the old `reduce` seeded at `first.end()`.
+            const ends = key.end;
+            end = ends[0];
+            for (let i = 1; i < n; i += 1) {
+                if (ends[i] > end)
+                    end = ends[i];
+            }
+        }
         return new TimeRange({ start, end });
     }
     /** Example: `series.overlaps(range)`. Returns `true` when the overall series extent overlaps the supplied temporal value. */

package/dist/batch/validate.js

@@ -416,7 +416,13 @@ export function validateAndNormalizeColumnar(input) {
         let column;
         switch (kind) {
             case 'number':
-                column = new Float64Column(numberBufs[c], length, validity);
+                // Strict intake: `assertCellKind` (kind 'number') already
+                // rejected every non-finite cell with a `ValidationError`
+                // before it reached `numberBufs`, so a surviving column is
+                // provably all-finite → `allFinite: true` (lets reducers skip
+                // the per-element finite guard). See the reducer non-finite
+                // policy + `Float64Column.allFinite`'s safety contract.
+                column = new Float64Column(numberBufs[c], length, validity, true);
                 break;
             case 'boolean':
                 column = new BooleanColumn(booleanBufs[c], length, validity);