pond-ts 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/dist/batch/aggregate-columns.js

@@ -123,26 +123,34 @@ export function tryAggregateColumnarTimeKeyed(begins, getColumn, buckets, column
                 reduced[p] = plan.reduce(plan.column.sliceByRange(start, scan));
             }
             else if (plan.which === 'first') {
-                // First defined cell in [start, scan); scans past missing cells.
+                // 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) {
-                        value = cell;
-                        break;
-                    }
+                    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.
+                // 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) {
-                        value = cell;
-                        break;
-                    }
+                    if (cell === undefined)
+                        continue;
+                    if (typeof cell === 'number' && !Number.isFinite(cell))
+                        continue;
+                    value = cell;
+                    break;
                 }
                 reduced[p] = value;
             }

package/dist/batch/operators/column-builders.d.ts

@@ -0,0 +1,31 @@
+import { type Column } from '../../columnar/index.js';
+/**
+ * Build a typed {@link Column} from a per-row value array, dispatching on the
+ * column's `kind`. An `undefined` cell becomes missing (its validity bit is
+ * left unset, so `read(i)` returns `undefined`). Numeric arrays reject
+ * non-finite values at construction (`float64ColumnFromArray`) — packed
+ * numeric columns stay NaN-free.
+ *
+ * This is the shared form of the kind→builder dispatch that `fill`
+ * (`buildFilledColumn`), `map` (its inline builder), and `collapse`
+ * (`buildScalarColumn`) each carry a local copy of — flagged there as a
+ * follow-up to converge. Columnar `rolling` is the fourth caller and uses
+ * this one directly; retrofitting the other three onto it is a separate
+ * (optional) cleanup.
+ */
+export declare function columnFromValuesByKind(kind: string, values: unknown[]): Column;
+/**
+ * Throw if any *defined* value fails the column's `kind` contract, mirroring
+ * the constructor's strict intake (`validate.ts`): a `number` must be finite;
+ * `string` / `boolean` must match `typeof`; an `array` must be a real array
+ * whose elements are each a finite number, string, or boolean. `undefined`
+ * (missing) values are allowed.
+ *
+ * Computed-writer paths that assemble via trusted construction bypass intake,
+ * and {@link columnFromValuesByKind}'s `*FromArray` builders silently coerce a
+ * kind mismatch to a *missing* cell — so a caller that must preserve the intake
+ * rejection (e.g. columnar `rolling`, matching `mapColumns`) calls this first.
+ * `label` is prefixed to the thrown message.
+ */
+export declare function assertColumnValuesMatchKind(kind: string, values: ReadonlyArray<unknown>, label: string): void;
+//# sourceMappingURL=column-builders.d.ts.map

package/dist/batch/operators/column-builders.js

