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

@@ -1,3 +1,4 @@
+import type { Column } from '../columnar/index.js';
 import type { AggregateMap, AggregateOutputMap, AggregateReducer, ScalarKind, SeriesSchema } from '../schema/index.js';
 /**
  * Normalised column spec used by both batch and live aggregation paths.
@@ -33,4 +34,32 @@ 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;
+}>(begins: Float64Array, getColumn: (name: string) => Column | undefined, buckets: ReadonlyArray<B>, columns: ReadonlyArray<AggregateColumnSpec>): Array<ReadonlyArray<unknown>> | null;
 //# sourceMappingURL=aggregate-columns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"aggregate-columns.d.ts","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAElB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAkBF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAC/C,mBAAmB,EAAE,CAuDvB"}
+{"version":3,"file":"aggregate-columns.d.ts","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAElB,gBAAgB,EAEhB,UAAU,EACV,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAkBF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAC/C,mBAAmB,EAAE,CAuDvB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,CAC3C,CAAC,SAAS;IAAE,KAAK,IAAI,MAAM,CAAC;IAAC,GAAG,IAAI,MAAM,CAAA;CAAE,EAE5C,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EAC/C,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,OAAO,EAAE,aAAa,CAAC,mBAAmB,CAAC,GAC1C,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAyCtC"}

package/dist/batch/aggregate-columns.js

@@ -73,4 +73,67 @@ 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
+        }
+        plans.push({ column: source, reduce: def.reduceColumn });
+    }
+    const n = begins.length;
+    let cursor = 0;
+    const rows = new Array(buckets.length);
+    for (let b = 0; b < buckets.length; b += 1) {
+        const bucket = buckets[b];
+        const bucketBegin = bucket.begin();
+        const bucketEnd = bucket.end();
+        while (cursor < n && begins[cursor] < bucketBegin)
+            cursor += 1;
+        const start = cursor;
+        let scan = start;
+        while (scan < n && begins[scan] < bucketEnd)
+            scan += 1;
+        cursor = scan;
+        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));
+        }
+        rows[b] = Object.freeze([bucket, ...reduced]);
+    }
+    return rows;
+}
 //# sourceMappingURL=aggregate-columns.js.map

package/dist/batch/aggregate-columns.js.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-columns.js","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AA6BtD;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAc;IAEd,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,OAAO,IAAI,KAAK,CACjB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,yBAAyB,CACvC,MAAS,EACT,OAAgD;IAEhD,MAAM,aAAa,GAAG,IAAI,GAAG,CAC3B,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAU,CAAC,CAChE,CAAC;IACF,MAAM,UAAU,GAA0B,EAAE,CAAC;IAE7C,KAAK,MAAM,CAAC,UAAU,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACxD,MAAM,UAAU,GAAG,qBAAqB,CAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC;QACzE,MAAM,YAAY,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACnD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,SAAS,CACjB,uDAAuD,UAAU,GAAG,CACrE,CAAC;QACJ,CAAC;QACD,IACE,YAAY,CAAC,IAAI,KAAK,QAAQ;YAC9B,YAAY,CAAC,IAAI,KAAK,QAAQ;YAC9B,YAAY,CAAC,IAAI,KAAK,SAAS;YAC/B,YAAY,CAAC,IAAI,KAAK,OAAO,EAC7B,CAAC;YACD,MAAM,IAAI,SAAS,CACjB,4BAA4B,UAAU,0BAA0B,CACjE,CAAC;QACJ,CAAC;QACD,MAAM,OAAO,GAAG,qBAAqB,CAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;QAChE,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YACjE,MAAM,IAAI,SAAS,CACjB,0BAA0B,UAAU,uCAAuC,CAC5E,CAAC;QACJ,CAAC;QACD,MAAM,YAAY,GAAG,qBAAqB,CAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QAC1E,IAAI,YAAwB,CAAC;QAC7B,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC/B,YAAY,GAAG,YAAY,CAAC;QAC9B,CAAC;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YACvC,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC;YACxC,IAAI,OAAO,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACpC,YAAY,GAAG,QAAQ,CAAC;YAC1B,CAAC;iBAAM,IAAI,OAAO,CAAC,UAAU,KAAK,OAAO,EAAE,CAAC;gBAC1C,YAAY,GAAG,OAAO,CAAC;YACzB,CAAC;iBAAM,CAAC;gBACN,YAAY,GAAG,YAAY,CAAC,IAAI,CAAC;YACnC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,YAAY,GAAG,YAAY,CAAC,IAAI,CAAC;QACnC,CAAC;QACD,UAAU,CAAC,IAAI,CAAC;YACd,MAAM,EAAE,UAAU;YAClB,MAAM,EAAE,UAAU;YAClB,OAAO;YACP,IAAI,EAAE,YAAY;SACnB,CAAC,CAAC;IACL,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC"}
+{"version":3,"file":"aggregate-columns.js","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"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"}

package/dist/batch/operators/collapse.d.ts

@@ -0,0 +1,42 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { ScalarValue, SeriesSchema } from '../../schema/index.js';
+/** The reducer's row input — the keyed columns' values for one row. */
+export type CollapseReducer = (values: Record<string, unknown>) => ScalarValue;
+/**
+ * **Step 4 — column-native `collapse` (extracted operator).** Reduces
+ * the `keys` columns into a single `output` column, one value per row,
+ * reading **only the keyed columns** off the store (storage-agnostic
+ * `read(i)`) — no `series.events` materialization, no per-row `Event`.
+ * The kept columns + the key axis pass through by reference.
+ *
+ * Unlike the pure folds (`cumulative`, `diff`, `shift`), `collapse`
+ * still calls the user reducer per row over a small `{ key: value }`
+ * object, so the win is the more modest "read only the keyed columns +
+ * drop the Event allocation + share the kept columns" rather than a
+ * full vectorization — but the materialization tax is still removed.
+ *
+ * Semantics (matching the row path):
+ * - the reducer receives the keyed columns' values for the row
+ *   (`undefined` for a missing cell), and returns a `ScalarValue`;
+ * - the output column's kind is inferred from the **first row's**
+ *   result (`number` / `boolean` / else `string`) — an empty series
+ *   yields a `string` output column, matching the old `nextEvents[0]?`
+ *   inference;
+ * - **`append: false`** (default) drops the keyed columns and appends
+ *   `output`; **`append: true`** keeps every value column and appends
+ *   `output`.
+ *
+ * Returns the reshaped store + the output schema; the result-schema
+ * cast is the single trust boundary, and the `TimeSeries.collapse`
+ * method wraps the store via `#fromTrustedStore`. An `output` name
+ * that collides with a kept column throws via `withColumnAppended`.
+ *
+ * NB: `buildScalarColumn` overlaps `fillOp`'s `buildFilledColumn` and
+ * `mapOp`'s `columnFromValuesByKind` — three callers now; a shared
+ * `columnFromValuesByKind` helper is the flagged follow-up.
+ */
+export declare function collapseOp<S extends SeriesSchema, OutSchema extends SeriesSchema>(store: ColumnarStore<S>, schema: S, keys: readonly string[], output: string, reducer: CollapseReducer, append: boolean): {
+    store: ColumnarStore<OutSchema>;
+    schema: OutSchema;
+};
+//# sourceMappingURL=collapse.d.ts.map

