pond-ts 0.22.0 → 0.24.0

package/dist/batch/time-series.js

@@ -12,7 +12,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, } 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';
@@ -468,6 +468,7 @@ export class TimeSeries {
             name: input.name,
             schema: input.schema,
             rows: parseJsonRows(input.schema, input.rows, input.parse),
+            sort: input.sort ?? false,
         });
     }
     /**
@@ -587,13 +588,21 @@ export class TimeSeries {
         }
         else {
             this.schema = Object.freeze(input.schema.slice());
+            // `{ sort: true }` sorts unsorted input by key before intake (otherwise
+            // the intake's non-decreasing-order check throws). Stable, so rows with
+            // equal keys keep their input order; same key comparator as
+            // `fromEvents` / `concat`. Copies the array — the caller's `rows` is not
+            // mutated.
+            const rows = input.sort
+                ? [...input.rows].sort((a, b) => compareEventKeys(toKey(a[0]), toKey(b[0])))
+                : input.rows;
             // `SeriesStore.fromValidatedRows` runs the column-native
             // intake (`validateAndNormalizeColumnar`) — same validation
             // rules as the pre-2a row-shape `validateAndNormalize` but
             // writes directly into columnar buffers without allocating
             // Event objects + frozen data dicts. Events lazy-materialize
             // on first `eventAt(i)` access via the store's per-row cache.
-            this.#store = SeriesStore.fromValidatedRows(this.schema, input.rows);
+            this.#store = SeriesStore.fromValidatedRows(this.schema, rows);
         }
         Object.freeze(this);
     }
@@ -701,6 +710,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.
      *
@@ -782,14 +883,18 @@ export class TimeSeries {
      * series.events[i]` holds whenever both are accessed.
      */
     at(index) {
-        // Match pre-2a array-indexing semantics: non-integer or NaN
-        // inputs return undefined rather than throwing downstream from
-        // `#store.eventAt`. `this.events[NaN]` returned undefined per
-        // JS array semantics (key coercion + miss); the direct route
-        // to `#store.eventAt(NaN)` would proceed past the bounds check
-        // and attempt key materialization at the invalid row. Closed
-        // Codex round 4's medium finding on PR #150.
-        if (!Number.isInteger(index) || index < 0 || index >= this.#store.length) {
+        // Non-integer / NaN inputs return undefined rather than throwing
+        // downstream from `#store.eventAt` (`this.events[NaN]` returned undefined
+        // per JS array semantics; the direct route to `#store.eventAt(NaN)` would
+        // proceed past the bounds check and materialize a key at an invalid row).
+        // Closed Codex round 4's medium finding on PR #150.
+        if (!Number.isInteger(index))
+            return undefined;
+        // Negative indices count from the end — parity with `LiveSeries.at` and
+        // `Array.prototype.at` (`at(-1)` is the last event).
+        if (index < 0)
+            index += this.#store.length;
+        if (index < 0 || index >= this.#store.length) {
             return undefined;
         }
         return this.#store.eventAt(index);
@@ -1292,7 +1397,8 @@ export class TimeSeries {
     }
     pivotByGroup(groupCol, valueCol, options = {}) {
         if (this.schema[0].kind !== 'time') {
-            throw new TypeError(`pivotByGroup requires a time-keyed series; got ${this.schema[0].kind}`);
+            throw new TypeError(`pivotByGroup requires a time-keyed series; got ${this.schema[0].kind}` +
+                ` — piping from aggregate/materialize? call .asTime({ at: 'begin' }) first`);
         }
         const valueColumnDef = this.schema.find((c) => c.name === valueCol);
         if (!valueColumnDef) {
@@ -2387,12 +2493,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. */
@@ -2826,6 +2957,12 @@ export class TimeSeries {
             rollingOptions.alignment = alignment;
         if (minSamples !== undefined)
             rollingOptions.minSamples = minSamples;
+        // Trust boundary: a generic mapping can't prove it satisfies the
+        // public overload's ValidatedAggregateMap constraint (S is
+        // unresolved here), so route through the broad-schema escape hatch
+        // — for concrete SeriesSchema the constraint degrades to the
+        // permissive AggregateMap by design. The computed spec keys are
+        // collision-checked above.
         const rolling = this.rolling(window, {
             [avgName]: { from: col, using: 'avg' },
             [sdName]: { from: col, using: 'stdev' },
@@ -2920,6 +3057,8 @@ export class TimeSeries {
             rollingOptions.alignment = alignment;
         if (minSamples !== undefined)
             rollingOptions.minSamples = minSamples;
+        // Trust boundary: see baseline() above — generic mapping routed
+        // through the broad-schema escape hatch of ValidatedAggregateMap.
         const rolling = this.rolling(window, rollingMapping, rollingOptions);
         const kept = [];
         for (let i = 0; i < this.events.length; i += 1) {

package/dist/batch/validate.js

@@ -376,11 +376,11 @@ export function validateAndNormalizeColumnar(input) {
         const prevBegin = beginBuf[i - 1];
         const curBegin = beginBuf[i];
         if (prevBegin > curBegin) {
-            throw new ValidationError(`row ${i} is out of order`);
+            throw new ValidationError(`row ${i} is out of order — keys must be non-decreasing; pass { sort: true } to sort rows on construction, or pre-sort them`);
         }
         if (prevBegin === curBegin && endBuf !== beginBuf) {
             if (endBuf[i - 1] > endBuf[i]) {
-                throw new ValidationError(`row ${i} is out of order`);
+                throw new ValidationError(`row ${i} is out of order — keys must be non-decreasing; pass { sort: true } to sort rows on construction, or pre-sort them`);
             }
         }
     }

package/dist/cjs-fallback.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+// pond-ts ships as ES modules only. This stub is the `require` target in the
+// package's `exports` map so that CommonJS consumers get a clear, actionable
+// error instead of Node's cryptic `ERR_PACKAGE_PATH_NOT_EXPORTED`.
+//
+// It is copied verbatim into `dist/` during `prepack` (see package.json) so it
+// rides along in the published tarball; the source of truth lives at the
+// package root and is never touched by `tsc`.
+
+throw new Error(
+  'pond-ts is an ES module package and cannot be loaded with require(). ' +
+    "Use `import { TimeSeries } from 'pond-ts'` instead, or a dynamic " +
+    "`await import('pond-ts')` from CommonJS. See https://nodejs.org/api/esm.html.",
+);

package/dist/index.d.ts

@@ -29,7 +29,7 @@ export { ArrayColumn } from './columnar/array-column.js';
 export { ChunkedArrayColumn, ChunkedBooleanColumn, ChunkedFloat64Column, ChunkedStringColumn, } from './columnar/chunked-column.js';
 export { type IntervalLabelKind, type KeyColumn, IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, } from './columnar/key-column.js';
 export { type ValidityBitmap } from './columnar/validity.js';
-export type { AlignSchema, ArrayColumnNameForSchema, BaselineSchema, AggregateFunction, AggregateReducer, AggregateOutputMap, AggregateOutputSpec, AggregateMap, AggregateSchema, ColumnDef, CollapseData, ArrayAggregateAppendSchema, ArrayAggregateKind, ArrayAggregateReplaceSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, CollapseSchema, DedupeKeep, EventDataForSchema, EventForSchema, EventKeyForKind, FillMapping, FillStrategy, MaterializeSchema, EventKeyForSchema, FirstColKind, FirstColumn, IntervalKeyedSchema, JsonIntervalInput, JsonObjectRowForSchema, JsonRowFormat, JsonRowForSchema, JsonTimeRangeInput, JsonTimestampInput, JsonValueForKind, RollingAlignment, RollingSchema, JoinConflictMode, JoinManySchema, PrefixedJoinManySchema, PrefixedJoinSchema, LiveSource, JoinType, JoinSchema, NormalizedRowForSchema, NormalizedObjectRowForSchema, NormalizedObjectRow, NormalizedValueForKind, ReduceResult, RenameData, RenameMap, RenameSchema, RekeySchema, RowForSchema, ArrayValue, ColumnValue, ScalarKind, ScalarValue, CustomAggregateReducer, DiffSchema, NumericColumnNameForSchema, SmoothMethod, SmoothAppendSchema, SmoothSchema, SelectData, SelectSchema, SeriesSchema, TimeKeyedSchema, TimeSeriesInput, TimeSeriesJsonInput, TimeRangeKeyedSchema, ValueColumnsForSchema, ValueColumn, ValueForKind, } from './schema/index.js';
+export type { AlignSchema, ArrayColumnNameForSchema, BaselineSchema, AggregateFunction, AggregateReducer, AggregateOutputMap, AggregateOutputSpec, AggregateMap, AggregateSchema, ValidatedAggregateMap, ColumnDef, CollapseData, ArrayAggregateAppendSchema, ArrayAggregateKind, ArrayAggregateReplaceSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, CollapseSchema, DedupeKeep, EventDataForSchema, EventForSchema, EventKeyForKind, FillMapping, FillStrategy, MaterializeSchema, EventKeyForSchema, FirstColKind, FirstColumn, IntervalKeyedSchema, JsonIntervalInput, JsonObjectRowForSchema, JsonRowFormat, JsonRowForSchema, JsonTimeRangeInput, JsonTimestampInput, JsonValueForKind, RollingAlignment, RollingSchema, JoinConflictMode, JoinManySchema, PrefixedJoinManySchema, PrefixedJoinSchema, LiveSource, JoinType, JoinSchema, NormalizedRowForSchema, NormalizedObjectRowForSchema, NormalizedObjectRow, NormalizedValueForKind, ReduceResult, RenameData, RenameMap, RenameSchema, RekeySchema, RowForSchema, ArrayValue, ColumnValue, ScalarKind, ScalarValue, CustomAggregateReducer, DiffSchema, NumericColumnNameForSchema, SmoothMethod, SmoothAppendSchema, SmoothSchema, SelectData, SelectSchema, SeriesSchema, TimeKeyedSchema, TimeSeriesInput, TimeSeriesJsonInput, TimeRangeKeyedSchema, ValueColumnsForSchema, ValueColumn, ValueForKind, } from './schema/index.js';
 export type { CalendarOptions, CalendarUnit, TimeZoneOptions, } from './core/calendar.js';
 export type { EventKey, IntervalInput, IntervalValue, TemporalLike, TimeRangeInput, TimestampInput, } from './core/temporal.js';
 export type { DurationInput } from './core/duration.js';

package/dist/live/live-aggregation.d.ts

@@ -4,7 +4,7 @@ import { LiveView, type LiveFillMapping, type LiveFillStrategy } from './live-vi
 import { LiveRollingAggregation, type LiveRollingOptions, type RollingWindow } from './live-rolling-aggregation.js';
 import { TimeSeries } from '../batch/time-series.js';
 import type { Sequence } from '../sequence/sequence.js';
-import type { AggregateMap, AggregateOutputMap, DiffSchema, EventDataForSchema, EventForSchema, LiveSource, NumericColumnNameForSchema, ColumnValue, RollingSchema, SelectSchema, SeriesSchema } from '../schema/index.js';
+import type { AggregateMap, AggregateOutputMap, DiffSchema, EventDataForSchema, EventForSchema, LiveSource, NumericColumnNameForSchema, ColumnValue, RollingSchema, SelectSchema, SeriesSchema, ValidatedAggregateMap } from '../schema/index.js';
 import type { RollingOutputMapSchema } from '../schema/index.js';
 import type { DurationInput } from '../core/duration.js';
 type ClosedEvent = Event<Interval, Record<string, ColumnValue | undefined>>;
@@ -48,7 +48,7 @@ export declare class LiveAggregation<S extends SeriesSchema, Out extends SeriesS
     cumulative<const Targets extends NumericColumnNameForSchema<Out>>(spec: {
         [K in Targets]: 'sum' | 'max' | 'min' | 'count' | ((acc: number, value: number) => number);
     }): LiveView<DiffSchema<Out, Targets>>;
-    rolling<const M extends AggregateMap<Out>>(windowSize: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<Out, RollingSchema<Out, M>>;
+    rolling<const M extends ValidatedAggregateMap<Out, M>>(windowSize: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<Out, RollingSchema<Out, M>>;
     rolling<const M extends AggregateOutputMap<Out>>(windowSize: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<Out, RollingOutputMapSchema<Out, M>>;
     /**
      * Pipeline stats snapshot — cumulative counters since

package/dist/live/live-partitioned-series.d.ts

@@ -4,9 +4,8 @@ import { LivePartitionedFusedRolling } from './live-partitioned-fused-rolling.js
 import type { SampleStrategy } from '../sequence/sample.js';
 import { type LiveFillMapping, type LiveFillStrategy } from './live-view.js';
 import type { Trigger } from './triggers.js';
-import { type AggregateMap, type AggregateOutputMap, type DiffSchema, type EventDataForSchema, type LiveSource, type NumericColumnNameForSchema, type RollingSchema, type SeriesSchema } from '../schema/index.js';
-import type { RollingOutputMapSchema } from '../schema/index.js';
-import type { FusedMapping, FusedMappingValid, FusedPartitionedRollingSchema } from '../schema/index.js';
+import { type DiffSchema, type EventDataForSchema, type LiveSource, type NumericColumnNameForSchema, type RollingSchema, type SeriesSchema } from '../schema/index.js';
+import type { FusedMapping, FusedMappingValid, FusedPartitionedRollingSchema, ValidatedAggregateMap } from '../schema/index.js';
 import type { DurationInput } from '../core/duration.js';
 import type { LiveRollingOptions, RollingWindow } from './live-rolling-aggregation.js';
 /**
@@ -252,28 +251,17 @@ export declare class LivePartitionedSeries<S extends SeriesSchema, K extends str
      * );
      * ```
      */
-    rolling<const M extends AggregateMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
+    rolling<const M extends ValidatedAggregateMap<S, M>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
         trigger?: {
             kind: 'event' | 'count';
         };
     }): LivePartitionedView<S, RollingSchema<S, M>, K, ByCol>;
-    rolling<const M extends AggregateOutputMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
-        trigger?: {
-            kind: 'event' | 'count';
-        };
-    }): LivePartitionedView<S, RollingOutputMapSchema<S, M>, K, ByCol>;
-    rolling<const M extends AggregateMap<S>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
-        trigger: {
-            kind: 'clock';
-        } & Trigger;
-    }): LivePartitionedSyncRolling<S, K, SeriesSchema>;
-    rolling<const M extends AggregateOutputMap<S>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
+    rolling<const M extends ValidatedAggregateMap<S, M>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
         trigger: {
             kind: 'clock';
         } & Trigger;
     }): LivePartitionedSyncRolling<S, K, SeriesSchema>;
-    rolling<const M extends AggregateMap<S>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<S, RollingSchema<S, M>, K, ByCol> | LivePartitionedSyncRolling<S, K, SeriesSchema>;
-    rolling<const M extends AggregateOutputMap<S>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<S, RollingOutputMapSchema<S, M>, K, ByCol> | LivePartitionedSyncRolling<S, K, SeriesSchema>;
+    rolling<const M extends ValidatedAggregateMap<S, M>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<S, RollingSchema<S, M>, K, ByCol> | LivePartitionedSyncRolling<S, K, SeriesSchema>;
     /**
      * Keyed-form fused multi-window partitioned rolling. Maintains N
      * windows per partition in a single ingest pass over a single
@@ -437,28 +425,17 @@ export declare class LivePartitionedView<SBase extends SeriesSchema, R extends S
      * partition column with a passthrough reducer (e.g.
      * `host: 'last'`) to keep it visible in the unified output.
      */
-    rolling<const M extends AggregateMap<R>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
+    rolling<const M extends ValidatedAggregateMap<R, M>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
         trigger?: {
             kind: 'event' | 'count';
         };
     }): LivePartitionedView<SBase, RollingSchema<R, M>, K, ByCol>;
-    rolling<const M extends AggregateOutputMap<R>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions & {
-        trigger?: {
-            kind: 'event' | 'count';
-        };
-    }): LivePartitionedView<SBase, RollingOutputMapSchema<R, M>, K, ByCol>;
-    rolling<const M extends AggregateMap<R>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
-        trigger: {
-            kind: 'clock';
-        } & Trigger;
-    }): LivePartitionedSyncRolling<R, K, SeriesSchema>;
-    rolling<const M extends AggregateOutputMap<R>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
+    rolling<const M extends ValidatedAggregateMap<R, M>>(window: RollingWindow, mapping: M, options: LiveRollingOptions & {
         trigger: {
             kind: 'clock';
         } & Trigger;
     }): LivePartitionedSyncRolling<R, K, SeriesSchema>;
