pond-ts 0.65.0 → 0.67.0

package/dist/live/live-series.js

@@ -17,6 +17,7 @@ import { ChunkedColumnarLiveStorage, materializeEventsFromStore, materializeEven
 import { validateAndNormalizeColumnar } from '../batch/validate.js';
 import { ColumnarStore } from '../columnar/store.js';
 import { parseDuration } from '../core/duration.js';
+import { ListenerSet } from './listener-set.js';
 // ── Single-row validation ───────────────────────────────────────
 const FIRST_COL_KINDS = new Set([
     'time',
@@ -94,6 +95,11 @@ function assertCellKind(kind, value, name) {
  * channels; snapshot to the batch layer at any time with `toTimeSeries()`.
  * Example: `new LiveSeries({ name, schema, retention: { maxEvents: 10_000 } })`.
  */
+/** [PND-LIVFIX] Surface the first listener error once the push has completed. */
+function rethrowFirst(errors) {
+    if (errors.length > 0)
+        throw errors[0];
+}
 export class LiveSeries {
     /** @internal */
     [EMITS_EVICT] = true;
@@ -113,6 +119,18 @@ export class LiveSeries {
     #onEvent;
     #onBatch;
     #onEvict;
+    /**
+     * [PND-LIVFIX] Re-entrancy guard. `> 0` while a push is fanning out to
+     * listeners. A push that arrives from inside a listener (`#dispatchDepth
+     * > 0`) is queued on `#pendingPushes` and run after the outer push has
+     * fully completed (retention, `'batch'`, `'evict'`), so emission order
+     * stays monotonic and the nested rows are order-checked against the
+     * buffer at their turn rather than mid-fan-out.
+     */
+    #dispatchDepth = 0;
+    #pendingPushes = [];
+    /** `true` while the outermost guard is draining `#pendingPushes`. */
+    #draining = false;
     /**
      * Column-native delta subscribers (chunked backing only). Fires with
      * the appended `ColumnarStore` per `pushMany` — the internal hook the
@@ -181,10 +199,10 @@ export class LiveSeries {
             this.#perRow = array;
             this.#storage = array;
         }
-        this.#onEvent = new Set();
-        this.#onBatch = new Set();
+        this.#onEvent = new ListenerSet();
+        this.#onBatch = new ListenerSet();
         this.#onChunk = new Set();
-        this.#onEvict = new Set();
+        this.#onEvict = new ListenerSet();
     }
     get length() {
         return this.#storage.length;
@@ -305,64 +323,145 @@ export class LiveSeries {
      * **Commit granularity differs by backing.** On the `Event[]`
      * backing each row is appended then its `'event'` fires, so a
      * handler observes `length` grow row-by-row (`1, 2, …`) within one
-     * `pushMany`, and a handler that throws mid-batch leaves only the
-     * rows up to the throw committed. On the chunked columnar backing
-     * (top-level `strict` time-keyed series) the whole batch is appended
-     * as one chunk *before* any `'event'` fires — so a handler sees the
-     * full post-batch `length` for every event of the batch, and a
-     * handler that throws mid-fan-out leaves the *entire* batch committed
-     * (the chunk is already appended). Both leave `length` and `ingested`
-     * mutually consistent after a throw; they differ only in how much of
-     * the batch is committed. This is intrinsic to all-or-nothing
-     * columnar append — per-row commit would reintroduce the per-row
-     * `Event` cost the chunked backing exists to avoid. The cross-backing
-     * contract callers can rely on: every successfully-ingested row fires
-     * exactly one `'event'`, in order, before `'batch'`/`'evict'`.
+     * `pushMany`. On the chunked columnar backing (top-level `strict`
+     * time-keyed series) the whole batch is appended as one chunk
+     * *before* any `'event'` fires, so a handler sees the full post-batch
+     * `length` for every event of the batch. This is intrinsic to
+     * all-or-nothing columnar append — per-row commit would reintroduce
+     * the per-row `Event` cost the chunked backing exists to avoid. The
+     * cross-backing contract callers can rely on: every
+     * successfully-ingested row fires exactly one `'event'`, in order,
+     * before `'batch'`/`'evict'`.
+     *
+     * **Listener errors are isolated** ([PND-LIVFIX]). A listener that
+     * throws does not stop the push: every row is still committed, the
+     * remaining listeners still run, retention still runs, and `'batch'` /
+     * `'evict'` still fire. The first error is rethrown to the caller once
+     * the push has completed, so `length`, `ingested` and every subscriber
+     * (a derived `filter()` view included) agree afterwards. A push made
+     * from inside a listener is queued and runs after the current push,
+     * in arrival order, so emission stays monotonic.
      */
     pushMany(rows) {
         if (rows.length === 0)
             return;
-        // Chunked (column-native) path: validate the whole batch into
-        // columns, no per-row Event. Only top-level strict time-keyed
-        // series select this backing.
-        if (this.#chunked) {
-            this.#pushManyColumnar(rows);
+        if (this.#dispatchDepth > 0) {
+            // Re-entrant push from inside a listener: defer until the outer
+            // push has completed. See `#dispatchDepth`.
+            this.#pendingPushes.push(() => this.pushMany(rows));
             return;
         }
-        // Per-row (Event[]) path.
-        const added = [];
-        for (const row of rows) {
-            const event = this.#validateRow(row);
-            if (this.#insertPerRow(event)) {
-                // Increment the counter immediately after a successful
-                // insert and BEFORE listener fan-out. If a listener throws
-                // partway through the loop, the event is committed in the
-                // buffer and reflected in `length` — `ingested` must
-                // reflect that too, so callers can recover from listener
-                // exceptions without observability counters lying.
-                this.#statsIngested++;
-                added.push(event);
-                for (const fn of this.#onEvent)
-                    fn(event);
+        this.#guarded(() => {
+            // Chunked (column-native) path: validate the whole batch into
+            // columns, no per-row Event. Only top-level strict time-keyed
+            // series select this backing.
+            if (this.#chunked) {
+                this.#pushManyColumnar(rows);
+                return;
             }
-            else {
-                // Drop-mode silent rejection: out-of-order event under
-                // `ordering: 'drop'`. Strict / reorder modes throw; those
-                // never reach this counter.
-                this.#statsRejected++;
+            // Per-row (Event[]) path.
+            const added = [];
+            const errors = [];
+            for (const row of rows) {
+                const event = this.#validateRow(row);
+                if (this.#insertPerRow(event)) {
+                    // Increment the counter immediately after a successful
+                    // insert and BEFORE listener fan-out. If a listener throws
+                    // partway through the loop, the event is committed in the
+                    // buffer and reflected in `length` — `ingested` must
+                    // reflect that too, so callers can recover from listener
+                    // exceptions without observability counters lying.
+                    this.#statsIngested++;
+                    added.push(event);
+                    this.#dispatch(this.#onEvent, event, errors);
+                }
+                else {
+                    // Drop-mode silent rejection: out-of-order event under
+                    // `ordering: 'drop'`. Strict / reorder modes throw; those
+                    // never reach this counter.
+                    this.#statsRejected++;
+                }
+            }
+            if (added.length === 0)
+                return;
+            // `#applyRetention` updates `#statsEvicted` internally and returns
+            // the materialized evicted events only when an `'evict'` listener
+            // will consume them.
+            const evicted = this.#applyRetention();
+            this.#dispatch(this.#onBatch, added, errors);
+            if (evicted.length > 0) {
+                this.#dispatch(this.#onEvict, evicted, errors);
             }
+            rethrowFirst(errors);
+        });
+    }
+    /**
+     * [PND-LIVFIX] Run one push under the re-entrancy guard: bump
+     * `#dispatchDepth` for its duration, then — from the OUTERMOST guard
+     * only — drain the pushes that listeners queued, strictly FIFO. A
+     * queued push runs as its own guarded push, so its listeners can queue
+     * more; those land at the tail of the same queue and run after every
+     * push queued before them. (Draining from every level, as the first
+     * cut did, let a grandchild jump a queued sibling — a review repro:
+     * listener on 1 queues 10 then 20, listener on 10 queues 30, and 30
+     * ran before 20, which strict ordering then rejected.) An error from
+     * the outer push is rethrown AFTER the queue has drained — queued rows
+     * were accepted by `push()` and must not be lost to a listener's
+     * exception elsewhere.
+     */
+    #guarded(run) {
+        let failure;
+        this.#dispatchDepth += 1;
+        try {
+            run();
         }
-        if (added.length === 0)
+        catch (error) {
+            failure = { error };
+        }
+        finally {
+            this.#dispatchDepth -= 1;
+        }
+        if (this.#dispatchDepth === 0 && !this.#draining) {
+            this.#draining = true;
+            try {
+                while (this.#pendingPushes.length > 0) {
+                    const push = this.#pendingPushes.shift();
+                    try {
+                        push();
+                    }
+                    catch (error) {
+                        failure ??= { error };
+                    }
+                }
+            }
+            finally {
+                this.#draining = false;
+            }
+        }
+        if (failure)
+            throw failure.error;
+    }
+    /**
+     * [PND-LIVFIX] Fan out to a listener set with error isolation. Iterates
+     * a snapshot, so a listener that adds or removes listeners during
+     * dispatch neither disturbs the others nor fires for the event it was
+     * added during. A throwing listener is recorded and the remaining
+     * listeners still run; the caller rethrows the first error once the
+     * whole push (retention, `'batch'`, `'evict'`) has completed. Before
+     * this, a throw skipped retention entirely and left every later
+     * subscriber — a derived `filter()` view included — permanently out of
+     * sync with the buffer (audit 2026-06 §4.1).
+     */
+    #dispatch(set, arg, errors) {
+        if (set.size === 0)
             return;
-        // `#applyRetention` updates `#statsEvicted` internally and returns
-        // the materialized evicted events only when an `'evict'` listener
-        // will consume them.
-        const evicted = this.#applyRetention();
-        for (const fn of this.#onBatch)
-            fn(added);
-        if (evicted.length > 0) {
-            for (const fn of this.#onEvict)
-                fn(evicted);
+        for (const fn of set.snapshot()) {
+            try {
+                fn(arg);
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
     }
     /**
@@ -424,21 +523,19 @@ export class LiveSeries {
         const added = this.#onEvent.size > 0 || this.#onBatch.size > 0
             ? materializeEventsFromStoreAt(source, indices, this.schema)
             : null;
-        if (added) {
-            for (const ev of added) {
-                for (const fn of this.#onEvent)
-                    fn(ev);
+        this.#guarded(() => {
+            const errors = [];
+            if (added) {
+                for (const ev of added)
+                    this.#dispatch(this.#onEvent, ev, errors);
             }
-        }
-        const evicted = this.#applyRetention();
-        if (added) {
-            for (const fn of this.#onBatch)
-                fn(added);
-        }
-        if (evicted.length > 0) {
-            for (const fn of this.#onEvict)
-                fn(evicted);
-        }
+            const evicted = this.#applyRetention();
+            if (added)
+                this.#dispatch(this.#onBatch, added, errors);
+            if (evicted.length > 0)
+                this.#dispatch(this.#onEvict, evicted, errors);
+            rethrowFirst(errors);
+        });
     }
     /**
      * Append one already-built `ColumnarStore` chunk, then run the
@@ -480,24 +577,20 @@ export class LiveSeries {
             ? materializeEventsFromStore(store, this.schema)
             : null;
         // `'event'` fan-out fires before retention (the ordering contract).
+        const errors = [];
         if (added) {
-            for (const ev of added) {
-                for (const fn of this.#onEvent)
-                    fn(ev);
-            }
+            for (const ev of added)
+                this.#dispatch(this.#onEvent, ev, errors);
         }
         // Retention always runs. It updates `#statsEvicted` internally and
         // returns the materialized evicted events only when an `'evict'`
         // listener exists (else `dropPrefix`, returning `[]`).
         const evicted = this.#applyRetention();
-        if (added) {
-            for (const fn of this.#onBatch)
-                fn(added);
-        }
-        if (evicted.length > 0) {
-            for (const fn of this.#onEvict)
-                fn(evicted);
-        }
+        if (added)
+            this.#dispatch(this.#onBatch, added, errors);
+        if (evicted.length > 0)
+            this.#dispatch(this.#onEvict, evicted, errors);
+        rethrowFirst(errors);
     }
     /**
      * @internal — fast-path ingest for events that have already been
@@ -536,38 +629,105 @@ export class LiveSeries {
         // chunked series. Reconstruct rows and reuse `#pushManyColumnar`
         // (re-validates — acceptable on this rare path; the strict
         // order-check still applies, matching the per-row trusted path).
-        if (this.#chunked) {
-            const rows = new Array(events.length);
-            for (let i = 0; i < events.length; i += 1) {
-                rows[i] = this.#eventToRow(events[i]);
-            }
-            this.#pushManyColumnar(rows);
+        if (this.#dispatchDepth > 0) {
+            this.#pendingPushes.push(() => this._pushTrustedEvents(events));
             return;
         }
-        const added = [];
-        for (const event of events) {
-            if (this.#insertPerRow(event)) {
-                // See pushMany — counter advances before listener fan-out
-                // so partial-failure on any listener still leaves
-                // `ingested` consistent with `length`.
-                this.#statsIngested++;
-                added.push(event);
-                for (const fn of this.#onEvent)
-                    fn(event);
+        this.#guarded(() => {
+            if (this.#chunked) {
+                const rows = new Array(events.length);
+                for (let i = 0; i < events.length; i += 1) {
+                    rows[i] = this.#eventToRow(events[i]);
+                }
+                this.#pushManyColumnar(rows);
+                return;
             }
-            else {
-                this.#statsRejected++;
+            const added = [];
+            const errors = [];
+            for (const event of events) {
+                if (this.#insertPerRow(event)) {
+                    // See pushMany — counter advances before listener fan-out
+                    // so partial-failure on any listener still leaves
+                    // `ingested` consistent with `length`.
+                    this.#statsIngested++;
+                    added.push(event);
+                    this.#dispatch(this.#onEvent, event, errors);
+                }
+                else {
+                    this.#statsRejected++;
+                }
             }
+            if (added.length === 0)
+                return;
+            const evicted = this.#applyRetention();
+            this.#dispatch(this.#onBatch, added, errors);
+            if (evicted.length > 0)
+                this.#dispatch(this.#onEvict, evicted, errors);
+            rethrowFirst(errors);
+        });
+    }
+    /**
+     * @internal — number of row-materialising listeners (`'event'` +
+     * `'batch'`). Zero means a push on the chunked backing builds no
+     * `Event` objects at all. Exposed for the [PND-LIVFIX] chained-dispose
+     * pin, which asserts a disposed chain leaves nothing subscribed.
+     */
+    get _rowListenerCount() {
+        return this.#onEvent.size + this.#onBatch.size;
+    }
+    /**
+     * @internal — [PND-LIVFIX] the order this series evicts relative to
+     * arrival. `'sorted'` for `ordering: 'reorder'`, whose retention drops
+     * the sorted prefix (possibly a late, i.e. recent, arrival);
+     * `'arrival'` otherwise. `LiveReduce` selects its windowed reducer
+     * state on this.
+     */
+    get _evictionOrder() {
+        return this.#ordering === 'reorder' ? 'sorted' : 'arrival';
+    }
+    /**
+     * @internal — [PND-LIVFIX] age-based retention against an EXTERNAL
+     * clock. `#applyRetention` measures `maxAge` from this buffer's own
+     * newest event, which is right for a standalone series but leaves a
+     * partition sub-series that has gone quiet holding its events forever:
+     * nothing ever pushes into it, so its clock never advances (audit
+     * 2026-06 §4.3 — a 10 s `maxAge` partition still held its event 9,999 s
+     * later). `LivePartitionedSeries` calls this on every partition as the
+     * source's watermark advances, so a quiet partition ages out against
+     * the time the source has actually reached. Emits `'evict'` exactly as
+     * push-driven retention does, so `LiveReduce` and views stay in sync.
+     * No-op without `maxAge` or on an empty buffer. Called while this
+     * series is mid-dispatch (a listener on it pushed re-entrantly), it is
+     * queued behind that push like any other re-entrant operation, so it
+     * cannot be starved.
+     */
+    _sweepAge(latestMs) {
+        if (this.#maxAgeMs === Infinity)
+            return;
+        if (this.#dispatchDepth > 0) {
+            this.#pendingPushes.push(() => this._sweepAge(latestMs));
+            return;
         }
-        if (added.length === 0)
+        const len = this.#storage.length;
+        if (len === 0)
+            return;
+        const cutoff = latestMs - this.#maxAgeMs;
+        let i = 0;
+        while (i < len && this.#storage.beginAt(i) < cutoff)
+            i += 1;
+        if (i === 0)
+            return;
+        this.#statsEvicted += i;
+        if (this.#onEvict.size === 0) {
+            this.#storage.dropPrefix(i);
             return;
-        const evicted = this.#applyRetention();
-        for (const fn of this.#onBatch)
-            fn(added);
-        if (evicted.length > 0) {
-            for (const fn of this.#onEvict)
-                fn(evicted);
         }
+        const evicted = this.#storage.evictPrefix(i);
+        this.#guarded(() => {
+            const errors = [];
+            this.#dispatch(this.#onEvict, evicted, errors);
+            rethrowFirst(errors);
+        });
     }
     /**
      * @internal — whether this series uses the chunked columnar backing
@@ -641,8 +801,9 @@ export class LiveSeries {
             // `evicted` counter on `stats()` for consistency. JSDoc on
             // `stats().evicted` documents both paths.
             this.#statsEvicted += evicted.length;
-            for (const fn of this.#onEvict)
-                fn(evicted);
+            const errors = [];
+            this.#dispatch(this.#onEvict, evicted, errors);
+            rethrowFirst(errors);
         }
     }
     toTimeSeries(name) {

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

@@ -37,15 +37,6 @@ type ViewOptions<S extends SeriesSchema> = {
  * Reuses `KeyColumnForSchema`, gated on the time variant.
  */
 type TimeKeyOnly<S extends SeriesSchema> = KeyColumnForSchema<S> extends TimeKeyColumn ? KeyColumnForSchema<S> : 'LiveView.keyColumn() supports time-keyed views only — use toTimeSeries() for other key kinds';
-/**
- * A derived, subscribable live projection — the result of chainable live
- * operators such as `filter`, `map`, `select`, `fill`, `diff`, and `rate`.
- * A view subscribes to its source `LiveSource`, runs each event through
- * its process function as it arrives (emitting a transformed event or
- * skipping it), and mirrors source eviction — you obtain one from an
- * operator rather than constructing it directly. Example:
- * `live.filter((e) => (e.get('value') as number) > 5)`.
- */
 export declare class LiveView<S extends SeriesSchema> implements LiveSource<S> {
     #private;
     readonly name: string;
@@ -188,6 +179,24 @@ export declare class LiveView<S extends SeriesSchema> implements LiveSource<S> {
     };
     on(type: 'event', fn: EventListener<S>): () => void;
     on(type: 'evict', fn: EvictListener<S>): () => void;
+    /**
+     * Detach this view from its source and drop its own listeners. After
+     * `dispose()` the view stops receiving events; its buffer is left as it
+     * was (a final `toTimeSeries()` snapshot still works) and further
+     * `dispose()` calls are no-ops.
+     *
+     * **Chain-aware.** `live.filter(p).map(f)` creates an intermediate view
+     * that nothing but the outer view references, and before [PND-LIVFIX]
+     * disposing the outer view left that intermediate subscribed to the
+     * source forever, processing every push into an unbounded buffer with
+     * no handle to stop it (audit 2026-06 §4.4). Now, when this view's source
+     * is itself a `LiveView` and this was its last subscriber, the source is
+     * disposed too, and so on up the chain. A source view that still has
+     * another subscriber is left alone. If you hold a reference to an
+     * intermediate and want to keep reading it after disposing a derived
+     * view, keep a listener on it — a view with no subscribers is treated
+     * as unreachable.
+     */
     dispose(): void;
 }
 /**

package/dist/live/live-view.js

@@ -1,3 +1,4 @@
+import { ListenerSet } from './listener-set.js';
 import { Event } from '../core/event.js';
 import { ValidationError } from '../core/errors.js';
 import { LiveAggregation } from './live-aggregation.js';
@@ -19,6 +20,36 @@ import { parseDuration } from '../core/duration.js';
  * operator rather than constructing it directly. Example:
  * `live.filter((e) => (e.get('value') as number) > 5)`.
  */
+/**
+ * [PND-LIVFIX] Fan out to a listener set with error isolation: iterate a
+ * snapshot (a listener may add or remove listeners while running) and
+ * let every listener run before surfacing the first error. Mirrors
+ * `LiveSeries`'s dispatch so a throwing subscriber on a view cannot
+ * starve the view's other subscribers.
+ */
+function dispatchIsolated(set, arg) {
+    if (set.size === 0)
+        return;
+    let first;
+    for (const fn of set.snapshot()) {
+        try {
+            fn(arg);
+        }
+        catch (error) {
+            first ??= { error };
+        }
+    }
+    if (first)
+        throw first.error;
+}
+/** A readable key for error messages — `String(key)` on a key object is `[object Object]`. */
+function describeKey(event) {
+    const begin = new Date(event.begin()).toISOString();
+    const end = event.end?.();
+    return end !== undefined && end !== event.begin()
+        ? `[${begin}, ${new Date(end).toISOString()})`
+        : begin;
+}
 export class LiveView {
     /** @internal */
     [EMITS_EVICT] = true;
@@ -41,15 +72,19 @@ export class LiveView {
     #onEvent;
     #onEvict;
     #unsubscribe;
+    /** The source this view subscribes to — kept for chain-aware dispose. */
+    #source;
+    #disposed = false;
     constructor(source, process, options) {
         this.name = source.name;
         this.schema = options?.schema ?? source.schema;
+        this.#source = source;
         this.#events = [];
         this.#process = process;
         this.#evict = options?.evict;
         this.#windowMs = options?.windowMs;
-        this.#onEvent = new Set();
-        this.#onEvict = new Set();
+        this.#onEvent = new ListenerSet();
+        this.#onEvict = new ListenerSet();
         for (let i = 0; i < source.length; i++) {
             const result = this.#process(source.at(i));
             if (result !== undefined)
@@ -61,8 +96,7 @@ export class LiveView {
             if (result !== undefined) {
                 this.#appendChecked(result);
                 this.#applyEviction();
-                for (const fn of this.#onEvent)
-                    fn(result);
+                dispatchIsolated(this.#onEvent, result);
             }
         });
         // Mirror source eviction: when the source removes old events, remove
@@ -86,8 +120,7 @@ export class LiveView {
                 if (i > 0) {
                     const removed = this.#events.splice(0, i);
                     this.#version += 1;
-                    for (const fn of this.#onEvict)
-                        fn(removed);
+                    dispatchIsolated(this.#onEvict, removed);
                 }
             });
         }
@@ -430,8 +463,39 @@ export class LiveView {
             set.delete(fn);
         };
     }
+    /**
+     * Detach this view from its source and drop its own listeners. After
+     * `dispose()` the view stops receiving events; its buffer is left as it
+     * was (a final `toTimeSeries()` snapshot still works) and further
+     * `dispose()` calls are no-ops.
+     *
+     * **Chain-aware.** `live.filter(p).map(f)` creates an intermediate view
+     * that nothing but the outer view references, and before [PND-LIVFIX]
+     * disposing the outer view left that intermediate subscribed to the
+     * source forever, processing every push into an unbounded buffer with
+     * no handle to stop it (audit 2026-06 §4.4). Now, when this view's source
+     * is itself a `LiveView` and this was its last subscriber, the source is
+     * disposed too, and so on up the chain. A source view that still has
+     * another subscriber is left alone. If you hold a reference to an
+     * intermediate and want to keep reading it after disposing a derived
+     * view, keep a listener on it — a view with no subscribers is treated
+     * as unreachable.
+     */
     dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
         this.#unsubscribe();
+        this.#onEvent.clear();
+        this.#onEvict.clear();
+        const source = this.#source;
+        if (source instanceof LiveView && source._listenerCount === 0) {
+            source.dispose();
+        }
+    }
+    /** @internal — subscribers on this view (`'event'` + `'evict'`). */
+    get _listenerCount() {
+        return this.#onEvent.size + this.#onEvict.size;
     }
     #applyEviction() {
         if (!this.#evict)
@@ -462,8 +526,8 @@ export class LiveView {
     #appendChecked(event) {
         const last = this.#events[this.#events.length - 1];
         if (last && event.key().compare(last.key()) < 0) {
-            throw new ValidationError(`LiveView: processed event has key ${String(event.key())} ` +
-                `older than the previous tail ${String(last.key())}. ` +
+            throw new ValidationError(`LiveView: processed event has key ${describeKey(event)} ` +
+                `older than the previous tail ${describeKey(last)}. ` +
                 `Re-keying maps that produce non-monotonic output break the ` +
                 `view's sorted-buffer invariant. Use a transform that ` +
                 `preserves keys, or perform time-axis rewrites on a snapshot ` +

package/dist/reducers/index.d.ts

@@ -36,5 +36,14 @@ export declare function bucketStateFor(reducer: AggregateReducer): AggregateBuck
  * Custom-function reducers shine on low-rate streams where
  * convenience matters more than per-snapshot cost.
  */
-export declare function rollingStateFor(reducer: AggregateReducer): RollingReducerState;
+/**
+ * Which order a source removes events from its buffer, relative to the
+ * order it delivered them. `'arrival'` (append-only sources — the chunked
+ * backing, `strict` / `drop`): oldest-arrived first, so a forward-sliding
+ * window state is exact. `'sorted'` (`reorder` + retention): the sorted
+ * prefix, which may be a later arrival — the windowed states must accept
+ * removal of any index ([PND-LIVFIX]).
+ */
+export type EvictionOrder = 'arrival' | 'sorted';
+export declare function rollingStateFor(reducer: AggregateReducer, evictionOrder?: EvictionOrder): RollingReducerState;
 //# sourceMappingURL=index.d.ts.map