package/dist/batch/operators/collapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/collapse.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAOnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEvE,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,WAAW,CAAC;AAiB/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,UAAU,CACxB,CAAC,SAAS,YAAY,EACtB,SAAS,SAAS,YAAY,EAE9B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,OAAO,GACd;IAAE,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CA8CxD"}

package/dist/batch/operators/collapse.js

@@ -0,0 +1,83 @@
+import { booleanColumnFromArray, float64ColumnFromArray, stringColumnFromArray, withColumnAppended, withColumnsSelected, } from '../../columnar/index.js';
+/** Builds the single output column from the reducer results + inferred kind. */
+function buildScalarColumn(kind, values) {
+    switch (kind) {
+        case 'number':
+            return float64ColumnFromArray(values);
+        case 'boolean':
+            return booleanColumnFromArray(values);
+        case 'string':
+            return stringColumnFromArray(values);
+    }
+}
+/**
+ * **Step 4 — column-native `collapse` (extracted operator).** Reduces
+ * the `keys` columns into a single `output` column, one value per row,
+ * reading **only the keyed columns** off the store (storage-agnostic
+ * `read(i)`) — no `series.events` materialization, no per-row `Event`.
+ * The kept columns + the key axis pass through by reference.
+ *
+ * Unlike the pure folds (`cumulative`, `diff`, `shift`), `collapse`
+ * still calls the user reducer per row over a small `{ key: value }`
+ * object, so the win is the more modest "read only the keyed columns +
+ * drop the Event allocation + share the kept columns" rather than a
+ * full vectorization — but the materialization tax is still removed.
+ *
+ * Semantics (matching the row path):
+ * - the reducer receives the keyed columns' values for the row
+ *   (`undefined` for a missing cell), and returns a `ScalarValue`;
+ * - the output column's kind is inferred from the **first row's**
+ *   result (`number` / `boolean` / else `string`) — an empty series
+ *   yields a `string` output column, matching the old `nextEvents[0]?`
+ *   inference;
+ * - **`append: false`** (default) drops the keyed columns and appends
+ *   `output`; **`append: true`** keeps every value column and appends
+ *   `output`.
+ *
+ * Returns the reshaped store + the output schema; the result-schema
+ * cast is the single trust boundary, and the `TimeSeries.collapse`
+ * method wraps the store via `#fromTrustedStore`. An `output` name
+ * that collides with a kept column throws via `withColumnAppended`.
+ *
+ * NB: `buildScalarColumn` overlaps `fillOp`'s `buildFilledColumn` and
+ * `mapOp`'s `columnFromValuesByKind` — three callers now; a shared
+ * `columnFromValuesByKind` helper is the flagged follow-up.
+ */
+export function collapseOp(store, schema, keys, output, reducer, append) {
+    const n = store.length;
+    const keyedCols = keys.map((k) => store.columns.get(k));
+    const out = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+        const values = {};
+        for (let j = 0; j < keys.length; j += 1) {
+            values[keys[j]] = keyedCols[j].read(i);
+        }
+        out[i] = reducer(values);
+    }
+    // Output kind from the first row's result (matches the old
+    // `typeof nextEvents[0]?.get(output)` inference; empty ⇒ 'string').
+    const first = n > 0 ? out[0] : undefined;
+    const outKind = typeof first === 'number'
+        ? 'number'
+        : typeof first === 'boolean'
+            ? 'boolean'
+            : 'string';
+    const outColumn = buildScalarColumn(outKind, out);
+    const keptDefs = append
+        ? schema.slice(1)
+        : schema.slice(1).filter((c) => !keys.includes(c.name));
+    const keptNames = keptDefs.map((c) => c.name);
+    // key + kept value columns (zero-copy), then append the output column.
+    const selected = withColumnsSelected(store, keptNames);
+    const result = withColumnAppended(selected, output, outColumn);
+    const outSchema = Object.freeze([
+        schema[0],
+        ...keptDefs,
+        { name: output, kind: outKind },
+    ]);
+    return {
+        store: result,
+        schema: outSchema,
+    };
+}
+//# sourceMappingURL=collapse.js.map

