pond-ts 0.1.4 → 0.3.0

package/dist/TimeSeries.js

@@ -1,10 +1,13 @@
+var _a;
 import { BoundedSequence } from './BoundedSequence.js';
 import { parseTimestampString } from './calendar.js';
 import { Interval } from './Interval.js';
 import { Time } from './Time.js';
 import { TimeRange } from './TimeRange.js';
+import { Event } from './Event.js';
 import { Sequence } from './Sequence.js';
 import { validateAndNormalize } from './validate.js';
+import { resolveReducer, } from './reducers/index.js';
 function isObjectRow(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -89,6 +92,23 @@ function parseJsonRows(schema, rows, options = {}) {
         }));
     });
 }
+function serializeJsonKey(kind, key, rowFormat) {
+    if (kind === 'time') {
+        return key.begin();
+    }
+    if (kind === 'timeRange') {
+        return rowFormat === 'object'
+            ? { start: key.begin(), end: key.end() }
+            : [key.begin(), key.end()];
+    }
+    const interval = key;
+    return rowFormat === 'object'
+        ? { value: interval.value, start: interval.begin(), end: interval.end() }
+        : [interval.value, interval.begin(), interval.end()];
+}
+function serializeJsonValue(value) {
+    return value === undefined ? null : value;
+}
 function toRows(schema, events) {
     return events.map((event) => {
         const data = event.data();
@@ -100,6 +120,20 @@ function toRows(schema, events) {
         ]);
     });
 }