-    rolling<const M extends AggregateMap<R>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<SBase, RollingSchema<R, M>, K, ByCol> | LivePartitionedSyncRolling<R, K, SeriesSchema>;
-    rolling<const M extends AggregateOutputMap<R>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<SBase, RollingOutputMapSchema<R, M>, K, ByCol> | LivePartitionedSyncRolling<R, K, SeriesSchema>;
+    rolling<const M extends ValidatedAggregateMap<R, M>>(window: RollingWindow, mapping: M, options: LiveRollingOptions): LivePartitionedView<SBase, RollingSchema<R, M>, K, ByCol> | LivePartitionedSyncRolling<R, K, SeriesSchema>;
     /**
      * Keyed-form fused multi-window rolling on a chained
      * `LivePartitionedView`. Same shape as the root variant — each

package/dist/live/live-rolling-aggregation.d.ts

@@ -2,7 +2,7 @@ import { LiveAggregation } from './live-aggregation.js';
 import { LiveView, type LiveFillMapping, type LiveFillStrategy } from './live-view.js';
 import type { Sequence } from '../sequence/sequence.js';
 import { type Trigger } from './triggers.js';
-import type { AggregateMap, AggregateOutputMap, AggregateSchema, DiffSchema, EventDataForSchema, EventForSchema, LiveSource, NumericColumnNameForSchema, SelectSchema, SeriesSchema, ColumnValue } from '../schema/index.js';
+import type { AggregateMap, AggregateOutputMap, AggregateSchema, DiffSchema, EventDataForSchema, EventForSchema, LiveSource, NumericColumnNameForSchema, SelectSchema, SeriesSchema, ColumnValue, ValidatedAggregateMap } from '../schema/index.js';
 import type { AggregateOutputMapResultSchema } from '../schema/index.js';
 import type { DurationInput } from '../core/duration.js';
 import type { RetentionPolicy } from './live-series.js';
@@ -107,7 +107,7 @@ export declare class LiveRollingAggregation<S extends SeriesSchema, Out extends
     cumulative<const Targets extends NumericColumnNameForSchema<Out>>(spec: {
         [K in Targets]: 'sum' | 'max' | 'min' | 'count' | ((acc: number, value: number) => number);
     }): LiveView<DiffSchema<Out, Targets>>;
-    aggregate<const M extends AggregateMap<Out>>(sequence: Sequence, mapping: M): LiveAggregation<Out, AggregateSchema<Out, M>>;
+    aggregate<const M extends ValidatedAggregateMap<Out, M>>(sequence: Sequence, mapping: M): LiveAggregation<Out, AggregateSchema<Out, M>>;
     aggregate<const M extends AggregateOutputMap<Out>>(sequence: Sequence, mapping: M): LiveAggregation<Out, AggregateOutputMapResultSchema<Out, M>>;
     /**
      * Pipeline stats snapshot — cumulative counters since

package/dist/live/live-series.d.ts

@@ -5,12 +5,11 @@ import { LiveRollingAggregation, type LiveRollingOptions, type RollingWindow } f
 import { TimeSeries, type KeyLike } from '../batch/time-series.js';
 import type { TimeZoneOptions } from '../core/calendar.js';
 import type { Sequence } from '../sequence/sequence.js';
-import { EMITS_EVICT, type AggregateMap, type AggregateOutputMap, type AggregateSchema, type DiffSchema, type EventDataForSchema, type EventForSchema, type JsonObjectRowForSchema, type JsonRowForSchema, type NormalizedObjectRow, type NormalizedRowForSchema, type NumericColumnNameForSchema, type RollingSchema, type RowForSchema, type SelectSchema, type SeriesSchema, type TimeSeriesJsonInput, type TimeSeriesJsonOutputArray, type TimeSeriesJsonOutputObject } from '../schema/index.js';
-import type { AggregateOutputMapResultSchema, RollingOutputMapSchema } from '../schema/index.js';
+import { type AggregateSchema, type DiffSchema, type EventDataForSchema, type EventForSchema, type JsonObjectRowForSchema, type JsonRowForSchema, type NormalizedObjectRow, type NormalizedRowForSchema, type NumericColumnNameForSchema, type RollingSchema, type RowForSchema, type SelectSchema, type SeriesSchema, type TimeSeriesJsonInput, type TimeSeriesJsonOutputArray, type TimeSeriesJsonOutputObject } from '../schema/index.js';
 import { LiveFusedRolling } from './live-fused-rolling.js';
 import { LiveReduce } from './live-reduce.js';
 import type { SampleStrategy } from '../sequence/sample.js';
-import type { FusedMapping, FusedMappingValid, FusedRollingSchema } from '../schema/index.js';
+import type { FusedMapping, FusedMappingValid, FusedRollingSchema, ValidatedAggregateMap } from '../schema/index.js';
 import type { DurationInput } from '../core/duration.js';
 export type OrderingMode = 'strict' | 'drop' | 'reorder';
 export type RetentionPolicy = {
@@ -44,7 +43,6 @@ type BatchListener<S extends SeriesSchema> = (events: ReadonlyArray<EventForSche
 type EvictListener<S extends SeriesSchema> = (events: ReadonlyArray<EventForSchema<S>>) => void;
 export declare class LiveSeries<S extends SeriesSchema> {
     #private;
-    readonly [EMITS_EVICT]: true;
     readonly name: string;
     readonly schema: S;
     constructor(options: LiveSeriesOptions<S>);
@@ -239,10 +237,8 @@ export declare class LiveSeries<S extends SeriesSchema> {
     sample(strategy: SampleStrategy): LiveView<S>;
     select<const Keys extends readonly (keyof EventDataForSchema<S>)[]>(...keys: Keys): LiveView<SelectSchema<S, Keys[number] & string>>;
     window(size: RollingWindow): LiveView<S>;
-    aggregate<const M extends AggregateMap<S>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateSchema<S, M>>;
-    aggregate<const M extends AggregateOutputMap<S>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateOutputMapResultSchema<S, M>>;
-    rolling<const M extends AggregateMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingSchema<S, M>>;
-    rolling<const M extends AggregateOutputMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingOutputMapSchema<S, M>>;
+    aggregate<const M extends ValidatedAggregateMap<S, M>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateSchema<S, M>>;
+    rolling<const M extends ValidatedAggregateMap<S, M>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingSchema<S, M>>;
     /**
      * Keyed-form fused multi-window rolling. Maintains N windows in
      * one ingest pass over a single shared deque; emits one merged
@@ -278,8 +274,7 @@ export declare class LiveSeries<S extends SeriesSchema> {
      * `[time, ...mappingColumns]`. Composes with the rest of the
      * live operator surface.
      */