package/dist/batch/operators/collapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse.js","sourceRoot":"","sources":["../../../src/batch/operators/collapse.ts"],"names":[],"mappings":"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"}

package/dist/batch/operators/cumulative.d.ts

@@ -0,0 +1,40 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { SeriesSchema } from '../../schema/index.js';
+/**
+ * A cumulative accumulator — a built-in name or a custom fold
+ * `(acc, value) => next`. Mirrors `TimeSeries.cumulative`'s spec values.
+ */
+export type CumulativeReducer = 'sum' | 'max' | 'min' | 'count' | ((acc: number, value: number) => number);
+/**
+ * **Step 4 — column-native `cumulative` (extracted operator).** Running
+ * accumulation per target column, computed straight off the columnar store:
+ * read each target's cells (storage-agnostic `read(i)`), fold a running
+ * accumulator, replace the column — no `series.events` materialization, no
+ * per-row `Event`. Non-target columns + the key axis pass through untouched
+ * (`withColumnReplaced` references the unchanged columns + keys zero-copy).
+ *
+ * Matches the row path's semantics exactly: a defined numeric cell updates
+ * the accumulator; a missing / undefined cell **carries** the current
+ * accumulator (does not reset it), and the output is `undefined` only until
+ * the first defined value (`float64ColumnFromArray` derives validity from the
+ * `undefined`s). A stored NaN is a defined number — applied, matching the old
+ * `typeof raw === 'number'` check.
+ *
+ * Returns the reshaped store + the output schema (targets widened to optional
+ * `number`). The result-schema cast is the single trust boundary; the
+ * `TimeSeries.cumulative` method wraps the store via `#fromTrustedStore`.
+ *
+ * A non-numeric target name is unreachable through the typed surface
+ * (`cumulative<Targets extends NumericColumnNameForSchema<S>>`); it can only
+ * arrive by defeating that constraint (`(series as any).cumulative(...)`).
+ * On such a type-illegal input the all-`undefined` replacement column is
+ * `kind: 'number'`, so `withColumnReplaced`'s kind guard throws a `RangeError`
+ * naming the column. This is a deliberate improvement over the old events path,
+ * which silently overwrote the column with all-`undefined` — fail-fast beats
+ * silent corruption on input the type already forbids.
+ */
+export declare function cumulativeOp<S extends SeriesSchema, OutSchema extends SeriesSchema>(store: ColumnarStore<S>, schema: S, spec: Readonly<Record<string, CumulativeReducer>>): {
+    store: ColumnarStore<OutSchema>;
+    schema: OutSchema;
+};
+//# sourceMappingURL=cumulative.d.ts.map

