pond-ts 0.65.0 → 0.67.0

package/dist/reducers/index.js

@@ -1,3 +1,4 @@
+import { rollingIndexedEntries, rollingSortedExtreme } from './rolling.js';
 import { parsePercentile, percentileReducer } from './percentile.js';
 import { parseTopN, topReducer } from './top.js';
 import { count } from './count.js';
@@ -102,31 +103,24 @@ export function bucketStateFor(reducer) {
         },
     };
 }
-/**
- * Build a `RollingReducerState` for a reducer that may be either a
- * built-in name (string) or a custom function. Built-ins use their
- * dedicated incremental machinery (O(1) `add`/`remove`/`snapshot`).
- *
- * Custom functions use a generic adapter:
- * - `add(idx, v)` stores into a Map keyed by event index.
- * - `remove(idx, v)` deletes by index.
- * - `snapshot()` calls the function with the current window's values
- *   in arrival order — O(N) per snapshot.
- *
- * **Performance characteristic.** Per-event cost is O(1) for state
- * maintenance but `snapshot` is O(window size) — the function re-
- * runs over every value in the current window each time the
- * accumulator emits. Compare to built-in reducers which maintain a
- * running result incrementally and snapshot in O(1).
- *
- * For high-throughput live use, prefer built-ins or `'samples'`
- * (which lets you compute the custom logic once at the consumer,
- * after the rolling has already collapsed events to the value list).
- * Custom-function reducers shine on low-rate streams where
- * convenience matters more than per-snapshot cost.
- */
-export function rollingStateFor(reducer) {
+export function rollingStateFor(reducer, evictionOrder = 'arrival') {
     if (typeof reducer === 'string') {
+        if (evictionOrder === 'sorted') {
+            // [PND-LIVFIX] The four forward-sliding-window states assume
+            // oldest-arrived-first eviction; swap in the any-order structures
+            // for a source that evicts its sorted prefix. Every other built-in
+            // already removes by index or by value.
+            switch (reducer) {
+                case 'min':
+                    return skipNonFiniteRolling(rollingSortedExtreme('min'));
+                case 'max':
+                    return skipNonFiniteRolling(rollingSortedExtreme('max'));
+                case 'first':
+                    return skipNonFiniteRolling(rollingIndexedEntries('first'));
+                case 'last':
+                    return skipNonFiniteRolling(rollingIndexedEntries('last'));
+            }
+        }
         return skipNonFiniteRolling(resolveReducer(reducer).rollingState());
     }
     // Custom-function adapter: Map keyed by event index for O(1) remove.

package/dist/reducers/rolling.d.ts

@@ -6,6 +6,28 @@ type RollingWindowEntry<T> = {
 };
 export declare function rollingMonotoneDeque(compare: (a: number, b: number) => boolean): RollingReducerState;
 export declare function rollingOrderedEntries(pick: (entries: RollingWindowEntry<ColumnValue>[], head: number) => ColumnValue | undefined): RollingReducerState;
+/**
+ * [PND-LIVFIX] Ordered entries that tolerate removal of ANY index, not only
+ * the head. `rollingOrderedEntries` above is a forward-sliding window: it
+ * assumes evictions arrive oldest-added-first, which holds for append-only
+ * sources but not for a `reorder` source with retention, whose sorted-prefix
+ * eviction can drop a middle or the newest arrival — and then `first` /
+ * `last` kept reporting an evicted value. Entries live in a `Map` keyed by
+ * index (insertion order = arrival order) so any index removes in O(1);
+ * `first` is the map's first value and `last` is a tracked tail index,
+ * re-derived by an O(n) scan when the tail itself is evicted — on a
+ * reorder source that is the headline case (the newest arrival being the
+ * sorted prefix), so `last` is O(n) per such eviction and O(1) otherwise.
+ */
+export declare function rollingIndexedEntries(pick: 'first' | 'last'): RollingReducerState;
+/**
+ * [PND-LIVFIX] `min` / `max` over a sorted array — removal by value, so the
+ * extreme is exact whatever order evictions arrive in. O(n) per insert /
+ * remove (a `splice`), against the monotone deque's amortised O(1); it is
+ * selected only for sources whose eviction order is not arrival order
+ * (`reorder` + retention), where the deque is wrong rather than slow.
+ */
+export declare function rollingSortedExtreme(pick: 'min' | 'max'): RollingReducerState;
 export declare function rollingSortedArray(): {
     sorted: number[];
     add(index: number, value: ColumnValue | undefined): void;

package/dist/reducers/rolling.js

@@ -51,6 +51,71 @@ export function rollingOrderedEntries(pick) {
         },
     };
 }
+/**
+ * [PND-LIVFIX] Ordered entries that tolerate removal of ANY index, not only
+ * the head. `rollingOrderedEntries` above is a forward-sliding window: it
+ * assumes evictions arrive oldest-added-first, which holds for append-only
+ * sources but not for a `reorder` source with retention, whose sorted-prefix
+ * eviction can drop a middle or the newest arrival — and then `first` /
+ * `last` kept reporting an evicted value. Entries live in a `Map` keyed by
+ * index (insertion order = arrival order) so any index removes in O(1);
+ * `first` is the map's first value and `last` is a tracked tail index,
+ * re-derived by an O(n) scan when the tail itself is evicted — on a
+ * reorder source that is the headline case (the newest arrival being the
+ * sorted prefix), so `last` is O(n) per such eviction and O(1) otherwise.
+ */
+export function rollingIndexedEntries(pick) {
+    const items = new Map();
+    let tail;
+    return {
+        add(index, value) {
+            if (value === undefined)
+                return;
+            items.set(index, value);
+            if (tail === undefined || index > tail)
+                tail = index;
+        },
+        remove(index, value) {
+            if (value === undefined)
+                return;
+            if (!items.delete(index))
+                return;
+            if (index === tail) {
+                tail = undefined;
+                for (const k of items.keys())
+                    if (tail === undefined || k > tail)
+                        tail = k;
+            }
+        },
+        snapshot() {
+            if (items.size === 0)
+                return undefined;
+            if (pick === 'first')
+                return items.values().next().value;
+            return tail === undefined ? undefined : items.get(tail);
+        },
+    };
+}
+/**
+ * [PND-LIVFIX] `min` / `max` over a sorted array — removal by value, so the
+ * extreme is exact whatever order evictions arrive in. O(n) per insert /
+ * remove (a `splice`), against the monotone deque's amortised O(1); it is
+ * selected only for sources whose eviction order is not arrival order
+ * (`reorder` + retention), where the deque is wrong rather than slow.
+ */
+export function rollingSortedExtreme(pick) {
+    const state = rollingSortedArray();
+    return {
+        add: state.add,
+        remove: state.remove,
+        snapshot() {
+            const s = state.sorted;
+            if (s.length === 0)
+                return undefined;
+            return pick === 'min' ? s[0] : s[s.length - 1];
+        },
+    };
+}
 export function rollingSortedArray() {
     const sorted = [];
     function bisect(v) {

package/package.json

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