@@ -0,0 +1,103 @@
+import { arrayColumnFromArray, booleanColumnFromArray, float64ColumnFromArray, stringColumnFromArray, } from '../../columnar/index.js';
+import { ValidationError } from '../../core/errors.js';
+/**
+ * Build a typed {@link Column} from a per-row value array, dispatching on the
+ * column's `kind`. An `undefined` cell becomes missing (its validity bit is
+ * left unset, so `read(i)` returns `undefined`). Numeric arrays reject
+ * non-finite values at construction (`float64ColumnFromArray`) — packed
+ * numeric columns stay NaN-free.
+ *
+ * This is the shared form of the kind→builder dispatch that `fill`
+ * (`buildFilledColumn`), `map` (its inline builder), and `collapse`
+ * (`buildScalarColumn`) each carry a local copy of — flagged there as a
+ * follow-up to converge. Columnar `rolling` is the fourth caller and uses
+ * this one directly; retrofitting the other three onto it is a separate
+ * (optional) cleanup.
+ */
+export function columnFromValuesByKind(kind, values) {
+    switch (kind) {
+        case 'number':
+            return float64ColumnFromArray(values);
+        case 'string':
+            return stringColumnFromArray(values);
+        case 'boolean':
+            return booleanColumnFromArray(values);
+        case 'array':
+            // ArrayValue cells; the cast is the kind dispatch's trust point.
+            return arrayColumnFromArray(values);
+        default:
+            throw new TypeError(`columnFromValuesByKind: unsupported kind '${kind}'`);
+    }
+}
+/**
+ * Throw if any *defined* value fails the column's `kind` contract, mirroring
+ * the constructor's strict intake (`validate.ts`): a `number` must be finite;
+ * `string` / `boolean` must match `typeof`; an `array` must be a real array
+ * whose elements are each a finite number, string, or boolean. `undefined`
+ * (missing) values are allowed.
+ *
+ * Computed-writer paths that assemble via trusted construction bypass intake,
+ * and {@link columnFromValuesByKind}'s `*FromArray` builders silently coerce a
+ * kind mismatch to a *missing* cell — so a caller that must preserve the intake
+ * rejection (e.g. columnar `rolling`, matching `mapColumns`) calls this first.
+ * `label` is prefixed to the thrown message.
+ */
+export function assertColumnValuesMatchKind(kind, values, label) {
+    for (let i = 0; i < values.length; i += 1) {
+        const v = values[i];
+        if (v === undefined)
+            continue; // missing cell — allowed
+        let ok;
+        switch (kind) {
+            case 'number':
+                ok = typeof v === 'number' && Number.isFinite(v);
+                break;
+            case 'string':
+                ok = typeof v === 'string';
+                break;
+            case 'boolean':
+                ok = typeof v === 'boolean';
+                break;
+            case 'array': {
+                if (!Array.isArray(v)) {
+                    ok = false;
+                    break;
+                }
+                // Indexed loop, NOT `.every` (which skips holes): a sparse array's
+                // hole reads as `undefined`, an invalid element that intake's indexed
+                // scan rejects. Match it exactly so sparse arrays throw here rather
+                // than getting silently coerced to a missing cell by the builder.
+                ok = true;
+                for (let j = 0; j < v.length; j += 1) {
+                    const el = v[j];
+                    if (!((typeof el === 'number' && Number.isFinite(el)) ||
+                        typeof el === 'string' ||
+                        typeof el === 'boolean')) {
+                        ok = false;
+                        break;
+                    }
+                }
+                break;
+            }
+            default:
+                ok = false;
+        }
+        if (!ok) {
+            // `ValidationError` (not `RangeError`) so the failure class matches the
+            // constructor's strict intake — a caller that catches `ValidationError`
+            // for bad user data sees columnar-rolling rejections identically. The
+            // value is stringified defensively: some invalid values (e.g. an array
+            // containing a `Symbol`) throw from `String(...)`, which would mask the
+            // `ValidationError` with a `TypeError`.
+            let shown;
+            try {
+                shown = String(v);
+            }
+            catch {
+                shown = `<unstringifiable ${typeof v}>`;
+            }
+            throw new ValidationError(`${label}: result ${shown} is not a valid '${kind}' value`);
+        }
+    }
+}
+//# sourceMappingURL=column-builders.js.map

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

@@ -900,6 +900,14 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * series carrying multiple entities (host, region, device id), use
      * `series.partitionBy(col).rolling(...).collect()` to scope per
      * entity. See {@link TimeSeries.partitionBy}.
