pond-ts 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -7,7 +7,8 @@ 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.25.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
@@ -19,6 +20,27 @@ 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

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,7 +13,7 @@ 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, bucketStateFor, rollingStateFor, } from '../reducers/index.js';
@@ -1979,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 = () => {
@@ -2015,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;
                 }
@@ -2043,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;
@@ -2068,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;
@@ -2099,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pond-ts",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "TypeScript-first time series primitives",
   "license": "MIT",
   "repository": {