package/dist/batch/operators/cumulative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cumulative.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/cumulative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAInB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GACzB,KAAK,GACL,KAAK,GACL,KAAK,GACL,OAAO,GACP,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;AAoB7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAC1B,CAAC,SAAS,YAAY,EACtB,SAAS,SAAS,YAAY,EAE9B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,GAChD;IAAE,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAgCxD"}

package/dist/batch/operators/cumulative.js

@@ -0,0 +1,74 @@
+import { float64ColumnFromArray, withColumnReplaced, } from '../../columnar/index.js';
+function buildApply(reducer) {
+    if (typeof reducer === 'function') {
+        return (acc, v) => (acc === undefined ? v : reducer(acc, v));
+    }
+    switch (reducer) {
+        case 'sum':
+            return (acc, v) => (acc ?? 0) + v;
+        case 'count':
+            return (acc) => (acc ?? 0) + 1;
+        case 'max':
+            return (acc, v) => (acc === undefined || v > acc ? v : acc);
+        case 'min':
+            return (acc, v) => (acc === undefined || v < acc ? v : acc);
+    }
+}
+/**
+ * **Step 4 — column-native `cumulative` (extracted operator).** Running
+ * accumulation per target column, computed straight off the columnar store:
+ * read each target's cells (storage-agnostic `read(i)`), fold a running
+ * accumulator, replace the column — no `series.events` materialization, no
+ * per-row `Event`. Non-target columns + the key axis pass through untouched
+ * (`withColumnReplaced` references the unchanged columns + keys zero-copy).
+ *
+ * Matches the row path's semantics exactly: a defined numeric cell updates
+ * the accumulator; a missing / undefined cell **carries** the current
+ * accumulator (does not reset it), and the output is `undefined` only until
+ * the first defined value (`float64ColumnFromArray` derives validity from the
+ * `undefined`s). A stored NaN is a defined number — applied, matching the old
+ * `typeof raw === 'number'` check.
+ *
+ * Returns the reshaped store + the output schema (targets widened to optional
+ * `number`). The result-schema cast is the single trust boundary; the
+ * `TimeSeries.cumulative` method wraps the store via `#fromTrustedStore`.
+ *
+ * A non-numeric target name is unreachable through the typed surface
+ * (`cumulative<Targets extends NumericColumnNameForSchema<S>>`); it can only
+ * arrive by defeating that constraint (`(series as any).cumulative(...)`).
+ * On such a type-illegal input the all-`undefined` replacement column is
+ * `kind: 'number'`, so `withColumnReplaced`'s kind guard throws a `RangeError`
+ * naming the column. This is a deliberate improvement over the old events path,
+ * which silently overwrote the column with all-`undefined` — fail-fast beats
+ * silent corruption on input the type already forbids.
+ */
+export function cumulativeOp(store, schema, spec) {
+    const entries = Object.entries(spec);
+    if (entries.length === 0) {
+        throw new Error('cumulative() requires at least one column');
+    }
+    const targetSet = new Set(entries.map(([name]) => name));
+    const outSchema = Object.freeze(schema.map((col, i) => i === 0 || !targetSet.has(col.name)
+        ? col
+        : { ...col, kind: 'number', required: false }));
+    const n = store.length;
+    let result = store;
+    for (const [name, reducer] of entries) {
+        const col = store.columns.get(name);
+        const apply = buildApply(reducer);
+        const out = new Array(n);
+        let acc;
+        for (let i = 0; i < n; i += 1) {
+            const raw = col.read(i);
+            if (typeof raw === 'number')
+                acc = apply(acc, raw);
+            out[i] = acc;
+        }
+        result = withColumnReplaced(result, name, float64ColumnFromArray(out));
+    }
+    return {
+        store: result,
+        schema: outSchema,
+    };
+}
+//# sourceMappingURL=cumulative.js.map