+     *
+     * **`array`-column identity:** the window reads values from the
+     * columnar store, so on an `array`-kind source column an identity-
+     * comparing reducer (`keep`, or a custom reducer using `===` on the
+     * cell) compares the stored cell, not the original object reference
+     * from construction. Two rows that were given the *same* array object
+     * therefore read as distinct values here. Scalar columns
+     * (number / string / boolean) are unaffected (value semantics).
      */
     rolling<const Mapping extends ValidatedAggregateMap<S, Mapping>>(window: DurationInput, mapping: Mapping, options?: {
         alignment?: RollingAlignment;

package/dist/batch/time-series.js

@@ -5,6 +5,7 @@ import { fillOp } from './operators/fill.js';
 import { mapOp } from './operators/map.js';
 import { shiftOp } from './operators/shift.js';
 import { collapseOp } from './operators/collapse.js';
+import { assertColumnValuesMatchKind, columnFromValuesByKind, } from './operators/column-builders.js';
 import { BoundedSequence } from '../sequence/bounded-sequence.js';
 import { Interval } from '../core/interval.js';
 import { Time } from '../core/time.js';
@@ -12,10 +13,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, withRowSelection, } from '../columnar/index.js';
+import { ColumnarStore, 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 +275,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 +320,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 +343,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();
@@ -1971,33 +1980,34 @@ export class TimeSeries {
             this.schema[0],
             ...resultColumnDefs,
         ]);
+        // Columnar output path (3C): read the key + source columns straight off
+        // the store and build the result columns directly — no `this.events`
+        // materialization, no per-row `Event`, no row re-validation/re-pack.
+        const store = this.#store.store;
+        const rowCount = store.length;
+        const sourceCols = columnSpecs.map((spec) => store.columns.get(spec.source));
         const reducerStates = columnSpecs.map((spec) => isBuiltInAggregateReducer(spec.reducer)
             ? createRollingReducerState(spec.reducer)
             : null);
-        const beginTimes = this.events.map((event) => event.begin());
-        const resultRows = new Array(this.events.length);
+        // Begin axis from the key buffer (replaces `this.events.map(e => e.begin())`).
+        const beginTimes = store.keys.begin;
+        // One value accumulator per output column; the result columns are built
+        // from these and assembled via trusted construction below.
+        const outValues = columnSpecs.map(() => new Array(rowCount));
         let windowStart = 0;
         let windowEnd = 0;
         const addEvent = (index) => {
-            const event = this.events[index];
-            const data = event.data();
             for (let i = 0; i < reducerStates.length; i++) {
                 const state = reducerStates[i];
-                if (state) {
-                    const spec = columnSpecs[i];
-                    state.add(index, data[spec.source]);
-                }
+                if (state)
+                    state.add(index, sourceCols[i].read(index));
             }
         };
         const removeEvent = (index) => {
-            const event = this.events[index];
-            const data = event.data();
             for (let i = 0; i < reducerStates.length; i++) {
                 const state = reducerStates[i];
-                if (state) {
-                    const spec = columnSpecs[i];
-                    state.remove(index, data[spec.source]);
-                }
+                if (state)
+                    state.remove(index, sourceCols[i].read(index));
             }
         };
         const snapshotWindow = () => {
@@ -2007,25 +2017,33 @@ export class TimeSeries {
                 const state = reducerStates[i];
                 if (state)
                     return state.snapshot();
-                const values = this.events
-                    .slice(windowStart, windowEnd)
-                    .map((event) => {
-                    const data = event.data();
-                    return data[spec.source];
-                });
+                // Custom reducer: read the window's source values directly off the
+                // column in arrival order — identical value list to the old
+                // `this.events.slice(windowStart, windowEnd)` path.
+                const col = sourceCols[i];
+                const values = [];
+                for (let j = windowStart; j < windowEnd; j++)
+                    values.push(col.read(j));
                 return applyAggregateReducer(spec.reducer, values);
             });
         };