+function toObjects(schema, events) {
+    const keyColumn = schema[0];
+    const dataColumns = schema.slice(1);
+    return events.map((event) => {
+        const row = {
+            [keyColumn.name]: event.key(),
+        };
+        const data = event.data();
+        for (const column of dataColumns) {
+            row[column.name] = data[column.name];
+        }
+        return Object.freeze(row);
+    });
+}
 function isEventKey(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -180,26 +214,38 @@ function eventAnchorTime(key) {
     return key instanceof Time ? key.begin() : key.timeRange().midpoint();
 }
 function loessAt(x, anchors, values, span) {
-    const points = anchors.flatMap((anchor, index) => {
-        const value = values[index];
-        return value === undefined ? [] : [{ x: anchor, y: value }];
-    });
-    if (points.length === 0) {
+    if (anchors.length === 0) {
         return undefined;
     }
-    if (points.length === 1) {
-        return points[0].y;
+    if (anchors.length === 1) {
+        return values[0];
     }
-    const neighborCount = Math.max(2, Math.min(points.length, Math.ceil(span * points.length)));
-    const sortedDistances = points
-        .map((point) => ({ point, distance: Math.abs(point.x - x) }))
-        .sort((left, right) => left.distance - right.distance);
-    const bandwidth = sortedDistances[neighborCount - 1].distance;
+    const neighborCount = Math.max(2, Math.min(anchors.length, Math.ceil(span * anchors.length)));
+    let start = 0;
+    if (neighborCount < anchors.length) {
+        let low = 0;
+        let high = anchors.length - neighborCount;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (x - anchors[mid] > anchors[mid + neighborCount] - x) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        start = low;
+    }
+    const end = start + neighborCount;
+    const bandwidth = Math.max(Math.abs(x - anchors[start]), Math.abs(anchors[end - 1] - x));
     if (bandwidth === 0) {
-        const coincident = sortedDistances
-            .filter((entry) => entry.distance === 0)
-            .map((entry) => entry.point.y);
-        return (coincident.reduce((sum, value) => sum + value, 0) / coincident.length);
+        const coincidentStart = lowerBound(anchors, x);
+        const coincidentEnd = upperBound(anchors, x);
+        let coincidentSum = 0;
+        for (let index = coincidentStart; index < coincidentEnd; index++) {
+            coincidentSum += values[index];
+        }
+        return coincidentSum / (coincidentEnd - coincidentStart);
     }
     let weightedCount = 0;
     let sumW = 0;
@@ -207,7 +253,10 @@ function loessAt(x, anchors, values, span) {
     let sumWY = 0;
     let sumWXX = 0;
     let sumWXY = 0;
-    for (const { point, distance } of sortedDistances.slice(0, neighborCount)) {
+    for (let index = start; index < end; index++) {
+        const pointX = anchors[index];
+        const pointY = values[index];
+        const distance = Math.abs(pointX - x);
         const ratio = distance / bandwidth;
         const weight = ratio >= 1 ? 0 : (1 - ratio ** 3) ** 3;
         if (weight === 0) {
@@ -215,10 +264,10 @@ function loessAt(x, anchors, values, span) {
         }
         weightedCount += 1;
         sumW += weight;
-        sumWX += weight * point.x;
-        sumWY += weight * point.y;
-        sumWXX += weight * point.x * point.x;
-        sumWXY += weight * point.x * point.y;
+        sumWX += weight * pointX;
+        sumWY += weight * pointY;
+        sumWXX += weight * pointX * pointX;
+        sumWXY += weight * pointX * pointY;
     }
     if (weightedCount === 0 || sumW === 0) {
         return undefined;
@@ -231,6 +280,34 @@ function loessAt(x, anchors, values, span) {
     const slope = (sumW * sumWXY - sumWX * sumWY) / denominator;
     return intercept + slope * x;
 }
+function lowerBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (values[mid] < target) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+function upperBound(values, target) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        if (values[mid] <= target) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
 function makeSmoothSchema(schema, target, output) {
     if (output === undefined || output === target) {
         return Object.freeze([
@@ -273,28 +350,60 @@ function bucketOverlapsHalfOpen(bucket, event) {
 function aggregateValues(operation, values) {
     const defined = values.filter((value) => value !== undefined);
     const numeric = defined.filter((value) => typeof value === 'number');
-    switch (operation) {
-        case 'count':
-            return defined.length;
-        case 'sum':
-            return numeric.reduce((sum, value) => sum + value, 0);
-        case 'avg':
-            return numeric.length === 0
-                ? undefined
-                : numeric.reduce((sum, value) => sum + value, 0) / numeric.length;
-        case 'min':
-            return numeric.length === 0
-                ? undefined
-                : numeric.reduce((left, right) => (left <= right ? left : right));
-        case 'max':
-            return numeric.length === 0
-                ? undefined
-                : numeric.reduce((left, right) => (left >= right ? left : right));
-        case 'first':
-            return defined[0];
-        case 'last':
-            return defined[defined.length - 1];
+    return resolveReducer(operation).reduce(defined, numeric);
+}
+function isBuiltInAggregateReducer(reducer) {
+    return typeof reducer === 'string';
+}
+function applyAggregateReducer(reducer, values) {
+    return isBuiltInAggregateReducer(reducer)
+        ? aggregateValues(reducer, values)
+        : reducer(values);
+}
+function isAggregateOutputSpec(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'from' in value &&
+        'using' in value);
+}
+function normalizeAggregateColumns(schema, mapping) {
+    const columnsByName = new Map(schema.slice(1).map((column) => [column.name, column]));
+    const normalized = [];
+    for (const [outputName, raw] of Object.entries(mapping)) {
+        const sourceName = isAggregateOutputSpec(raw) ? raw.from : outputName;
+        const sourceColumn = columnsByName.get(sourceName);
+        if (!sourceColumn) {
+            throw new TypeError(`aggregate mapping references unknown source column '${sourceName}'`);
+        }
+        if (sourceColumn.kind !== 'number' &&
+            sourceColumn.kind !== 'string' &&
+            sourceColumn.kind !== 'boolean') {
+            throw new TypeError(`aggregate source column '${sourceName}' must be a scalar value column`);
+        }
+        const reducer = isAggregateOutputSpec(raw) ? raw.using : raw;
+        if (typeof reducer !== 'string' && typeof reducer !== 'function') {
+            throw new TypeError(`aggregate reducer for '${outputName}' must be a built-in name or function`);
+        }
+        const explicitKind = isAggregateOutputSpec(raw) ? raw.kind : undefined;
+        const resolvedKind = explicitKind ??
+            (typeof reducer === 'string' &&
+                resolveReducer(reducer).outputKind === 'number'
+                ? 'number'
+                : sourceColumn.kind);
+        normalized.push({
+            output: outputName,
+            source: sourceName,
+            reducer,
+            kind: resolvedKind,
+        });
     }
+    return normalized;
+}
+function createAggregateBucketState(operation) {
+    return resolveReducer(operation).bucketState();
+}
+function createRollingReducerState(operation) {
+    return resolveReducer(operation).rollingState();
 }
 function parseDurationInput(value) {
     if (typeof value === 'number') {
@@ -428,7 +537,7 @@ export class TimeSeries {
      * the supplied `parse.timeZone`, which defaults to `UTC`.
      */
     static fromJSON(input) {
-        return new TimeSeries({
+        return new _a({
             name: input.name,
             schema: input.schema,
             rows: parseJsonRows(input.schema, input.rows, input.parse),
@@ -441,6 +550,61 @@ export class TimeSeries {
         this.events = validateAndNormalize(input);
         Object.freeze(this);
     }
+    /**
+     * Example: `series.toJSON({ rowFormat: "object" })`.
+     * Serializes the series into the JSON-friendly shape accepted by `TimeSeries.fromJSON(...)`.
+     *
+     * Timestamps are emitted as numbers to avoid time zone ambiguity. Missing payload values are
+     * emitted as `null`. By default rows are emitted as arrays; use `rowFormat: "object"` for rows
+     * keyed by schema column names.
+     */
+    toJSON(options = {}) {
+        const rowFormat = options.rowFormat ?? 'array';
+        const dataColumns = this.schema.slice(1);
+        if (rowFormat === 'object') {
+            const keyColumn = this.schema[0];
+            const rows = this.events.map((event) => {
+                const row = {
+                    [keyColumn.name]: serializeJsonKey(keyColumn.kind, event.key(), rowFormat),
+                };
+                const data = event.data();
+                for (const column of dataColumns) {
+                    row[column.name] = serializeJsonValue(data[column.name]);
+                }
+                return Object.freeze(row);
+            });
+            return {
+                name: this.name,
+                schema: this.schema,
+                rows,
+            };
+        }
+        const rows = this.events.map((event) => {
+            const data = event.data();
+            return Object.freeze([
+                serializeJsonKey(this.schema[0].kind, event.key(), rowFormat),
+                ...dataColumns.map((column) => serializeJsonValue(data[column.name])),
+            ]);
+        });
+        return {
+            name: this.name,
+            schema: this.schema,
+            rows,
+        };
+    }
+    /**
+     * Builds a series from event data that has already been validated and ordered by the caller.
+     *
+     * This is intentionally private and only used by transforms that preserve the existing event
+     * order and normalized key invariants.
+     */
+    static #fromTrustedEvents(name, schema, events) {
+        const series = Object.create(_a.prototype);
+        series.name = name;
+        series.schema = Object.freeze(schema.slice());
+        series.events = Object.freeze(events.slice());
+        return Object.freeze(series);
+    }
     /** Example: `series.firstColumnKind`. Returns the first-column kind from the series schema. */
     get firstColumnKind() {
         return this.schema[0].kind;
@@ -449,6 +613,14 @@ export class TimeSeries {
     get rows() {
         return toRows(this.schema, this.events);
     }
+    /** Example: `series.toRows()`. Returns normalized row arrays using `Time`/`TimeRange`/`Interval` keys and `undefined` for missing payload values. */
+    toRows() {
+        return this.rows;
+    }
+    /** Example: `series.toObjects()`. Returns normalized schema-keyed object rows using temporal key objects and `undefined` for missing payload values. */
+    toObjects() {
+        return toObjects(this.schema, this.events);
+    }
     /** Example: `series.at(0)`. Returns the event at the supplied zero-based position, if present. */
     at(index) {
         return this.events[index];
@@ -466,7 +638,7 @@ export class TimeSeries {
     /** Example: `series.map(nextSchema, event => event)`. Maps each event into a new typed schema and returns a new series. */
     map(schema, mapper) {
         const mappedEvents = this.events.map((event, index) => mapper(event, index));
-        return new TimeSeries({
+        return new _a({
             name: this.name,
             schema,
             rows: toRows(schema, mappedEvents),
@@ -478,10 +650,14 @@ export class TimeSeries {
             { name: 'time', kind: 'time' },
             ...this.schema.slice(1),
         ]);
-        return new TimeSeries({
+        const resultEvents = this.events.map((event) => event.asTime(options));
+        if ((options.at ?? 'begin') === 'begin') {
+            return _a.#fromTrustedEvents(this.name, schema, resultEvents);
+        }
+        return new _a({
             name: this.name,
             schema,
-            rows: toRows(schema, this.events.map((event) => event.asTime(options))),
+            rows: toRows(schema, resultEvents),
         });
     }
     /** Example: `series.asTimeRange()`. Converts the series key type to `"timeRange"` while preserving each event extent. */
@@ -490,11 +666,8 @@ export class TimeSeries {
             { name: 'timeRange', kind: 'timeRange' },
             ...this.schema.slice(1),
         ]);
-        return new TimeSeries({
-            name: this.name,
-            schema,
-            rows: toRows(schema, this.events.map((event) => event.asTimeRange())),
-        });
+        const resultEvents = this.events.map((event) => event.asTimeRange());
+        return _a.#fromTrustedEvents(this.name, schema, resultEvents);
     }
     asInterval(value) {
         const schema = Object.freeze([
@@ -506,14 +679,13 @@ export class TimeSeries {
                 ? event.asInterval(() => value(event, index))
                 : event.asInterval(value);
         });
-        return new TimeSeries({
-            name: this.name,
-            schema,
-            rows: toRows(schema, nextEvents),
-        });
+        return _a.#fromTrustedEvents(this.name, schema, nextEvents);
     }
     join(other, options = {}) {
-        const [left, right] = prepareSeriesForJoin([this, other], options);
+        const [left, right] = prepareSeriesForJoin([
+            this,
+            other,
+        ], options);
         const joinType = options.type ?? 'outer';
         if (left.firstColumnKind !== right.firstColumnKind) {
             throw new TypeError('cannot join series with different key kinds');
@@ -566,11 +738,7 @@ export class TimeSeries {
                 rightIndex += 1;
             }
         }
-        return new TimeSeries({
-            name: left.name,
-            schema: resultSchema,
-            rows: toRows(resultSchema, joinedEvents),
-        });
+        return _a.#fromTrustedEvents(left.name, resultSchema, joinedEvents);
     }
     /**
      * Example: `series.align(Sequence.every("1m"))`.
@@ -602,7 +770,7 @@ export class TimeSeries {
         const range = options.range ?? this.timeRange();
         const resultSchema = makeAlignedSchema(this.schema);
         if (!range) {
-            return new TimeSeries({
+            return new _a({
                 name: this.name,
                 schema: resultSchema,
                 rows: [],
@@ -613,103 +781,481 @@ export class TimeSeries {
         }
         const intervals = toBoundedSequence(sequence, range, sample).intervals();
         const valueColumns = this.schema.slice(1);
-        const alignedRows = intervals.map((interval) => {
-            const t = sampleTime(interval, sample);
-            const data = method === 'linear'
-                ? this.#alignLinearAt(t, valueColumns)
-                : this.#alignHoldAt(t);
-            return Object.freeze([
-                interval,
-                ...resultSchema
-                    .slice(1)
-                    .map((column) => data[column.name]),
-            ]);
-        });
-        return new TimeSeries({
+        const resultColumns = resultSchema.slice(1);
+        const alignedRows = method === 'linear'
+            ? (() => {
+                const cursor = { index: 0 };
+                const rows = new Array(intervals.length);
+                for (let i = 0; i < intervals.length; i += 1) {
+                    const interval = intervals[i];
+                    const t = sampleTime(interval, sample);
+                    const data = alignLinearAt(this, t, valueColumns, cursor);
+                    const row = new Array(resultColumns.length + 1);
+                    row[0] = interval;
+                    for (let j = 0; j < resultColumns.length; j += 1) {
+                        const column = resultColumns[j];
+                        row[j + 1] = data[column.name];
+                    }
+                    rows[i] = Object.freeze(row);
+                }
+                return rows;
+            })()
+            : intervals.map((interval) => {
+                const t = sampleTime(interval, sample);
+                const data = alignHoldAt(this, t);
+                return Object.freeze([
+                    interval,
+                    ...resultSchema
+                        .slice(1)
+                        .map((column) => data[column.name]),
+                ]);
+            });
+        return new _a({
             name: this.name,
             schema: resultSchema,
             rows: alignedRows,
         });
     }
+    aggregate(sequence, mapping, options = {}) {
+        return aggregateInternal(this, sequence, mapping, options);
+    }
+    reduce(columnOrMapping, reducer) {
+        if (typeof columnOrMapping === 'string') {
+            const values = this.events.map((event) => {
+                const data = event.data();
+                return data[columnOrMapping];
+            });
+            return applyAggregateReducer(reducer, values);
+        }
+        const columns = normalizeAggregateColumns(this.schema, columnOrMapping);
+        const result = {};
+        for (const col of columns) {
+            const values = this.events.map((event) => {
+                const data = event.data();
+                return data[col.source];
+            });
+            result[col.output] = applyAggregateReducer(col.reducer, values);
+        }
+        return result;
+    }
+    groupBy(column, transform) {
+        const buckets = new Map();
+        for (const event of this.events) {
+            const raw = event.data()[column];
+            const key = raw === undefined ? 'undefined' : String(raw);
+            let bucket = buckets.get(key);
+            if (!bucket) {
+                bucket = [];
+                buckets.set(key, bucket);
+            }
+            bucket.push(event);
+        }
+        const buildGroup = (events) => new _a({
+            name: this.name,
+            schema: this.schema,
+            rows: toRows(this.schema, events),
+        });
+        if (transform) {
+            const result = new Map();
+            for (const [key, events] of buckets) {
+                result.set(key, transform(buildGroup(events), key));
+            }
+            return result;
+        }
+        const result = new Map();
+        for (const [key, events] of buckets) {
+            result.set(key, buildGroup(events));
+        }
+        return result;
+    }
     /**
-     * Example: `series.aggregate(Sequence.every("1m"), { value: "avg" })`.
-     * Aggregates events into sequence buckets using built-in reducer names.
+     * Example: `series.diff("requests")`.
+     * Computes per-event differences for the specified numeric columns.
+     * Non-specified columns pass through unchanged. The first event gets
+     * `undefined` in affected columns unless `{ drop: true }` is passed,
+     * which removes the first event entirely.
      *
-     * Buckets use half-open membership semantics: `[begin, end)`. Point events contribute to the
-     * bucket containing their timestamp. Interval-like events contribute to every bucket they
-     * overlap under half-open overlap rules.
+     * Example: `series.diff(["requests", "cpu"])`.
+     * Multiple columns can be diffed in a single call.
      *
-     * Defaults:
-     * - `range`: `series.timeRange()`
+     * Example: `series.diff("requests", { drop: true })`.
+     * Drops the first event instead of keeping it with undefined values.
+     */
+    diff(columns, options) {
+        return this.#diffOrRate('diff', columns, options);
+    }
+    /**
+     * Example: `series.rate("requests")`.
+     * Computes the per-second rate of change for the specified numeric columns.
+     * Non-specified columns pass through unchanged. The first event gets
+     * `undefined` in affected columns unless `{ drop: true }` is passed,
+     * which removes the first event entirely.
      *
-     * As with `align(...)`, `Sequence` defines the underlying grid and `range` selects which portion
-     * of that grid is bounded. With `Sequence.every(...)`, the default grid anchor is Unix epoch `0`,
-     * but the default aggregation range is always the source series extent. When a
-     * `BoundedSequence` is supplied, its intervals are used directly.
+     * Example: `series.rate(["requests", "cpu"])`.
+     * Multiple columns can be rated in a single call.
+     *
+     * Example: `series.rate("requests", { drop: true })`.
+     * Drops the first event instead of keeping it with undefined values.
+     */
+    rate(columns, options) {
+        return this.#diffOrRate('rate', columns, options);
+    }
+    /**
+     * Example: `series.pctChange("requests")`.
+     * Computes the percentage change `(curr - prev) / prev` for the specified
+     * numeric columns. Non-specified columns pass through unchanged. The first
+     * event gets `undefined` in affected columns unless `{ drop: true }` is
+     * passed.
+     */
+    pctChange(columns, options) {
+        return this.#diffOrRate('pctChange', columns, options);
+    }
+    #diffOrRate(mode, columns, options) {
+        const cols = typeof columns === 'string' ? [columns] : columns;
+        const drop = options?.drop === true;
+        if (cols.length === 0) {
+            throw new Error(`${mode}() requires at least one column name`);
+        }
+        const targetSet = new Set(cols);
+        const outSchema = Object.freeze(this.schema.map((col, i) => {
+            if (i === 0)
+                return col;
+            if (targetSet.has(col.name)) {
+                return { ...col, kind: 'number', required: false };
+            }
+            return col;
+        }));
+        const events = this.events;
+        if (events.length === 0) {
+            return _a.#fromTrustedEvents(this.name, outSchema, []);
+        }
+        const resultEvents = [];
+        if (!drop) {
+            const firstData = { ...events[0].data() };
+            for (const col of cols) {
+                firstData[col] = undefined;
+            }
+            resultEvents.push(new Event(events[0].key(), firstData));
+        }
+        for (let i = 1; i < events.length; i++) {
+            const prev = events[i - 1];
+            const curr = events[i];
+            const data = { ...curr.data() };
+            const dt = mode === 'rate' ? (curr.begin() - prev.begin()) / 1000 : undefined;
+            for (const col of cols) {
+                const prevVal = prev.data()[col];
+                const currVal = data[col];
+                if (typeof currVal === 'number' && typeof prevVal === 'number') {
+                    const delta = currVal - prevVal;
+                    if (mode === 'pctChange') {
+                        data[col] = prevVal !== 0 ? delta / prevVal : undefined;
+                    }
+                    else if (mode === 'rate') {
+                        data[col] = dt !== 0 ? delta / dt : undefined;
+                    }
+                    else {
+                        data[col] = delta;
+                    }
+                }
+                else {
+                    data[col] = undefined;
+                }
+            }
+            resultEvents.push(new Event(curr.key(), data));
+        }
+        return _a.#fromTrustedEvents(this.name, outSchema, resultEvents);
+    }
+    /**
+     * Example: `series.cumulative({ requests: "sum" })`.
+     * Computes running accumulations for the specified numeric columns.
+     * Non-accumulated columns pass through unchanged.
      *
-     * Override `range` when you need multiple series aggregated over the same reporting window,
-     * including leading or trailing empty buckets outside an individual series extent.
+     * Built-in accumulators: `"sum"`, `"max"`, `"min"`, `"count"`.
+     * Custom accumulators: `(acc: number, value: number) => number`.
+     */
+    cumulative(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(this.schema.map((col, i) => {
+            if (i === 0)
+                return col;
+            if (targetSet.has(col.name)) {
+                return { ...col, kind: 'number', required: false };
+            }
+            return col;
+        }));
+        const events = this.events;
+        if (events.length === 0) {
+            return _a.#fromTrustedEvents(this.name, outSchema, []);
+        }
+        const state = new Map();
+        for (const [name, reducer] of entries) {
+            if (typeof reducer === 'function') {
+                const fn = reducer;
+                state.set(name, {
+                    acc: undefined,
+                    apply: (acc, v) => (acc === undefined ? v : fn(acc, v)),
+                });
+            }
+            else {
+                switch (reducer) {
+                    case 'sum':
+                        state.set(name, {
+                            acc: undefined,
+                            apply: (acc, v) => (acc ?? 0) + v,
+                        });
+                        break;
+                    case 'count':
+                        state.set(name, { acc: undefined, apply: (acc) => (acc ?? 0) + 1 });
+                        break;
+                    case 'max':
+                        state.set(name, {
+                            acc: undefined,
+                            apply: (acc, v) => (acc === undefined || v > acc ? v : acc),
+                        });
+                        break;
+                    case 'min':
+                        state.set(name, {
+                            acc: undefined,
+                            apply: (acc, v) => (acc === undefined || v < acc ? v : acc),
+                        });
+                        break;
+                }
+            }
+        }
+        const resultEvents = [];
+        for (const event of events) {
+            const data = { ...event.data() };
+            for (const [name, s] of state) {
+                const raw = data[name];
+                if (typeof raw === 'number') {
+                    s.acc = s.apply(s.acc, raw);
+                    data[name] = s.acc;
+                }
+                else {
+                    data[name] = s.acc;
+                }
+            }
+            resultEvents.push(new Event(event.key(), data));
+        }
+        return _a.#fromTrustedEvents(this.name, outSchema, resultEvents);
+    }
+    /**
+     * Example: `series.shift("value", 1)`.
+     * Lags column values by N events (positive N) or leads them (negative N).
+     * Vacated positions get `undefined`.
+     */
+    shift(columns, n) {
+        const cols = typeof columns === 'string' ? [columns] : columns;
+        if (cols.length === 0) {
+            throw new Error('shift() requires at least one column name');
+        }
+        if (!Number.isInteger(n)) {
+            throw new Error('shift() requires an integer offset');
+        }
+        const targetSet = new Set(cols);
+        const outSchema = Object.freeze(this.schema.map((col, i) => {
+            if (i === 0)
+                return col;
+            if (targetSet.has(col.name)) {
+                return { ...col, kind: 'number', required: false };
+            }
+            return col;
+        }));
+        const events = this.events;
+        if (events.length === 0) {
+            return _a.#fromTrustedEvents(this.name, outSchema, []);
+        }
+        const resultEvents = [];
+        for (let i = 0; i < events.length; i++) {
+            const data = { ...events[i].data() };
+            const srcIdx = i - n;
+            for (const col of cols) {
+                if (srcIdx >= 0 && srcIdx < events.length) {
+                    data[col] = events[srcIdx].data()[col];
+                }
+                else {
+                    data[col] = undefined;
+                }
+            }
+            resultEvents.push(new Event(events[i].key(), data));
+        }
+        return _a.#fromTrustedEvents(this.name, outSchema, resultEvents);
+    }
+    /**
+     * Example: `series.fill("hold")`.
+     * Fills `undefined` values using the given strategy for all payload columns.
      *
-     * To align buckets to the beginning of the current series instead of epoch boundaries, override
-     * the sequence anchor rather than the aggregation range:
+     * Example: `series.fill({ cpu: "linear", host: "hold" })`.
+     * Per-column fill strategies. Unmentioned columns are left as-is.
+     * Strategy names: `"hold"` (forward fill), `"linear"` (time-interpolated),
+     * `"zero"` (fill with 0). A non-string value is used as a literal fill value.
      *
-     * ```ts
-     * const range = series.timeRange();
-     * if (!range) {
-     *   throw new Error("empty series");
-     * }
+     * Example: `series.fill("hold", { limit: 3 })`.
+     * Caps consecutive fills per column. After `limit` consecutive fills, further
+     * `undefined` values are left as-is until a real value resets the counter.
      *
-     * const aggregated = series.aggregate(
-     *   Sequence.every("1m", { anchor: range.begin() }),
-     *   { value: "avg" },
-     * );
-     * ```
+     * `"linear"` requires known values on both sides of a gap to interpolate.
+     * Leading and trailing `undefined` runs are left unfilled.
      */
-    aggregate(sequence, mapping, options = {}) {
-        const range = options.range ?? this.timeRange();
-        const resultSchema = Object.freeze([
-            { name: 'interval', kind: 'interval' },
-            ...this.schema
-                .slice(1)
-                .filter((column) => column.name in mapping)
-                .map((column) => {
-                const operation = mapping[column.name];
-                return {
-                    name: column.name,
-                    kind: operation === 'sum' ||
-                        operation === 'avg' ||
-                        operation === 'count'
-                        ? 'number'
-                        : column.kind,
-                    required: false,
-                };
-            }),
-        ]);
-        if (!range) {
-            return new TimeSeries({
-                name: this.name,
-                schema: resultSchema,
-                rows: [],
-            });
+    fill(strategy, options) {
+        if (this.events.length === 0) {
+            return this;
         }
-        const buckets = toBoundedSequence(sequence, range, 'begin').intervals();
-        const resultRows = buckets.map((bucket) => {
-            const contributors = this.events.filter((event) => bucketOverlapsHalfOpen(bucket, event.key()));
-            const aggregated = resultSchema.slice(1).map((column) => {
-                const operation = mapping[column.name];
-                const values = contributors.map((event) => {
-                    const data = event.data();
-                    return data[column.name];
-                });
-                return aggregateValues(operation, values);
-            });
-            return Object.freeze([bucket, ...aggregated]);
-        });
-        return new TimeSeries({
-            name: this.name,
-            schema: resultSchema,
-            rows: resultRows,
-        });
+        const colNames = this.schema.slice(1).map((c) => c.name);
+        const specs = new Map();
+        if (typeof strategy === 'string') {
+            for (const name of colNames) {
+                specs.set(name, { mode: strategy });
+            }
+        }
+        else {
+            const strategies = new Set([
+                'hold',
+                'bfill',
+                'linear',
+                'zero',
+            ]);
+            for (const [name, spec] of Object.entries(strategy)) {
+                if (typeof spec === 'string' && strategies.has(spec)) {
+                    specs.set(name, { mode: spec });
+                }
+                else {
+                    specs.set(name, { mode: 'literal', value: spec });
+                }
+            }
+        }
+        const limit = options?.limit;
+        const n = this.events.length;
+        const columns = {};
+        for (const name of colNames) {
+            columns[name] = new Array(n);
+        }
+        for (let i = 0; i < n; i++) {
+            const data = this.events[i].data();
+            for (const name of colNames) {
+                columns[name][i] = data[name];
+            }
+        }
+        const times = new Array(n);
+        for (let i = 0; i < n; i++) {
+            times[i] = this.events[i].begin();
+        }
+        for (const [name, spec] of specs) {
+            const col = columns[name];
+            if (!col)
+                continue;
+            switch (spec.mode) {
+                case 'hold': {
+                    let last;
+                    let consecutive = 0;
+                    for (let i = 0; i < n; i++) {
+                        if (col[i] !== undefined) {
+                            last = col[i];
+                            consecutive = 0;
+                        }
+                        else if (last !== undefined) {
+                            consecutive++;
+                            if (limit === undefined || consecutive <= limit) {
+                                col[i] = last;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'bfill': {
+                    let next;
+                    let consecutive = 0;
+                    for (let i = n - 1; i >= 0; i--) {
+                        if (col[i] !== undefined) {
+                            next = col[i];
+                            consecutive = 0;
+                        }
+                        else if (next !== undefined) {
+                            consecutive++;
+                            if (limit === undefined || consecutive <= limit) {
+                                col[i] = next;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'zero': {
+                    let consecutive = 0;
+                    for (let i = 0; i < n; i++) {
+                        if (col[i] !== undefined) {
+                            consecutive = 0;
+                        }
+                        else {
+                            consecutive++;
+                            if (limit === undefined || consecutive <= limit) {
+                                col[i] = 0;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'literal': {
+                    let consecutive = 0;
+                    for (let i = 0; i < n; i++) {
+                        if (col[i] !== undefined) {
+                            consecutive = 0;
+                        }
+                        else {
+                            consecutive++;
+                            if (limit === undefined || consecutive <= limit) {
+                                col[i] = spec.value;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case 'linear': {
+                    let gapStart = -1;
+                    for (let i = 0; i < n; i++) {
+                        if (col[i] !== undefined) {
+                            if (gapStart >= 0 && gapStart > 0) {
+                                const before = col[gapStart - 1];
+                                const after = col[i];
+                                const t0 = times[gapStart - 1];
+                                const t1 = times[i];
+                                const span = t1 - t0;
+                                const gapLen = i - gapStart;
+                                for (let j = gapStart; j < i; j++) {
+                                    const fillIndex = j - gapStart + 1;
+                                    if (limit !== undefined && fillIndex > limit)
+                                        break;
+                                    if (span === 0) {
+                                        col[j] = before;
+                                    }
+                                    else {
+                                        const ratio = (times[j] - t0) / span;
+                                        col[j] = before + (after - before) * ratio;
+                                    }
+                                }
+                            }
+                            gapStart = -1;
+                        }
+                        else if (gapStart < 0) {
+                            gapStart = i;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        const resultEvents = [];
+        for (let i = 0; i < n; i++) {
+            const data = {};
+            for (const name of colNames) {
+                data[name] = columns[name][i];
+            }
+            resultEvents.push(new Event(this.events[i].key(), data));
+        }
+        return _a.#fromTrustedEvents(this.name, this.schema, resultEvents);
     }
     rolling(sequenceOrWindow, windowOrMapping, mappingOrOptions, maybeOptions = {}) {
         const buildResultColumns = () => this.schema
@@ -765,7 +1311,7 @@ export class TimeSeries {
                 ...buildResultColumns(),
             ]);
             if (!range) {
-                return new TimeSeries({
+                return new _a({
                     name: this.name,
                     schema: resultSchema,
                     rows: [],
@@ -776,39 +1322,162 @@ export class TimeSeries {
                 const anchor = sampleTime(bucket, sample);
                 const contributors = this.events.filter((candidate) => anchorInWindow(candidate.begin(), anchor));
                 const aggregated = resultSchema.slice(1).map((column) => {
-                    const operation = mapping[column.name];
+                    const reducer = mapping[column.name];
                     const values = contributors.map((candidate) => {
                         const data = candidate.data();
                         return data[column.name];
                     });
-                    return aggregateValues(operation, values);
+                    return applyAggregateReducer(reducer, values);
                 });
                 return Object.freeze([bucket, ...aggregated]);
             });
-            return new TimeSeries({
+            return new _a({
                 name: this.name,
                 schema: resultSchema,
                 rows: resultRows,
             });
         }
+        const resultColumns = buildResultColumns();
         const resultSchema = Object.freeze([
             this.schema[0],
-            ...buildResultColumns(),
+            ...resultColumns,
         ]);
-        const resultRows = this.events.map((event) => {
-            const anchor = event.begin();
-            const contributors = this.events.filter((candidate) => anchorInWindow(candidate.begin(), anchor));
-            const aggregated = resultSchema.slice(1).map((column) => {
-                const operation = mapping[column.name];
-                const values = contributors.map((candidate) => {
-                    const data = candidate.data();
-                    return data[column.name];
-                });
-                return aggregateValues(operation, values);
+        const reducerStates = resultColumns.map((column) => {
+            const reducer = mapping[column.name];
+            return isBuiltInAggregateReducer(reducer)
+                ? createRollingReducerState(reducer)
+                : null;
+        });
+        const beginTimes = this.events.map((event) => event.begin());
+        const resultRows = new Array(this.events.length);
+        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 column = resultColumns[i];
+                    state.add(index, data[column.name]);
+                }
+            }
+        };
+        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 column = resultColumns[i];
+                    state.remove(index, data[column.name]);
+                }
+            }
+        };
+        const snapshotWindow = () => resultColumns.map((column, i) => {
+            const state = reducerStates[i];
+            if (state)
+                return state.snapshot();
+            const reducer = mapping[column.name];
+            const values = this.events
+                .slice(windowStart, windowEnd)
+                .map((event) => {
+                const data = event.data();
+                return data[column.name];
             });
-            return Object.freeze([event.key(), ...aggregated]);
+            return applyAggregateReducer(reducer, values);
         });
-        return new TimeSeries({
+        if (alignment === 'trailing') {
+            for (let groupStart = 0; groupStart < this.events.length;) {
+                const anchor = beginTimes[groupStart];
+                let groupEnd = groupStart + 1;
+                while (groupEnd < this.events.length &&
+                    beginTimes[groupEnd] === anchor) {
+                    groupEnd += 1;
+                }
+                while (windowEnd < this.events.length &&
+                    beginTimes[windowEnd] <= anchor) {
+                    addEvent(windowEnd);
+                    windowEnd += 1;
+                }
+                const lowerBound = anchor - windowMs;
+                while (windowStart < windowEnd &&
+                    beginTimes[windowStart] <= lowerBound) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const aggregated = snapshotWindow();
+                for (let index = groupStart; index < groupEnd; index++) {
+                    resultRows[index] = Object.freeze([
+                        this.events[index].key(),
+                        ...aggregated,
+                    ]);
+                }
+                groupStart = groupEnd;
+            }
+        }
+        else if (alignment === 'leading') {
+            for (let groupStart = 0; groupStart < this.events.length;) {
+                const anchor = beginTimes[groupStart];
+                let groupEnd = groupStart + 1;
+                while (groupEnd < this.events.length &&
+                    beginTimes[groupEnd] === anchor) {
+                    groupEnd += 1;
+                }
+                const lowerBound = anchor;
+                while (windowStart < windowEnd &&
+                    beginTimes[windowStart] < lowerBound) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const upperBound = anchor + windowMs;
+                while (windowEnd < this.events.length &&
+                    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,
+                    ]);
+                }
+                groupStart = groupEnd;
+            }
+        }
+        else {
+            const halfWindow = windowMs / 2;
+            for (let groupStart = 0; groupStart < this.events.length;) {
+                const anchor = beginTimes[groupStart];
+                let groupEnd = groupStart + 1;
+                while (groupEnd < this.events.length &&
+                    beginTimes[groupEnd] === anchor) {
+                    groupEnd += 1;
+                }
+                const lowerBound = anchor - halfWindow;
+                while (windowStart < windowEnd &&
+                    beginTimes[windowStart] < lowerBound) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const upperBound = anchor + halfWindow;
+                while (windowEnd < this.events.length &&
+                    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,
+                    ]);
+                }
+                groupStart = groupEnd;
+            }
+        }
+        return new _a({
             name: this.name,
             schema: resultSchema,
             rows: resultRows,
@@ -873,7 +1542,7 @@ export class TimeSeries {
                         .map((nextColumn) => nextEvent.data()[nextColumn.name]),
                 ]);
             });
-            return new TimeSeries({
+            return new _a({
                 name: this.name,
                 schema: resultSchema,
                 rows: resultRows,
@@ -890,8 +1559,17 @@ export class TimeSeries {
                 span > 1) {
                 throw new TypeError('loess smoothing requires span to be a finite number in the range (0, 1]');
             }
+            const loessAnchors = [];
+            const loessValues = [];
+            for (let index = 0; index < anchors.length; index++) {
+                const value = sourceValues[index];
+                if (typeof value === 'number') {
+                    loessAnchors.push(anchors[index]);
+                    loessValues.push(value);
+                }
+            }
             const resultRows = this.events.map((event, index) => {
-                const smoothed = loessAt(anchors[index], anchors, sourceValues, span);
+                const smoothed = loessAt(anchors[index], loessAnchors, loessValues, span);
                 const nextEvent = output === undefined
                     ? event.set(column, smoothed)
                     : event.merge({ [output]: smoothed });
@@ -902,7 +1580,7 @@ export class TimeSeries {
                         .map((nextColumn) => nextEvent.data()[nextColumn.name]),
                 ]);
             });
-            return new TimeSeries({
+            return new _a({
                 name: this.name,
                 schema: resultSchema,
                 rows: resultRows,
@@ -914,24 +1592,78 @@ export class TimeSeries {
         const window = options.window;
         const windowMs = parseDurationInput(window);
         const alignment = options.alignment ?? 'trailing';
-        const anchorInWindow = (candidate, anchor) => {
-            if (alignment === 'trailing') {
-                return candidate > anchor - windowMs && candidate <= anchor;
+        const resultValues = new Array(this.events.length);
+        let windowStart = 0;
+        let windowEnd = 0;
+        let numericSum = 0;
+        let numericCount = 0;
+        const addEvent = (index) => {
+            const value = sourceValues[index];
+            if (typeof value === 'number') {
+                numericSum += value;
+                numericCount += 1;
             }
-            if (alignment === 'leading') {
-                return candidate >= anchor && candidate < anchor + windowMs;
+        };
+        const removeEvent = (index) => {
+            const value = sourceValues[index];
+            if (typeof value === 'number') {
+                numericSum -= value;
+                numericCount -= 1;
             }
-            const halfWindow = windowMs / 2;
-            return (candidate >= anchor - halfWindow && candidate < anchor + halfWindow);
         };
+        const snapshot = () => numericCount === 0 ? undefined : numericSum / numericCount;
+        for (let groupStart = 0; groupStart < this.events.length;) {
+            const anchor = anchors[groupStart];
+            let groupEnd = groupStart + 1;
+            while (groupEnd < this.events.length && anchors[groupEnd] === anchor) {
+                groupEnd += 1;
+            }
+            if (alignment === 'trailing') {
+                while (windowEnd < this.events.length &&
+                    anchors[windowEnd] <= anchor) {
+                    addEvent(windowEnd);
+                    windowEnd += 1;
+                }
+                const lowerBound = anchor - windowMs;
+                while (windowStart < windowEnd && anchors[windowStart] <= lowerBound) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+            }
+            else if (alignment === 'leading') {
+                while (windowStart < windowEnd && anchors[windowStart] < anchor) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const upperBound = anchor + windowMs;
+                while (windowEnd < this.events.length &&
+                    anchors[windowEnd] < upperBound) {
+                    addEvent(windowEnd);
+                    windowEnd += 1;
+                }
+            }
+            else {
+                const halfWindow = windowMs / 2;
+                while (windowStart < windowEnd &&
+                    anchors[windowStart] < anchor - halfWindow) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const upperBound = anchor + halfWindow;
+                while (windowEnd < this.events.length &&
+                    anchors[windowEnd] < upperBound) {
+                    addEvent(windowEnd);
+                    windowEnd += 1;
+                }
+            }
+            const smoothed = snapshot();
+            for (let index = groupStart; index < groupEnd; index++) {
+                resultValues[index] = smoothed;
+            }
+            groupStart = groupEnd;
+        }
         const resultRows = this.events.map((event, index) => {
-            const anchor = anchors[index];
-            const values = sourceValues
-                .filter((_, candidateIndex) => anchorInWindow(anchors[candidateIndex], anchor))
-                .flatMap((value) => (value === undefined ? [] : [value]));
-            const smoothed = values.length === 0
-                ? undefined
-                : values.reduce((sum, value) => sum + value, 0) / values.length;
+            const smoothed = resultValues[index];
             const nextEvent = output === undefined
                 ? event.set(column, smoothed)
                 : event.merge({ [output]: smoothed });
@@ -942,7 +1674,7 @@ export class TimeSeries {
                     .map((nextColumn) => nextEvent.data()[nextColumn.name]),
             ]);
         });
-        return new TimeSeries({
+        return new _a({
             name: this.name,
             schema: resultSchema,
             rows: resultRows,
@@ -950,19 +1682,11 @@ export class TimeSeries {
     }
     /** Example: `series.slice(0, 10)`. Returns a positional half-open slice of the series. */
     slice(beginIndex, endIndex) {
-        return new TimeSeries({
-            name: this.name,
-            schema: this.schema,
-            rows: toRows(this.schema, this.events.slice(beginIndex, endIndex)),
-        });
+        return _a.#fromTrustedEvents(this.name, this.schema, this.events.slice(beginIndex, endIndex));
     }
     /** Example: `series.filter(event => event.get("active"))`. Returns a new series containing only events that match the predicate. */
     filter(predicate) {
-        return new TimeSeries({
-            name: this.name,
-            schema: this.schema,
-            rows: toRows(this.schema, this.events.filter((event, index) => predicate(event, index))),
-        });
+        return _a.#fromTrustedEvents(this.name, this.schema, this.events.filter((event, index) => predicate(event, index)));
     }
     /** Example: `series.find(event => event.get("value") > 0)`. Returns the first event that matches the predicate, if any. */
     find(predicate) {
@@ -979,7 +1703,9 @@ export class TimeSeries {
     /** Example: `series.includesKey(new Time(Date.now()))`. Returns `true` when the series contains an event with an exactly matching key. */
     includesKey(key) {
         const normalizedKey = toKey(key);
-        return this.events.some((event) => event.key().equals(normalizedKey));
+        const index = this.bisect(normalizedKey);
+        return (index < this.events.length &&
+            this.events[index].key().equals(normalizedKey));
     }
     /** Example: `series.bisect(new Time(Date.now()))`. Returns the insertion index for the supplied key in the ordered event sequence. */
     bisect(key) {
@@ -1081,11 +1807,7 @@ export class TimeSeries {
         const trimmedEvents = this.events
             .map((event) => event.trim(range))
             .filter((event) => event !== undefined);
-        return new TimeSeries({
-            name: this.name,
-            schema: this.schema,
-            rows: toRows(this.schema, trimmedEvents),
-        });
+        return _a.#fromTrustedEvents(this.name, this.schema, trimmedEvents);
     }
     /** Example: `series.before(Date.now())`. Returns the events ending strictly before the supplied temporal boundary. */
     before(boundary) {
@@ -1117,11 +1839,7 @@ export class TimeSeries {
             const selectedEvent = event.select(...keys);
             return selectedEvent;
         });
-        return new TimeSeries({
-            name: this.name,
-            schema: resultSchema,
-            rows: toRows(resultSchema, resultEvents),
-        });
+        return _a.#fromTrustedEvents(this.name, resultSchema, resultEvents);
     }
     /** Example: `series.rename({ cpu: "usage" })`. Returns a new series with payload field names renamed according to the supplied mapping. */
     rename(mapping) {
@@ -1139,11 +1857,7 @@ export class TimeSeries {
             const renamedEvent = event.rename(mapping);
             return renamedEvent;
         });
-        return new TimeSeries({
-            name: this.name,
-            schema: resultSchema,
-            rows: toRows(resultSchema, resultEvents),
-        });
+        return _a.#fromTrustedEvents(this.name, resultSchema, resultEvents);
     }
     collapse(keys, output, reducer, options) {
         const nextEvents = this.events.map((event) => {
@@ -1171,47 +1885,138 @@ export class TimeSeries {
                         : 'string',
             },
         ]);
-        return new TimeSeries({
-            name: this.name,
-            schema: resultSchema,
-            rows: toRows(resultSchema, nextEvents),
-        });
+        return _a.#fromTrustedEvents(this.name, resultSchema, nextEvents);
     }
     /** Example: `series.length`. Returns the number of events in the series. */
     get length() {
         return this.events.length;
     }
-    #alignHoldAt(t) {
-        const event = this.atOrBefore(new Time(t));
-        return (event?.data() ?? {});
+}
+_a = TimeSeries;
+function aggregateInternal(series, sequence, mapping, options = {}) {
+    const range = options.range ?? series.timeRange();
+    const aggregateColumns = normalizeAggregateColumns(series.schema, mapping);
+    const resultSchema = Object.freeze([
+        { name: 'interval', kind: 'interval' },
+        ...aggregateColumns.map((column) => ({
+            name: column.output,
+            kind: column.kind,
+            required: false,
+        })),
+    ]);
+    if (!range) {
+        return new TimeSeries({
+            name: series.name,
+            schema: resultSchema,
+            rows: [],
+        });
     }
-    #alignLinearAt(t, valueColumns) {
-        const exact = this.find((event) => event.begin() === t);
-        if (exact) {
-            return exact.data();
-        }
-        const previous = this.atOrBefore(new Time(t));
-        const next = this.atOrAfter(new Time(t));
-        if (!previous || !next || previous.begin() === next.begin()) {
-            return (previous?.data() ?? {});
-        }
-        const ratio = (t - previous.begin()) / (next.begin() - previous.begin());
-        const result = {};
-        const previousData = previous.data();
-        const nextData = next.data();
-        for (const column of valueColumns) {
-            const previousValue = previousData[column.name];
-            const nextValue = nextData[column.name];
-            if (column.kind === 'number' &&
-                typeof previousValue === 'number' &&
-                typeof nextValue === 'number') {
-                result[column.name] =
-                    previousValue + (nextValue - previousValue) * ratio;
-                continue;
+    const buckets = toBoundedSequence(sequence, range, 'begin').intervals();
+    const columns = aggregateColumns;
+    if (isTimeKeyed(series)) {
+        const builtInOnly = columns.every((column) => isBuiltInAggregateReducer(column.reducer));
+        let eventIndex = 0;
+        const resultRows = buckets.map((bucket) => {
+            const states = builtInOnly
+                ? columns.map((column) => createAggregateBucketState(column.reducer))
+                : undefined;
+            while (eventIndex < series.events.length &&
+                series.events[eventIndex].begin() < bucket.begin()) {
+                eventIndex += 1;
+            }
+            const bucketStart = eventIndex;
+            let scanIndex = bucketStart;
+            while (scanIndex < series.events.length &&
+                series.events[scanIndex].begin() < bucket.end()) {
+                if (states) {
+                    const data = series.events[scanIndex].data();
+                    for (let index = 0; index < columns.length; index += 1) {
+                        const column = columns[index];
+                        states[index].add(data[column.source]);
+                    }
+                }
+                scanIndex += 1;
+            }
+            eventIndex = scanIndex;
+            if (states) {
+                return Object.freeze([
+                    bucket,
+                    ...states.map((state) => state.snapshot()),
+                ]);
             }
-            result[column.name] = previousValue;
+            const contributors = series.events.slice(bucketStart, scanIndex);
+            const aggregated = columns.map((column) => {
+                const values = contributors.map((event) => {
+                    const data = event.data();
+                    return data[column.source];
+                });
+                return applyAggregateReducer(column.reducer, values);
+            });
+            return Object.freeze([bucket, ...aggregated]);
+        });
+        return new TimeSeries({
+            name: series.name,
+            schema: resultSchema,
+            rows: resultRows,
+        });
+    }
+    const resultRows = buckets.map((bucket) => {
+        const contributors = series.events.filter((event) => bucketOverlapsHalfOpen(bucket, event.key()));
+        const aggregated = columns.map((column) => {
+            const values = contributors.map((event) => {
+                const data = event.data();
+                return data[column.source];
+            });
+            return applyAggregateReducer(column.reducer, values);
+        });
+        return Object.freeze([bucket, ...aggregated]);
+    });
+    return new TimeSeries({
+        name: series.name,
+        schema: resultSchema,
+        rows: resultRows,
+    });
+}
+function alignHoldAt(series, t) {
+    const event = series.atOrBefore(new Time(t));
+    return (event?.data() ?? {});
+}
+function alignLinearAt(series, t, valueColumns, cursor) {
+    const events = series.events;
+    const hasCursor = cursor !== undefined;
+    let index = hasCursor ? cursor.index : series.bisect(t);
+    if (hasCursor) {
+        while (index < events.length && events[index].begin() < t) {
+            index += 1;
         }
-        return result;
+        cursor.index = index;
+    }
+    if (index < events.length && events[index].begin() === t) {
+        return events[index].data();
+    }
+    if (index === 0) {
+        return {};
+    }
+    const previous = events[index - 1];
+    const next = events[index];
+    if (!next || previous.begin() === next.begin()) {
+        return previous.data();
+    }
+    const ratio = (t - previous.begin()) / (next.begin() - previous.begin());
+    const result = {};
+    const previousData = previous.data();
+    const nextData = next.data();
+    for (const column of valueColumns) {
+        const previousValue = previousData[column.name];
+        const nextValue = nextData[column.name];
+        if (column.kind === 'number' &&
+            typeof previousValue === 'number' &&
+            typeof nextValue === 'number') {
+            result[column.name] = previousValue + (nextValue - previousValue) * ratio;
+            continue;
+        }
+        result[column.name] = previousValue;
     }
+    return result;
 }
 //# sourceMappingURL=TimeSeries.js.map