package/dist/batch/operators/cumulative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cumulative.js","sourceRoot":"","sources":["../../../src/batch/operators/cumulative.ts"],"names":[],"mappings":"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"}

package/dist/batch/operators/diff-rate.d.ts

@@ -0,0 +1,52 @@
+import { type ColumnarStore } from '../../columnar/index.js';
+import type { SeriesSchema } from '../../schema/index.js';
+/**
+ * Successive-difference family selector. `diff` is the raw delta
+ * `curr - prev`; `rate` divides by the elapsed seconds between the
+ * two rows' begins; `pctChange` divides by the previous value.
+ */
+export type DiffRateMode = 'diff' | 'rate' | 'pctChange';
+/**
+ * **Step 4 — column-native `diff` / `rate` / `pctChange` (extracted
+ * operator).** Successive differences per target column, computed
+ * straight off the columnar store: read each target's cells
+ * (storage-agnostic `read(i)`), fold the per-row difference, replace
+ * the column — no `series.events` materialization, no per-row
+ * `Event`. Non-target columns + the key axis pass through untouched
+ * (`withColumnReplaced` references the unchanged columns + keys
+ * zero-copy).
+ *
+ * Matches the row path's semantics exactly:
+ * - Row 0 has no predecessor, so each target is `undefined` there.
+ * - Row `i ≥ 1`: with both `prev` and `curr` defined numbers,
+ *   `delta = curr - prev`; `diff` emits `delta`, `rate` emits
+ *   `delta / dt` (`dt` = `(begin[i] − begin[i−1]) / 1000` seconds,
+ *   `undefined` when `dt === 0`), `pctChange` emits `delta / prev`
+ *   (`undefined` when `prev === 0`). If either side is missing /
+ *   non-numeric, the output is `undefined`. A stored `NaN` is a
+ *   defined number (`typeof raw === 'number'`), so it participates.
+ *
+ * **`drop`.** `drop: false` (default) keeps the predecessor-less
+ * first row (its targets `undefined`, its other columns + key
+ * intact). `drop: true` removes that row entirely — every column
+ * **and** the key slice to `[1, n)` via `withRowRange`, the row-range
+ * substrate built for exactly this. The full-length result is built
+ * first (the `drop: false` shape); `drop: true` just appends the
+ * trailing one-row slice, so the two paths share all the fold logic.
+ *
+ * Returns the reshaped store + the output schema (targets widened to
+ * optional `number`). The result-schema cast is the single trust
+ * boundary; the `TimeSeries` method wraps the store via
+ * `#fromTrustedStore`.
+ *
+ * A non-numeric target name is unreachable through the typed surface
+ * (`NumericColumnNameForSchema<S>`); defeating that constraint makes
+ * the all-`undefined` replacement column `kind: 'number'`, so
+ * `withColumnReplaced`'s kind guard throws a `RangeError` naming the
+ * column — fail-fast over the old path's silent all-`undefined`.
+ */
+export declare function diffRateOp<S extends SeriesSchema, OutSchema extends SeriesSchema>(store: ColumnarStore<S>, schema: S, mode: DiffRateMode, cols: readonly string[], drop: boolean): {
+    store: ColumnarStore<OutSchema>;
+    schema: OutSchema;
+};
+//# sourceMappingURL=diff-rate.d.ts.map

package/dist/batch/operators/diff-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-rate.d.ts","sourceRoot":"","sources":["../../../src/batch/operators/diff-rate.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,UAAU,CACxB,CAAC,SAAS,YAAY,EACtB,SAAS,SAAS,YAAY,EAE9B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,IAAI,EAAE,OAAO,GACZ;IAAE,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CA8DxD"}