-    reduce<const M extends AggregateMap<S>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingSchema<S, M>>;
-    reduce<const M extends AggregateOutputMap<S>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingOutputMapSchema<S, M>>;
+    reduce<const M extends ValidatedAggregateMap<S, M>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingSchema<S, M>>;
     /**
      * Time span of the current buffer — `last.begin() - first.begin()`
      * in milliseconds. Returns `0` if the buffer is empty or holds a

package/dist/live/live-series.js

@@ -87,6 +87,7 @@ function assertCellKind(kind, value, name) {
 }
 // ── LiveSeries ──────────────────────────────────────────────────
 export class LiveSeries {
+    /** @internal */
     [EMITS_EVICT] = true;
     name;
     schema;
@@ -373,7 +374,7 @@ export class LiveSeries {
             rows,
         });
         // INTRA-batch order is enforced by `validateAndNormalizeColumnar`
-        // above (it throws `ValidationError("row N is out of order")`). The
+        // above (it throws a `ValidationError` naming the out-of-order row). The
         // cross-batch boundary check + commit/fan-out live in `#commitChunk`.
         const store = ColumnarStore.fromTrustedStore(this.schema, keys, columns);
         this.#commitChunk(store);

package/dist/live/live-view.d.ts

@@ -7,9 +7,8 @@ import { TimeSeries, type KeyLike } from '../batch/time-series.js';
 import type { Sequence } from '../sequence/sequence.js';
 import { TimeKeyColumn } from '../columnar/key-column.js';
 import type { PublicColumnForKind, KeyColumnForSchema } from '../column.js';