+        // Scatter one window's aggregated values across every row of an equal-key
+        // group (replaces the per-row frozen `[key, ...aggregated]` tuple write).
+        const writeGroup = (groupStart, groupEnd, aggregated) => {
+            for (let index = groupStart; index < groupEnd; index++) {
+                for (let c = 0; c < outValues.length; c++) {
+                    outValues[c][index] = aggregated[c];
+                }
+            }
+        };
         if (alignment === 'trailing') {
-            for (let groupStart = 0; groupStart < this.events.length;) {
+            for (let groupStart = 0; groupStart < rowCount;) {
                 const anchor = beginTimes[groupStart];
                 let groupEnd = groupStart + 1;
-                while (groupEnd < this.events.length &&
-                    beginTimes[groupEnd] === anchor) {
+                while (groupEnd < rowCount && beginTimes[groupEnd] === anchor) {
                     groupEnd += 1;
                 }
-                while (windowEnd < this.events.length &&
-                    beginTimes[windowEnd] <= anchor) {
+                while (windowEnd < rowCount && beginTimes[windowEnd] <= anchor) {
                     addEvent(windowEnd);
                     windowEnd += 1;
                 }
@@ -2035,22 +2053,15 @@ export class TimeSeries {
                     removeEvent(windowStart);
                     windowStart += 1;
                 }
-                const aggregated = snapshotWindow();
-                for (let index = groupStart; index < groupEnd; index++) {
-                    resultRows[index] = Object.freeze([
-                        this.events[index].key(),
-                        ...aggregated,
-                    ]);
-                }
+                writeGroup(groupStart, groupEnd, snapshotWindow());
                 groupStart = groupEnd;
             }
         }
         else if (alignment === 'leading') {
-            for (let groupStart = 0; groupStart < this.events.length;) {
+            for (let groupStart = 0; groupStart < rowCount;) {
                 const anchor = beginTimes[groupStart];
                 let groupEnd = groupStart + 1;
-                while (groupEnd < this.events.length &&
-                    beginTimes[groupEnd] === anchor) {
+                while (groupEnd < rowCount && beginTimes[groupEnd] === anchor) {
                     groupEnd += 1;
                 }
                 const lowerBound = anchor;
@@ -2060,28 +2071,20 @@ export class TimeSeries {
                     windowStart += 1;
                 }
                 const upperBound = anchor + windowMs;
-                while (windowEnd < this.events.length &&
-                    beginTimes[windowEnd] < upperBound) {
+                while (windowEnd < rowCount && beginTimes[windowEnd] < upperBound) {
                     addEvent(windowEnd);
                     windowEnd += 1;
                 }
-                const aggregated = snapshotWindow();
-                for (let index = groupStart; index < groupEnd; index++) {
-                    resultRows[index] = Object.freeze([
-                        this.events[index].key(),
-                        ...aggregated,
-                    ]);
-                }
+                writeGroup(groupStart, groupEnd, snapshotWindow());
                 groupStart = groupEnd;
             }
         }
         else {
             const halfWindow = windowMs / 2;
-            for (let groupStart = 0; groupStart < this.events.length;) {
+            for (let groupStart = 0; groupStart < rowCount;) {
                 const anchor = beginTimes[groupStart];
                 let groupEnd = groupStart + 1;
-                while (groupEnd < this.events.length &&
-                    beginTimes[groupEnd] === anchor) {
+                while (groupEnd < rowCount && beginTimes[groupEnd] === anchor) {
                     groupEnd += 1;
                 }
                 const lowerBound = anchor - halfWindow;
@@ -2091,26 +2094,36 @@ export class TimeSeries {
                     windowStart += 1;
                 }
                 const upperBound = anchor + halfWindow;
-                while (windowEnd < this.events.length &&
-                    beginTimes[windowEnd] < upperBound) {
+                while (windowEnd < rowCount && beginTimes[windowEnd] < upperBound) {
                     addEvent(windowEnd);
                     windowEnd += 1;
                 }
-                const aggregated = snapshotWindow();
-                for (let index = groupStart; index < groupEnd; index++) {
-                    resultRows[index] = Object.freeze([
-                        this.events[index].key(),
-                        ...aggregated,
-                    ]);
-                }
+                writeGroup(groupStart, groupEnd, snapshotWindow());
                 groupStart = groupEnd;
             }
         }
-        return new TimeSeries({
-            name: this.name,
-            schema: resultSchema,
-            rows: resultRows,
-        });
+        // Assemble the result columns from the per-column accumulators and wrap via
+        // trusted construction — the key column passes through zero-copy, and there
+        // is no row re-validation / re-pack (the win this path exists for).
+        const outColumns = new Map();
+        for (let c = 0; c < columnSpecs.length; c++) {
+            const kind = resultColumnDefs[c].kind;
+            const values = outValues[c];
+            // The old event-based path re-packed via the constructor's strict intake,
+            // which rejected any defined result that didn't match the declared output
+            // kind — a non-finite number (a `sum` overflow), or a wrong-typed value
+            // (a custom reducer / `kind` override producing a string for a number
+            // column, etc.). Trusted construction skips intake, and the `*FromArray`
+            // builders silently coerce a kind mismatch to a *missing* cell — so
+            // re-assert the same contract here (same value rules AND the same
+            // `ValidationError` class as intake), keeping packed columns clean.
+            // Missing cells (`undefined`, e.g. the minSamples warm-up) are
+            // unaffected. (#225 Codex finding.)
+            assertColumnValuesMatchKind(kind, values, `rolling column '${columnSpecs[c].output}'`);
+            outColumns.set(columnSpecs[c].output, columnFromValuesByKind(kind, values));
+        }
+        const outStore = ColumnarStore.fromTrustedStore(resultSchema, store.keys, outColumns);
+        return TimeSeries.#fromTrustedStore(this.name, resultSchema, outStore);
     }
     /**
      * Example: `series.smooth("value", "ema", { alpha: 0.2 })`.

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);