pond-ts 0.14.3 → 0.15.0

package/CHANGELOG.md

@@ -7,10 +7,177 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 file covers both packages. Pre-1.0: minor bumps may include new features and
 type-level changes; patch bumps are strictly additive.
 
-[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.14.3...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.15.0...HEAD
 
 ## [Unreleased]
 
+## [0.15.0] — 2026-05-05
+
+The "fused multi-window rolling" release. Shipping the primitive
+that closes the gRPC experiment's V6→V7 architectural cliff: a
+keyed-form overload on `live.rolling()` that maintains N windows
+in one ingest pass over a single shared deque, emits one merged
+event per trigger boundary, and (on the partitioned variant) eats
+the doubled `#routeEvent` / `#evictPartition` / `_pushTrustedEvents`
+hops V7 surfaced.
+
+Two independent signals motivated this: the gRPC profile-diff
+(PR #19 in `pond-grpc-experiment`) and the buffer-as-window
+persona's metric-agent call site
+(`series.rolling(RETENTION, mapping, ...)` as workaround). Both
+point at one primitive; both shipped together. RFC #20 in
+`pond-grpc-experiment` is the design record.
+
+### Added
+
+- **Keyed-form fused rolling on `LiveSeries.rolling`,
+  `LiveView.rolling`, and `LivePartitionedSeries.rolling`.** Pass
+  a record of `{ duration: mapping }` instead of `(window, mapping)`
+  to declare multiple windows; the rolling maintains them all in
+  one ingest pass:
+
+  ```ts
+  const fused = byHost.rolling(
+    {
+      '1m': {
+        cpu_avg: { from: 'cpu', using: 'avg' },
+        cpu_sd: { from: 'cpu', using: 'stdev' },
+      },
+      '200ms': { cpu_samples: { from: 'cpu', using: 'samples' } },
+    },
+    { trigger: Trigger.every('200ms') },
+  );
+  // fused emits one merged event per boundary with all four
+  // columns; one ingest pass per source event.
+  ```
+
+  - **Output: one merged stream.** All declared windows' columns
+    concatenated into one record per trigger fire — not N
+    accumulators or N streams. User code collapses to one event
+    handler (the V7 → V8 migration in the gRPC experiment drops
+    ~30 lines of `pendingByTs` / `partsFor` / `tryEmit` join
+    machinery).
+  - **Constraints.** Time-based windows only (object keys are
+    duration strings); single trigger across all windows by
+    design (per-window cadence falls back to two `rolling()`
+    calls, paying the V7 cost). On partitioned series, clock
+    trigger is required.
+  - **Per-window options.** Use the elaborated value form
+    (`{ mapping, minSamples }`) when one window needs different
+    options from the rest; bare-mapping value stays clean for
+    the common case.
+  - **Duplicate output column names** across windows are rejected
+    at construction with a clear error. Partition column auto-
+    injection is unified across all windows.
+  - **Single-window equivalence pin.**
+    `live.rolling('1m', mapping, opts)` and
+    `live.rolling({ '1m': mapping }, opts)` produce identical
+    output (locked down by tests).
+
+- **`LiveFusedRolling<S, Out>`** — non-partitioned class, exposed
+  on the public surface via `live.rolling({...}, opts)`.
+- **`LivePartitionedFusedRolling<S, K, Out>`** — synchronised-cross-
+  partition class, exposed via `byHost.rolling({...}, { trigger })`.
+- **Type-level surface:** `FusedMapping<S>`, `FusedMappingValue<S>`,
+  `FusedMappingElaborated<S>`, `FusedRollingSchema<S, FM>`,
+  `FusedPartitionedRollingSchema<S, ByCol, FM>`, and
+  `DurationString` — all exported from `pond-ts`. Output column
+  kinds narrow correctly through `event.get('cpu_avg')` to
+  `number | undefined`.
+
+### Performance
+
+`packages/core/scripts/perf-fused-rolling.mjs` — bench against
+gRPC RFC #20 acceptance criteria. Headline numbers (median of 3
+runs, `node --expose-gc`):
+
+```
+Partitioned, 100k events × 100 hosts (the gRPC use case):
+                                     wall (ms)    heap (MB)
+  single rolling baseline                95.20       74.33
+  two separate rollings (V7 shape)      141.12      101.71
+  fused two-window (V8 shape)           112.36       68.46
+
+Fused vs V7 shape:    -20.4% wall,  -32.7% heap
+Fused vs baseline:    +18.0% wall,   -7.9% heap
+
+Partitioned, 100k events × 1000 hosts (saturation):
+                                     wall (ms)    heap (MB)
+  two separate rollings (V7 shape)      700.35      556.56
+  fused two-window (V8 shape)           446.21      309.25
+
+Fused vs V7 shape:    -36.3% wall,  -44.4% heap
+```
+
+**Scaling beyond two windows — the architectural argument
+verified.** Every per-event pond hop runs ONCE in fused vs N times
+in N separate rollings. The bench scales N from 2 to 5 windows
+over the same 100k-events × 100-hosts source:
+
+```
+                Separate (ms)   Fused (ms)   Wall delta
+  N = 2            152.91         102.91       -32.7%
+  N = 3            186.63          79.89       -57.2%
+  N = 4            245.42         107.51       -56.2%
+  N = 5            279.79         118.90       -57.5%
+
+                Separate (MB)   Fused (MB)   Heap delta
+  N = 2            108.13          72.20       -33.2%
+  N = 3             93.30          43.08       -53.8%
+  N = 4            113.69          47.19       -58.5%
+  N = 5            137.17          47.12       -65.6%
+```
+
+Fused stays roughly constant (~100ms) across N=2..5; separate
+scales linearly. At N=5: **2.4× faster wall, 34% of the heap.**
+
+The architectural cliff is closed and the win compounds with N.
+Fused rolling's per-event cost is O(1) in the number of windows
+for pipeline overhead — only O(N) for the unavoidable per-window
+reducer-state updates (which separate also pays). Heap is
+dominated by the saved per-rolling deque + per-partition state.
+
+### Notes on what this does NOT include
+
+- **`live.reduce(mapping)` sugar.** Designed in PLAN as
+  `live.rolling({ buffer: mapping }, { history: false })`; the
+  `'buffer'` sentinel is reserved at the type level but throws at
+  runtime for now. Lands with the buffer-as-window Tier 1 PR.
+- **`TimeSeries.rolling` snapshot-side parity.** The keyed-form
+  overload is live-side only in v0.15.0; batch-side comes in a
+  follow-up.
+- **Path A (share `LiveSeries` buffer).** Currently Path B (own
+  deque) — fused rolling subscribes via `'event'` and maintains
+  its own per-partition deque. Path A is a transparent perf
+  follow-up; same API.
+- **Compile-time uniqueness check on output columns.** Runtime
+  check is in place; the type-level `CheckUniqueOutputs` helper
+  is parked as a follow-up. Same with tightening `DurationString`
+  to reject `'1min'`-style typos at the type level (today's
+  template-literal type is permissive; runtime `parseDuration`
+  catches malformed durations).
+
+### Migration
+
+Existing `live.rolling(window, mapping, opts)` calls are
+unchanged. The keyed form is opt-in and additive. Two-rolling
+patterns can migrate by collapsing to one fused call:
+
+```ts
+// Before:
+const baseline = byHost.rolling('1m', m1, { trigger });
+const slice = byHost.rolling('200ms', m2, { trigger });
+// Then a per-(ts, host) join over both event streams …
+
+// After:
+const fused = byHost.rolling({ '1m': m1, '200ms': m2 }, { trigger });
+fused.on('event', (e) => {
+  // All columns from both windows on one event.
+});
+```
+
+[0.15.0]: https://github.com/pjm17971/pond-ts/compare/v0.14.3...v0.15.0
+
 ## [0.14.3] — 2026-05-04
 
 A targeted allocation fix in the `'samples'` reducer's rolling-state

package/dist/LiveFusedRolling.d.ts

@@ -0,0 +1,55 @@
+import type { ColumnValue, EventForSchema, LiveSource, SeriesSchema } from './types.js';
+import type { FusedMapping } from './types-fused-rolling.js';
+import type { LiveRollingOptions } from './LiveRollingAggregation.js';
+type EventListener = (event: any) => void;
+/**
+ * Multi-window rolling that maintains N windows in one ingest pass
+ * over a single shared deque. Replaces the workaround of multiple
+ * separate `LiveRollingAggregation`s sharing the same source — the
+ * gRPC experiment's V6→V7 profile-diff (PR #19) showed every per-
+ * event pond hop roughly doubled when running two rollings.
+ *
+ * Each declared window has:
+ *  - Its own resolved duration (clipped to retention; see PLAN.md)
+ *  - Its own column-spec list and reducer states
+ *  - Its own head cursor into the shared deque
+ *
+ * Output is ONE merged stream: one event per trigger boundary, with
+ * all windows' columns concatenated into one record. Duplicate
+ * output column names across windows are rejected at construction
+ * with a clear error (compile-time detection is queued as a
+ * follow-up).
+ *
+ * **Single trigger.** All windows share the configured trigger.
+ * Per-window cadence is explicitly NOT supported — that's what
+ * fusion saves. Users who need per-window cadence fall back to two
+ * separate `rolling()` calls and pay the V7 cost.
+ *
+ * **Time-based windows only.** Object keys are duration strings.
+ * Count-based windows stay on the existing single-window
+ * `LiveRollingAggregation`. This constraint keeps the
+ * window-clip-to-retention rule and boundary-detection logic clean.
+ *
+ * Public API: constructed via the `live.rolling(fusedMapping, opts)`
+ * keyed-form overload on `LiveSeries` / `LiveView`. User code
+ * doesn't import this class directly.
+ */
+export declare class LiveFusedRolling<S extends SeriesSchema, Out extends SeriesSchema = SeriesSchema> implements LiveSource<Out> {
+    #private;
+    readonly name: string;
+    readonly schema: Out;
+    constructor(source: LiveSource<S>, fusedMapping: FusedMapping<S>, options?: LiveRollingOptions);
+    get length(): number;
+    at(index: number): EventForSchema<Out> | undefined;
+    /**
+     * Read the current merged snapshot — every window's reducer
+     * outputs concatenated into one record. Useful for live-display
+     * patterns where the consumer wants the latest values without
+     * waiting for the next trigger fire.
+     */
+    value(): Record<string, ColumnValue | undefined>;
+    on(type: 'event', fn: EventListener): () => void;
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=LiveFusedRolling.d.ts.map

package/dist/LiveFusedRolling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveFusedRolling.d.ts","sourceRoot":"","sources":["../src/LiveFusedRolling.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAGV,WAAW,EACX,cAAc,EACd,UAAU,EACV,YAAY,EACb,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAwCtE,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,gBAAgB,CAC3B,CAAC,SAAS,YAAY,EACtB,GAAG,SAAS,YAAY,GAAG,YAAY,CACvC,YAAW,UAAU,CAAC,GAAG,CAAC;;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;gBAoCnB,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,EACrB,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,EAC7B,OAAO,GAAE,kBAAuB;IAyGlC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS;IAKlD;;;;;OAKG;IACH,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IAahD,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,aAAa,GAAG,MAAM,IAAI;IAYhD,OAAO,IAAI,IAAI;CA0IhB"}

package/dist/LiveFusedRolling.js

@@ -0,0 +1,393 @@
+import { normalizeAggregateColumns, } from './aggregate-columns.js';
+import { Event } from './Event.js';
+import { Time } from './Time.js';
+import { rollingStateFor } from './reducers/index.js';
+import { bucketIndexFor, boundaryTimestampFor, } from './triggers.js';
+import { parseDuration } from './utils/duration.js';
+/**
+ * Multi-window rolling that maintains N windows in one ingest pass
+ * over a single shared deque. Replaces the workaround of multiple
+ * separate `LiveRollingAggregation`s sharing the same source — the
+ * gRPC experiment's V6→V7 profile-diff (PR #19) showed every per-
+ * event pond hop roughly doubled when running two rollings.
+ *
+ * Each declared window has:
+ *  - Its own resolved duration (clipped to retention; see PLAN.md)
+ *  - Its own column-spec list and reducer states
+ *  - Its own head cursor into the shared deque
+ *
+ * Output is ONE merged stream: one event per trigger boundary, with
+ * all windows' columns concatenated into one record. Duplicate
+ * output column names across windows are rejected at construction
+ * with a clear error (compile-time detection is queued as a
+ * follow-up).
+ *
+ * **Single trigger.** All windows share the configured trigger.
+ * Per-window cadence is explicitly NOT supported — that's what
+ * fusion saves. Users who need per-window cadence fall back to two
+ * separate `rolling()` calls and pay the V7 cost.
+ *
+ * **Time-based windows only.** Object keys are duration strings.
+ * Count-based windows stay on the existing single-window
+ * `LiveRollingAggregation`. This constraint keeps the
+ * window-clip-to-retention rule and boundary-detection logic clean.
+ *
+ * Public API: constructed via the `live.rolling(fusedMapping, opts)`
+ * keyed-form overload on `LiveSeries` / `LiveView`. User code
+ * doesn't import this class directly.
+ */
+export class LiveFusedRolling {
+    name;
+    schema;
+    /** Shared deque sized by the longest declared window. */
+    #entries;
+    /** Per-window state, in declared order. */
+    #windows;
+    /**
+     * Longest declared window in ms — bounds the shared deque. Equal
+     * to `max(windows[i].windowMs)`.
+     */
+    #longestWindowMs;
+    /**
+     * Output column specs in declared order — flat union across all
+     * windows. Used to assemble emit records and the output schema.
+     */
+    #emitColumns;
+    #trigger;
+    /**
+     * For clock triggers: the bucket index of the most recently
+     * crossed boundary. Undefined until the first event is ingested.
+     */
+    #lastClockBucketIdx;
+    /**
+     * For count triggers: the number of events ingested since the
+     * most recent emission.
+     */
+    #countSinceLastEmit;
+    #nextIndex;
+    #outputEvents;
+    #onEvent;
+    #unsubscribe;
+    constructor(source, fusedMapping, options = {}) {
+        this.name = source.name;
+        const topMinSamples = options.minSamples ?? 0;
+        if (!Number.isInteger(topMinSamples) || topMinSamples < 0) {
+            throw new TypeError('rolling minSamples must be a non-negative integer (default 0)');
+        }
+        this.#trigger = options.trigger ?? { kind: 'event' };
+        this.#lastClockBucketIdx = undefined;
+        this.#countSinceLastEmit = 0;
+        this.#nextIndex = 0;
+        this.#entries = [];
+        this.#outputEvents = [];
+        this.#onEvent = new Set();
+        // Resolve each window: parse the duration key, normalize the
+        // mapping (handles bare AggregateMap, AggregateOutputMap, and the
+        // elaborated `{ mapping, minSamples }` wrapper), build per-column
+        // reducer state.
+        const windowKeys = Object.keys(fusedMapping);
+        if (windowKeys.length === 0) {
+            throw new TypeError('fused rolling: at least one window must be declared');
+        }
+        const windows = [];
+        let longestMs = 0;
+        for (const key of windowKeys) {
+            const value = fusedMapping[key];
+            const { innerMapping, perWindowMinSamples } = unwrapFusedMappingValue(value);
+            const windowMs = resolveWindowKey(key);
+            if (windowMs > longestMs)
+                longestMs = windowMs;
+            // Reuse the same column-normalisation helper used by the
+            // single-window rolling — keeps reducer-state behavior
+            // identical to today's-shape `LiveRollingAggregation`.
+            const columns = normalizeAggregateColumns(source.schema, innerMapping);
+            const states = columns.map((c) => rollingStateFor(c.reducer));
+            windows.push({
+                id: key,
+                windowMs,
+                columns,
+                states,
+                minSamples: perWindowMinSamples ?? topMinSamples,
+                head: 0,
+            });
+        }
+        this.#windows = windows;
+        this.#longestWindowMs = longestMs;
+        // Build the merged output schema. Reject duplicate output column
+        // names across windows. (Compile-time detection is a follow-up;
+        // runtime check keeps shipping unblocked.)
+        const seenOutputs = new Set();
+        const emitColumns = [];
+        for (const win of this.#windows) {
+            for (const col of win.columns) {
+                if (seenOutputs.has(col.output)) {
+                    throw new TypeError(`fused rolling: duplicate output column '${col.output}' across windows. ` +
+                        `Each output column name must be unique across the merged schema. ` +
+                        `Either rename the alias (use AggregateOutputMap with a distinct \`from\` ` +
+                        `→ alias mapping) or drop one of the duplicating windows.`);
+                }
+                seenOutputs.add(col.output);
+                emitColumns.push(col);
+            }
+        }
+        this.#emitColumns = emitColumns;
+        this.schema = Object.freeze([
+            source.schema[0],
+            ...emitColumns.map((c) => ({
+                name: c.output,
+                kind: c.kind,
+                required: false,
+            })),
+        ]);
+        // Replay the source's existing events through the same ingest
+        // path, so a fused rolling created on a non-empty source matches
+        // the streaming-from-construction shape.
+        for (let i = 0; i < source.length; i++) {
+            this.#ingest(source.at(i));
+        }
+        this.#unsubscribe = source.on('event', (event) => {
+            this.#ingest(event);
+        });
+    }
+    // ── LiveSource<Out> contract ────────────────────────────────
+    get length() {
+        return this.#outputEvents.length;
+    }
+    at(index) {
+        if (index < 0)
+            index = this.#outputEvents.length + index;
+        return this.#outputEvents[index];
+    }
+    /**
+     * Read the current merged snapshot — every window's reducer
+     * outputs concatenated into one record. Useful for live-display
+     * patterns where the consumer wants the latest values without
+     * waiting for the next trigger fire.
+     */
+    value() {
+        const result = {};
+        for (const win of this.#windows) {
+            const warmup = this.#windowSize(win) < win.minSamples;
+            for (let i = 0; i < win.columns.length; i++) {
+                result[win.columns[i].output] = warmup
+                    ? undefined
+                    : win.states[i].snapshot();
+            }
+        }
+        return result;
+    }
+    on(type, fn) {
+        if (type !== 'event') {
+            throw new TypeError(`LiveFusedRolling.on: unsupported event type '${String(type)}'`);
+        }
+        this.#onEvent.add(fn);
+        return () => {
+            this.#onEvent.delete(fn);
+        };
+    }
+    dispose() {
+        this.#unsubscribe();
+    }
+    // ── Private ─────────────────────────────────────────────────
+    /**
+     * Number of events currently in window `w`'s reducer state.
+     * Equals `entries.length - (w.head - frontAbsIdx)` where
+     * `frontAbsIdx = entries[0].absIdx`. Used for minSamples gating.
+     */
+    #windowSize(w) {
+        if (this.#entries.length === 0)
+            return 0;
+        const frontAbsIdx = this.#entries[0].absIdx;
+        return this.#entries.length - (w.head - frontAbsIdx);
+    }
+    #ingest(event) {
+        const data = event.data();
+        const absIdx = this.#nextIndex++;
+        const ts = event.begin();
+        const entry = { absIdx, timestamp: ts, data };
+        this.#entries.push(entry);
+        // Per-window: advance head while leading entries are out-of-window,
+        // then add the new event to every column's reducer state.
+        for (const win of this.#windows) {
+            const cutoff = ts - win.windowMs;
+            while (win.head < absIdx &&
+                this.#getEntry(win.head).timestamp < cutoff) {
+                const old = this.#getEntry(win.head);
+                for (let i = 0; i < win.columns.length; i++) {
+                    win.states[i].remove(old.absIdx, old.data[win.columns[i].source]);
+                }
+                win.head++;
+            }
+            for (let i = 0; i < win.columns.length; i++) {
+                win.states[i].add(absIdx, data[win.columns[i].source]);
+            }
+        }
+        // Compact the shared deque: drop entries before the leftmost
+        // window head. The longest window's head IS this leftmost head
+        // in steady state.
+        this.#compactFront();
+        // Emission gated by the configured trigger.
+        switch (this.#trigger.kind) {
+            case 'event':
+                this.#emitEvent(event.key());
+                return;
+            case 'clock':
+                this.#emitClock(ts, this.#trigger);
+                return;
+            case 'count':
+                this.#emitCount(event.key(), this.#trigger.n);
+                return;
+        }
+    }
+    /**
+     * Translate an absolute event index to its current position in
+     * the shared deque. Returns `undefined` if the entry has been
+     * compacted out of the front.
+     */
+    #getEntry(absIdx) {
+        if (this.#entries.length === 0)
+            return undefined;
+        const front = this.#entries[0].absIdx;
+        const offset = absIdx - front;
+        if (offset < 0 || offset >= this.#entries.length)
+            return undefined;
+        return this.#entries[offset];
+    }
+    /**
+     * Drop entries from the front of the shared deque whose absIdx
+     * is less than every window's head. The longest window's head
+     * defines the leftmost-still-live cursor.
+     *
+     * Uses `Array.shift()` for now (matches today's
+     * `LiveRollingAggregation`); the head-index-pointer ring-buffer
+     * optimization is queued as a separate tactical fix in PLAN.md.
+     */
+    #compactFront() {
+        if (this.#entries.length === 0)
+            return;
+        let minHead = this.#windows[0].head;
+        for (let i = 1; i < this.#windows.length; i++) {
+            const h = this.#windows[i].head;
+            if (h < minHead)
+                minHead = h;
+        }
+        while (this.#entries.length > 0 && this.#entries[0].absIdx < minHead) {
+            this.#entries.shift();
+        }
+    }
+    #emitCount(key, n) {
+        this.#countSinceLastEmit++;
+        if (this.#countSinceLastEmit < n)
+            return;
+        this.#countSinceLastEmit = 0;
+        this.#emitEvent(key);
+    }
+    /**
+     * Build one merged event with every window's reducer snapshot
+     * concatenated into one record, then push to outputs and notify
+     * listeners.
+     */
+    #emitEvent(key) {
+        const record = {};
+        for (const win of this.#windows) {
+            const warmup = this.#windowSize(win) < win.minSamples;
+            for (let i = 0; i < win.columns.length; i++) {
+                record[win.columns[i].output] = warmup
+                    ? undefined
+                    : win.states[i].snapshot();
+            }
+        }
+        const outputEvent = new Event(key, record);
+        this.#outputEvents.push(outputEvent);
+        for (const fn of this.#onEvent)
+            fn(outputEvent);
+    }
+    #emitClock(eventTs, trigger) {
+        const bucketIdx = bucketIndexFor(trigger, eventTs);
+        if (this.#lastClockBucketIdx === undefined) {
+            this.#lastClockBucketIdx = bucketIdx;
+            return;
+        }
+        if (bucketIdx > this.#lastClockBucketIdx) {
+            const boundaryMs = boundaryTimestampFor(trigger, bucketIdx);
+            this.#emitEvent(new Time(boundaryMs));
+            this.#lastClockBucketIdx = bucketIdx;
+        }
+    }
+}
+// ── Helpers (module-private) ──────────────────────────────────
+/**
+ * Resolve a fused-mapping window key (duration string or `'buffer'`
+ * sentinel) to a duration in ms. The `'buffer'` sentinel is reserved
+ * for future use by `live.reduce()` and not yet implemented; throws
+ * a clear error for now.
+ */
+function resolveWindowKey(key) {
+    if (key === 'buffer') {
+        throw new TypeError(`fused rolling: 'buffer' sentinel key is reserved for live.reduce(); ` +
+            `not yet implemented. Use an explicit duration string ` +
+            `(e.g. '1m', '200ms') for now.`);
+    }
+    // parseDuration's input type is `number | DurationString` — at runtime it
+    // throws on bad input. Cast to satisfy the type and let parseDuration
+    // surface a clear error if the key isn't a valid duration string. Wrap
+    // the throw to point at the fused-rolling context.
+    try {
+        return parseDuration(key);
+    }
+    catch {
+        throw new TypeError(`fused rolling: invalid window key '${key}'. Keys must be duration ` +
+            `strings (e.g. '1m', '200ms', '5s'). Count-based windows stay on ` +
+            `the existing single-window overload.`);
+    }
+}
+/**
+ * Peel off the elaborated wrapper if present, returning the inner
+ * mapping and the per-window minSamples (if specified).
+ */
+/**
+ * True when `v` looks like an `AggregateOutputSpec` — i.e., a bare
+ * `{ from: string, using: ... }` shape. Used to disambiguate the
+ * elaborated-wrapper detection: a user with an `AggregateOutputMap`
+ * entry literally named `'mapping'` (e.g. `{ '1m': { mapping: { from:
+ * 'cpu', using: 'avg' } } }`) must NOT be unwrapped as the wrapper.
+ *
+ * The wrapper's `mapping` field carries a whole record of column
+ * specs; the colliding-name AggregateOutputMap entry's `mapping` key
+ * carries one spec. This check distinguishes the two by looking for
+ * the `from` + `using` discriminators that only exist on a spec.
+ */
+function isAggregateOutputSpec(v) {
+    return (v !== null &&
+        typeof v === 'object' &&
+        typeof v.from === 'string' &&
+        'using' in v);
+}
+function unwrapFusedMappingValue(value) {
+    if (value !== null &&
+        typeof value === 'object' &&
+        'mapping' in value &&
+        typeof value.mapping === 'object' &&
+        // Disambiguation: if `.mapping` is itself an AggregateOutputSpec,
+        // the user named an alias `mapping` in an AggregateOutputMap —
+        // this is NOT the elaborated wrapper. Fall through to the bare
+        // mapping branch.
+        !isAggregateOutputSpec(value.mapping)) {
+        const elaborated = value;
+        if (elaborated.minSamples !== undefined) {
+            if (!Number.isInteger(elaborated.minSamples) ||
+                elaborated.minSamples < 0) {
+                throw new TypeError('fused rolling: per-window minSamples must be a non-negative integer');
+            }
+        }
+        return {
+            innerMapping: elaborated.mapping,
+            perWindowMinSamples: elaborated.minSamples,
+        };
+    }
+    return {
+        innerMapping: value,
+        perWindowMinSamples: undefined,
+    };
+}
+//# sourceMappingURL=LiveFusedRolling.js.map

package/dist/LiveFusedRolling.js.map

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