-import { EMITS_EVICT, type AggregateMap, type AggregateOutputMap, type AggregateSchema, type DiffSchema, type EventDataForSchema, type EventForSchema, type LiveSource, type NumericColumnNameForSchema, type ValueColumnNameForSchema, type RollingSchema, type ScalarValue, type SelectSchema, type SeriesSchema, type ValueColumnsForSchema } from '../schema/index.js';
-import type { AggregateOutputMapResultSchema, RollingOutputMapSchema } from '../schema/index.js';
-import type { FusedMapping, FusedMappingValid, FusedRollingSchema } from '../schema/index.js';
+import { type AggregateSchema, type DiffSchema, type EventDataForSchema, type EventForSchema, type LiveSource, type NumericColumnNameForSchema, type ValueColumnNameForSchema, type RollingSchema, type ScalarValue, type SelectSchema, type SeriesSchema, type ValueColumnsForSchema } from '../schema/index.js';
+import type { FusedMapping, FusedMappingValid, FusedRollingSchema, ValidatedAggregateMap } from '../schema/index.js';
 export type LiveFillStrategy = 'hold' | 'zero';
 export type LiveFillMapping<S extends SeriesSchema> = {
     [K in ValueColumnsForSchema<S>[number]['name']]?: LiveFillStrategy | ScalarValue;
@@ -40,7 +39,6 @@ type ViewOptions<S extends SeriesSchema> = {
 type TimeKeyOnly<S extends SeriesSchema> = KeyColumnForSchema<S> extends TimeKeyColumn ? KeyColumnForSchema<S> : 'LiveView.keyColumn() supports time-keyed views only — use toTimeSeries() for other key kinds';
 export declare class LiveView<S extends SeriesSchema> implements LiveSource<S> {
     #private;
-    readonly [EMITS_EVICT]: true;
     readonly name: string;
     readonly schema: S;
     constructor(source: LiveSource<any>, process: (event: any) => EventForSchema<S> | undefined, options?: ViewOptions<S>);
@@ -122,10 +120,8 @@ export declare class LiveView<S extends SeriesSchema> implements LiveSource<S> {
      * is per-event derivative of the named columns.
      */
     eventRate(): number;
-    aggregate<const M extends AggregateMap<S>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateSchema<S, M>>;
-    aggregate<const M extends AggregateOutputMap<S>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateOutputMapResultSchema<S, M>>;
-    rolling<const M extends AggregateMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingSchema<S, M>>;
-    rolling<const M extends AggregateOutputMap<S>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingOutputMapSchema<S, M>>;
+    aggregate<const M extends ValidatedAggregateMap<S, M>>(sequence: Sequence, mapping: M): LiveAggregation<S, AggregateSchema<S, M>>;
+    rolling<const M extends ValidatedAggregateMap<S, M>>(window: RollingWindow, mapping: M, options?: LiveRollingOptions): LiveRollingAggregation<S, RollingSchema<S, M>>;
     /**
      * Keyed-form fused multi-window rolling on a `LiveView`. See
      * {@link LiveSeries.rolling} for the full surface — chained-from-
@@ -137,8 +133,7 @@ export declare class LiveView<S extends SeriesSchema> implements LiveSource<S> {
      * Streaming reduce over the view's current buffer. See
      * {@link LiveSeries.reduce} for the full surface.
      */
-    reduce<const M extends AggregateMap<S>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingSchema<S, M>>;
-    reduce<const M extends AggregateOutputMap<S>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingOutputMapSchema<S, M>>;
+    reduce<const M extends ValidatedAggregateMap<S, M>>(mapping: M, options?: LiveRollingOptions): LiveReduce<S, RollingSchema<S, M>>;
     diff<const Target extends NumericColumnNameForSchema<S>>(columns: Target | readonly Target[], options?: {
         drop?: boolean;
     }): LiveView<DiffSchema<S, Target>>;

package/dist/live/live-view.js

@@ -11,6 +11,7 @@ import { TimeKeyColumn } from '../columnar/key-column.js';
 import { EMITS_EVICT, } from '../schema/index.js';
 import { parseDuration } from '../core/duration.js';
 export class LiveView {
+    /** @internal */
     [EMITS_EVICT] = true;
     name;
     schema;

package/dist/reducers/first.js

@@ -1,6 +1,7 @@
 import { rollingOrderedEntries } from './rolling.js';
 export const first = {
     outputKind: 'source',
+    definedBoundary: 'first',
     reduce(defined) {
         return defined[0];
     },

package/dist/reducers/last.js

@@ -1,6 +1,7 @@
 import { rollingOrderedEntries } from './rolling.js';
 export const last = {
     outputKind: 'source',
+    definedBoundary: 'last',
     reduce(defined) {
         return defined[defined.length - 1];
     },

package/dist/reducers/types.d.ts

@@ -85,6 +85,22 @@ export type ReducerDef = {
      * `reduceColumn` may assume the column is a packed `Float64Column`.
      */
     reduceColumn?(col: Float64Column): ColumnValue | undefined;
+    /**
+     * **Columnar fast-path for boundary selectors.** Present only on
+     * `first` / `last`. Marks the reducer as "pick the {first|last}
+     * *defined* value in the bucket" — which a columnar caller can compute
+     * as a boundary scan over the source column (via `col.read(i)`, any
+     * kind / any storage) instead of bailing the whole call to the row
+     * path just because these reducers lack a numeric `reduceColumn`.
+     *
+     * Semantics match `reduce` / `bucketState` exactly: scan past *missing*
+     * cells to the first/last cell whose `read(i)` is not `undefined`; an
+     * all-missing or empty bucket yields `undefined`. This is what lets the
+     * partitioned-`aggregate` fast path run — the auto-injected
+     * partition-column reducer is `'first'` (see `PartitionedTimeSeries`),
+     * which previously tripped the all-or-nothing gate for every call.
+     */
+    definedBoundary?: 'first' | 'last';
     /** Return a fresh incremental state for one aggregation bucket. */
     bucketState(): AggregateBucketState;
     /** Return a fresh incremental state for one rolling window column. */