pond-ts 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -7,11 +7,76 @@ 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.18.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.20.0...HEAD
+[0.20.0]: https://github.com/pjm17971/pond-ts/compare/v0.19.0...v0.20.0
+[0.19.0]: https://github.com/pjm17971/pond-ts/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/pjm17971/pond-ts/compare/v0.17.1...v0.18.0
 
 ## [Unreleased]
 
+## [0.20.0] — 2026-06-04
+
+Two internal performance improvements driven by the dashboard experiment at
+256-host stress. **No public API changes** — both are behavior-preserving.
+
+### Changed
+
+- **Column-native partition routing.** `partitionBy(...)` over a strict
+  time-keyed source now routes its source chunks into per-partition
+  **chunked** sub-series via a coalescing staging tier, replacing the
+  per-partition `Event[]` retention. A large drop in retained memory and
+  object count at high partition counts (gRPC bench at 256 partitions: 60×
+  fewer columnar stores, −99.4% `Event` retention, +24% sustained throughput)
+  ([#175](https://github.com/pjm17971/pond-ts/pull/175)). Behavior-preserving;
+  internal only — no public surface added.
+- **`LiveView.toTimeSeries()` snapshot caching.** The built `TimeSeries` is
+  memoized against an internal mutation counter, so back-to-back
+  identical-state calls (multiple subscribers, framework commit batching,
+  StrictMode double-invoke) return the cached instance by reference instead of
+  rebuilding the whole snapshot — ~44 ms → ~0 at a 262k-event window. A
+  fresh-state call still builds; safe because `TimeSeries` is immutable
+  ([#180](https://github.com/pjm17971/pond-ts/pull/180)).
+
+## [0.19.0] — 2026-06-02
+
+Adds an **experimental column-read surface to the live side** — read typed
+columns straight off a `LiveView` without materializing a `TimeSeries`
+snapshot — driven by the dashboard experiment's per-tick memo cost. Plus a
+`useTimeSeries` schema-inference fix. The live column surface is
+**experimental and expected to keep moving in 0.19.x**.
+
+### Added
+
+- **`LiveView` column-read surface (experimental).** Read columns directly
+  off a windowed live view, the column-API counterpart to the batch
+  `TimeSeries` surface ([#179](https://github.com/pjm17971/pond-ts/pull/179)):
+  - `liveView.column(name)` — a numeric value column gathered from the view's
+    current events (string / array columns are a compile error; read those as
+    scalars or snapshot via `toTimeSeries()`).
+  - `liveView.keyColumn()` — the time axis (`TimeKeyColumn`; time-keyed views
+    only, enforced at compile time).
+  - `liveView.partitionBy(col).toMap(fn)` — a walk-now per-partition read
+    returning `Map<string, R>`, mirroring `TimeSeries.partitionBy().toMap()`
+    but without per-partition `TimeSeries` construction. Distinct from
+    `LiveSeries.partitionBy` (which is subscription-oriented). Throws on a
+    missing / key partition column rather than silently merging.
+  - `LiveColumnGroup` — the per-partition view passed to the `toMap` callback.
+- **`@pond-ts/react`: `useLiveVersion(source, { throttle })` (experimental)**
+  — a `useSyncExternalStore`-based change signal that bumps on append **and**
+  eviction, so a component can read columns off a live view each render
+  without manufacturing a `TimeSeries` snapshot. Closes the
+  render-before-subscribe gap; throttling bounds only the React notification
+  ([#179](https://github.com/pjm17971/pond-ts/pull/179)).
+
+### Changed
+
+- **`useTimeSeries` collapsed to a single generic** `<S extends SeriesSchema>`
+  so the schema infers from `input.schema`. The prior two-generic signature
+  lost `S` through the input-wrapper generic and resolved
+  `result.column('cpu')` to `never`; the accepted input type is unchanged, so
+  this is an inference fix — but a caller passing two explicit type arguments
+  must drop the second ([#176](https://github.com/pjm17971/pond-ts/pull/176)).
+
 ## [0.18.0] — 2026-05-30
 
 This release graduates the **Phase 4.7 columnar substrate** from

package/README.md

@@ -1,7 +1,7 @@
 # pond-ts
 
 **Highly optimised, fully typed Timeseries library for TypeScript**
- 
+
 Schema-driven events, composable batch transforms, push-based streaming
 ingest, multi-entity partitioning, and an optional React integration —
 all strict TypeScript end to end, all immutable.
@@ -31,6 +31,11 @@ npm install @pond-ts/react          # React hooks (optional)
   single node.js instance.)
 - **Triggers** — for control of rolling emission cadences. Synchronised
   partitioned rolling fires across partitions on every boundary.
+- **Typed column extraction** — `series.column('cpu')` returns a
+  schema-narrowed typed column with single-pass reductions
+  (`min`/`max`/`sum`/`mean`/`stdev`/`median`/`percentile`/`minMax`),
+  index downsampling (`bin`), and a zero-copy `toFloat64Array()` for
+  canvas / WebGL draw loops — no per-event allocation on the hot path.
 - **No legacy baggage**
 
 ## Quick start: batch

package/dist/batch/aggregate-columns.d.ts

@@ -1,4 +1,4 @@
-import type { AggregateMap, AggregateOutputMap, AggregateOutputSpec, AggregateReducer, ScalarKind, SeriesSchema } from '../schema/index.js';
+import type { AggregateMap, AggregateOutputMap, AggregateReducer, ScalarKind, SeriesSchema } from '../schema/index.js';
 /**
  * Normalised column spec used by both batch and live aggregation paths.
  *
@@ -17,12 +17,6 @@ export type AggregateColumnSpec = {
     reducer: AggregateReducer;
     kind: ScalarKind;
 };
-/**
- * @internal — discriminator between an `AggregateOutputSpec` (`{ from,
- * using, kind? }`) and a bare reducer string/function passed in an
- * `AggregateMap` slot.
- */
-export declare function isAggregateOutputSpec<S extends SeriesSchema>(value: unknown): value is AggregateOutputSpec<S>;
 /**
  * Resolve a user-supplied `mapping` (either `AggregateMap<S>` or
  * `AggregateOutputMap<S>`) against the source `schema` into a flat

package/dist/batch/aggregate-columns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-columns.d.ts","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,YAAY,EAC1D,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAAC,CAAC,CAAC,CAOjC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAC/C,mBAAmB,EAAE,CAuDvB"}
+{"version":3,"file":"aggregate-columns.d.ts","sourceRoot":"","sources":["../../src/batch/aggregate-columns.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAElB,gBAAgB,EAChB,UAAU,EACV,YAAY,EACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAkBF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAC/C,mBAAmB,EAAE,CAuDvB"}

package/dist/columnar/column.d.ts

@@ -127,13 +127,6 @@ export declare class Float64Column implements ColumnBase<number, 'number'> {
     readonly kind: "number";
     readonly storage: "packed";
     readonly length: number;
-    /**
-     * @internal Substrate-level raw buffer handle. May be oversized
-     * (`_values.length > length` for capacity-grown columns). Walk
-     * with `this.length` as the bound. For consumer code that wants
-     * a length-bounded `Float64Array`, use `toFloat64Array()`.
-     */
-    readonly _values: Float64Array;
     readonly validity?: ValidityBitmap;
     constructor(values: Float64Array, length: number, validity?: ValidityBitmap);
     read(i: number): number | undefined;

package/dist/columnar/column.d.ts.map

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

package/dist/columnar/key-column.d.ts

@@ -88,19 +88,6 @@ export declare class TimeKeyColumn implements KeyColumnBase<'time'> {
      * O(1) on the key axis rather than O(e − s).
      */
     sliceByRange(start: number, end: number): TimeKeyColumn;
-    /**
-     * @internal Trusted-buffer factory used by slice paths. Skips
-     * the per-row finiteness scan that the public constructor runs;
-     * the caller MUST pass a subarray of (or otherwise equivalently
-     * pre-validated) buffer from a `TimeKeyColumn` that was itself
-     * constructed via the public path. External callers must use
-     * `new TimeKeyColumn(...)`.
-     *
-     * Still validates structural invariants: finite non-negative
-     * integer `length` and `length <= begin.length`. Those are O(1)
-     * and protect against caller-passed garbage.
-     */
-    static fromValidatedSubarray(begin: Float64Array, length: number): TimeKeyColumn;
     /**
      * Gathers rows by index into a new `TimeKeyColumn`. Out-of-range
      * source indices produce a `0` slot in the output buffer — the
@@ -131,20 +118,6 @@ export declare class TimeRangeKeyColumn implements KeyColumnBase<'timeRange'> {
      * See RFC §4 close-cases for why range-key max-end is deferred.
      */
     sliceByRange(start: number, end: number): TimeRangeKeyColumn;
-    /**
-     * @internal Trusted-buffer factory for slice paths. Skips per-
-     * row finiteness scans on both buffers AND the `begin[i] <=
-     * end[i]` invariant check — the caller MUST pass subarrays of
-     * (or equivalently pre-validated) buffers from a
-     * `TimeRangeKeyColumn` that was itself constructed via the
-     * public path. External callers must use
-     * `new TimeRangeKeyColumn(...)`.
-     *
-     * Still validates O(1) structural invariants: finite non-
-     * negative integer `length`, and `length <= min(begin.length,
-     * end.length)`.
-     */
-    static fromValidatedSubarray(begin: Float64Array, end: Float64Array, length: number): TimeRangeKeyColumn;
     /**
      * Gathers rows by index into a new `TimeRangeKeyColumn`. See
      * `TimeKeyColumn.sliceByIndices` for the out-of-range semantics.
@@ -189,24 +162,6 @@ export declare class IntervalKeyColumn implements KeyColumnBase<'interval'> {
      * `end[length - 1]`).
      */
     sliceByRange(start: number, end: number): IntervalKeyColumn;
-    /**
-     * @internal Trusted-buffer factory for slice paths. Skips
-     * per-row validation: finiteness scans on begin/end, the
-     * begin[i] <= end[i] invariant check, AND the per-row label
-     * defined-and-type-matches check (which is the dominant cost
-     * for IntervalKeyColumn — `labels.read(i)` per row).
-     *
-     * Caller MUST pass subarrays / pre-validated buffers from an
-     * `IntervalKeyColumn` that was constructed via the public path
-     * (or compositionally from other trusted paths). External
-     * callers must use `new IntervalKeyColumn(...)`.
-     *
-     * The `labelKind` argument is explicit (rather than re-derived
-     * from `labels.kind`) so callers retain the source column's
-     * discriminator without an extra branch — trusted construction
-     * trusts the caller knows what they have.
-     */
-    static fromValidatedSubarray(begin: Float64Array, end: Float64Array, labels: StringColumn | Float64Column, labelKind: IntervalLabelKind, length: number): IntervalKeyColumn;
     /**
      * Gathers rows by index into a new `IntervalKeyColumn`. The label
      * column is `sliceByIndices`'d as well — for string labels the

package/dist/columnar/key-column.d.ts.map

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

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { LiveAggregation } from './live/live-aggregation.js';
 export type { LiveAggregationOptions } from './live/live-aggregation.js';
 export { LivePartitionedSeries, LivePartitionedView, type LivePartitionedOptions, } from './live/live-partitioned-series.js';
 export { LiveSeries } from './live/live-series.js';
-export { LiveView } from './live/live-view.js';
+export { LiveView, LiveColumnGroup } from './live/live-view.js';
 export type { LiveFillMapping, LiveFillStrategy } from './live/live-view.js';
 export { LiveRollingAggregation } from './live/live-rolling-aggregation.js';
 export { LiveFusedRolling } from './live/live-fused-rolling.js';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -4,7 +4,7 @@ export { Interval } from './core/interval.js';
 export { LiveAggregation } from './live/live-aggregation.js';
 export { LivePartitionedSeries, LivePartitionedView, } from './live/live-partitioned-series.js';
 export { LiveSeries } from './live/live-series.js';
-export { LiveView } from './live/live-view.js';
+export { LiveView, LiveColumnGroup } from './live/live-view.js';
 export { LiveRollingAggregation } from './live/live-rolling-aggregation.js';
 export { LiveFusedRolling } from './live/live-fused-rolling.js';
 export { LivePartitionedFusedRolling } from './live/live-partitioned-fused-rolling.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EACL,qBAAqB,EACrB,mBAAmB,GAEpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAM7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAgB,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,mEAAmE;AACnE,EAAE;AACF,0DAA0D;AAC1D,kEAAkE;AAClE,6DAA6D;AAC7D,yDAAyD;AACzD,iEAAiE;AACjE,mEAAmE;AACnE,OAAO,aAAa,CAAC;AAmBrB,iEAAiE;AACjE,EAAE;AACF,+DAA+D;AAC/D,oEAAoE;AACpE,+DAA+D;AAC/D,8DAA8D;AAC9D,oEAAoE;AACpE,mDAAmD;AACnD,EAAE;AACF,8DAA8D;AAC9D,kEAAkE;AAClE,kEAAkE;AAClE,2DAA2D;AAC3D,kEAAkE;AAClE,4DAA4D;AAC5D,kEAAkE;AAClE,EAAE;AACF,iEAAiE;AACjE,8DAA8D;AAC9D,8DAA8D;AAC9D,6DAA6D;AAC7D,6DAA6D;AAC7D,gBAAgB;AAChB,OAAO,EAKL,aAAa,EACb,aAAa,GACd,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EACjB,aAAa,EACb,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EACL,qBAAqB,EACrB,mBAAmB,GAEpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAM7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAgB,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,mEAAmE;AACnE,EAAE;AACF,0DAA0D;AAC1D,kEAAkE;AAClE,6DAA6D;AAC7D,yDAAyD;AACzD,iEAAiE;AACjE,mEAAmE;AACnE,OAAO,aAAa,CAAC;AAmBrB,iEAAiE;AACjE,EAAE;AACF,+DAA+D;AAC/D,oEAAoE;AACpE,+DAA+D;AAC/D,8DAA8D;AAC9D,oEAAoE;AACpE,mDAAmD;AACnD,EAAE;AACF,8DAA8D;AAC9D,kEAAkE;AAClE,kEAAkE;AAClE,2DAA2D;AAC3D,kEAAkE;AAClE,4DAA4D;AAC5D,kEAAkE;AAClE,EAAE;AACF,iEAAiE;AACjE,8DAA8D;AAC9D,8DAA8D;AAC9D,6DAA6D;AAC7D,6DAA6D;AAC7D,gBAAgB;AAChB,OAAO,EAKL,aAAa,EACb,aAAa,GACd,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EACjB,aAAa,EACb,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}

package/dist/live/live-chunked-storage.d.ts

@@ -48,10 +48,25 @@ import type { ReadableLiveStorage } from './live-storage.js';
  * after the listeners run), so they don't defeat the heap win.
  */
 export declare function materializeEventsFromStore<S extends SeriesSchema>(store: ColumnarStore<S>, schema: S): EventForSchema<S>[];
+/**
+ * Like {@link materializeEventsFromStore} but over a subset of rows
+ * (`indices`, in order) — the transient `'event'` / `'batch'` fan-out
+ * for the column-native partition router's staged slice. NOT cached
+ * (young-gen), so it doesn't defeat the heap win.
+ */
+export declare function materializeEventsFromStoreAt<S extends SeriesSchema>(store: ColumnarStore<S>, indices: ArrayLike<number>, schema: S): EventForSchema<S>[];
 export declare class ChunkedColumnarLiveStorage<S extends SeriesSchema> implements ReadableLiveStorage<S> {
     #private;
-    constructor(schema: S);
+    constructor(schema: S, flushThreshold?: number);
     get length(): number;
+    /**
+     * Number of committed (compacted) chunks. Test/bench observability for
+     * the coalescing win — under thin partition routing this stays bounded
+     * (≈ rows / flushThreshold) instead of one chunk per source batch.
+     */
+    get committedChunkCount(): number;
+    /** Rows currently in the un-flushed staging tier (`< flushThreshold`). */
+    get pendingCount(): number;
     /**
      * Validate a batch of rows directly into columns and append it as a
      * chunk. No per-row `Event` is created. The caller (`LiveSeries`)
@@ -66,6 +81,18 @@ export declare class ChunkedColumnarLiveStorage<S extends SeriesSchema> implemen
      * convenience used by the isolated tests.
      */
     appendStore(store: ColumnarStore<S>): void;
+    /**
+     * Stage a partition's slice of a source chunk: gather rows `indices`
+     * from `store` into the pending tier (cheap tuples — NO per-batch
+     * `ColumnarStore`), flushing one packed chunk when the tier reaches
+     * `#flushThreshold`. The column-native partition-routing path
+     * (`LivePartitionedSeries.#routeChunk`); the coalescing fix for thin
+     * scatter (gRPC V7: naive one-chunk-per-slice was 23.5× the object
+     * count + a throughput collapse). The caller guarantees the gathered
+     * rows are `>=` the current last key (strict source + order-preserving
+     * scatter). Time-keyed only — the chunked routing gate is strict+time.
+     */
+    stageRows(store: ColumnarStore<S>, indices: ArrayLike<number>): void;
     at(index: number): EventForSchema<S> | undefined;
     keyAt(index: number): EventKey | undefined;
     beginAt(index: number): number | undefined;

package/dist/live/live-chunked-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-chunked-storage.d.ts","sourceRoot":"","sources":["../../src/live/live-chunked-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,YAAY,EAC/D,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,GACR,cAAc,CAAC,CAAC,CAAC,EAAE,CAoBrB;AAiBD,qBAAa,0BAA0B,CACrC,CAAC,SAAS,YAAY,CACtB,YAAW,mBAAmB,CAAC,CAAC,CAAC;;gBASrB,MAAM,EAAE,CAAC;IAYrB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACH,mBAAmB,CAAC,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAY/D;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAkB1C,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS;IAWhD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAQ1C,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAM1C,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS;IAIrC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IASxD,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAM3B,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAWzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;CA4EtC"}
+{"version":3,"file":"live-chunked-storage.d.ts","sourceRoot":"","sources":["../../src/live/live-chunked-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,YAAY,EAC/D,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,CAAC,GACR,cAAc,CAAC,CAAC,CAAC,EAAE,CAoBrB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,YAAY,EACjE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,EAC1B,MAAM,EAAE,CAAC,GACR,cAAc,CAAC,CAAC,CAAC,EAAE,CAqBrB;AAiBD,qBAAa,0BAA0B,CACrC,CAAC,SAAS,YAAY,CACtB,YAAW,mBAAmB,CAAC,CAAC,CAAC;;gBAsBrB,MAAM,EAAE,CAAC,EAAE,cAAc,SAAM;IAkB3C,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;OAIG;IACH,IAAI,mBAAmB,IAAI,MAAM,CAEhC;IAED,0EAA0E;IAC1E,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACH,mBAAmB,CAAC,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAY/D;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAY1C;;;;;;;;;;OAUG;IACH,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI;IAyDpE,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS;IAehD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAa1C,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAS1C,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS;IAIrC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IASxD,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAM3B,KAAK,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAYzC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;CAkGtC"}

package/dist/live/live-chunked-storage.js

@@ -68,6 +68,33 @@ export function materializeEventsFromStore(store, schema) {
     }
     return out;
 }
+/**
+ * Like {@link materializeEventsFromStore} but over a subset of rows
+ * (`indices`, in order) — the transient `'event'` / `'batch'` fan-out
+ * for the column-native partition router's staged slice. NOT cached
+ * (young-gen), so it doesn't defeat the heap win.
+ */
+export function materializeEventsFromStoreAt(store, indices, schema) {
+    const keyKind = schema[0].kind;
+    const valueNames = [];
+    for (let i = 1; i < schema.length; i += 1) {
+        valueNames.push(schema[i].name);
+    }
+    const out = new Array(indices.length);
+    for (let j = 0; j < indices.length; j += 1) {
+        const i = indices[j];
+        const begin = store.beginAt(i);
+        const key = keyKind === 'time'
+            ? new Time(begin)
+            : new TimeRange({ start: begin, end: store.endAt(i) });
+        const data = {};
+        for (let v = 0; v < valueNames.length; v += 1) {
+            data[valueNames[v]] = store.valueAt(i, valueNames[v]);
+        }
+        out[j] = new Event(key, data);
+    }
+    return out;
+}
 /** Row-range slice of a store: sliced keys + each column sliced in lockstep. */
 function sliceStore(store, start, end) {
     const keys = store.keys.sliceByRange(start, end);
@@ -83,20 +110,49 @@ export class ChunkedColumnarLiveStorage {
     #keyKind;
     #valueNames;
     #chunks = [];
-    #total = 0;
+    /** Rows committed to `#chunks` (excludes the pending staging tier). */
+    #committed = 0;
+    /**
+     * Staging tier — gathered row tuples not yet compacted into a chunk.
+     * The coalescing fix for thin partition routing (scatter delivers ~1
+     * row per partition per source batch; one chunk each would be ~23×
+     * the object count of the Events it replaces — see PLAN "Deferred").
+     * Rows accumulate here (cheap pushes, no per-batch `ColumnarStore`),
+     * then flush as ONE packed chunk at `#flushThreshold`. Readable in
+     * place so the live series' `length` / `at(i)` / retention see staged
+     * rows immediately. Bounded to `[0, #flushThreshold)` at any instant.
+     */
+    #pending = [];
+    #flushThreshold;
     /** Lazy event materialization cache, keyed by logical index. */
     #cache = new Map();
-    constructor(schema) {
+    constructor(schema, flushThreshold = 256) {
         this.#schema = schema;
         const keyKind = schema[0].kind;
         if (keyKind !== 'time' && keyKind !== 'timeRange') {
             throw new Error(`ChunkedColumnarLiveStorage: unsupported key kind '${keyKind}' (expected 'time' | 'timeRange')`);
         }
+        if (!Number.isInteger(flushThreshold) || flushThreshold < 1) {
+            throw new Error(`ChunkedColumnarLiveStorage: flushThreshold must be a positive integer, got ${flushThreshold}`);
+        }
         this.#keyKind = keyKind;
+        this.#flushThreshold = flushThreshold;
         this.#valueNames = schema.slice(1).map((c) => c.name);
     }
     get length() {
-        return this.#total;
+        return this.#committed + this.#pending.length;
+    }
+    /**
+     * Number of committed (compacted) chunks. Test/bench observability for
+     * the coalescing win — under thin partition routing this stays bounded
+     * (≈ rows / flushThreshold) instead of one chunk per source batch.
+     */
+    get committedChunkCount() {
+        return this.#chunks.length;
+    }
+    /** Rows currently in the un-flushed staging tier (`< flushThreshold`). */
+    get pendingCount() {
+        return this.#pending.length;
     }
     /**
      * Validate a batch of rows directly into columns and append it as a
@@ -123,12 +179,72 @@ export class ChunkedColumnarLiveStorage {
     appendStore(store) {
         if (store.length === 0)
             return;
+        // A direct chunk lands logically AFTER any staged rows, so flush
+        // pending first to keep committed order correct. (In practice a
+        // storage uses either appendStore — the source's big batches — or
+        // stageRows — partition routing — not both; the guard keeps the
+        // order contract unconditional.)
+        if (this.#pending.length > 0)
+            this.#flushPending();
         this.#chunks.push(store);
-        this.#total += store.length;
+        this.#committed += store.length;
+    }
+    /**
+     * Stage a partition's slice of a source chunk: gather rows `indices`
+     * from `store` into the pending tier (cheap tuples — NO per-batch
+     * `ColumnarStore`), flushing one packed chunk when the tier reaches
+     * `#flushThreshold`. The column-native partition-routing path
+     * (`LivePartitionedSeries.#routeChunk`); the coalescing fix for thin
+     * scatter (gRPC V7: naive one-chunk-per-slice was 23.5× the object
+     * count + a throughput collapse). The caller guarantees the gathered
+     * rows are `>=` the current last key (strict source + order-preserving
+     * scatter). Time-keyed only — the chunked routing gate is strict+time.
+     */
+    stageRows(store, indices) {
+        if (this.#keyKind !== 'time') {
+            throw new Error(`ChunkedColumnarLiveStorage.stageRows: only 'time' keys are stageable (got '${this.#keyKind}')`);
+        }
+        const k = indices.length;
+        if (k === 0)
+            return;
+        const valueNames = this.#valueNames;
+        for (let j = 0; j < k; j += 1) {
+            const i = indices[j];
+            const row = [store.beginAt(i)];
+            for (let v = 0; v < valueNames.length; v += 1) {
+                row.push(store.valueAt(i, valueNames[v]));
+            }
+            this.#pending.push(row);
+        }
+        if (this.#pending.length >= this.#flushThreshold)
+            this.#flushPending();
+    }
+    /**
+     * Compact the pending tier into one packed chunk. Rows are trusted
+     * (gathered from a validated source store), but reusing
+     * `validateAndNormalizeColumnar` is fine — it runs once per
+     * `#flushThreshold` rows (amortized O(N)), and avoids re-implementing
+     * per-kind column + validity construction.
+     */
+    #flushPending() {
+        if (this.#pending.length === 0)
+            return;
+        const { keys, columns } = validateAndNormalizeColumnar({
+            name: 'live-chunk',
+            schema: this.#schema,
+            rows: this.#pending,
+        });
+        this.#chunks.push(ColumnarStore.fromTrustedStore(this.#schema, keys, columns));
+        this.#committed += this.#pending.length;
+        this.#pending = [];
     }
-    /** Locate logical index `i` as `[chunkIndex, localIndex]`, or null if out of range. */
+    /**
+     * Locate a COMMITTED logical index `i` as `[chunkIndex, localIndex]`,
+     * or null if out of the committed range. Pending-tier indices
+     * (`i >= #committed`) are handled by the callers, not here.
+     */
     #locate(i) {
-        if (i < 0 || i >= this.#total)
+        if (i < 0 || i >= this.#committed)
             return null;
         let acc = 0;
         for (let c = 0; c < this.#chunks.length; c += 1) {
@@ -140,33 +256,44 @@ export class ChunkedColumnarLiveStorage {
         return null; // unreachable given the range guard
     }
     at(index) {
-        const loc = this.#locate(index);
-        if (loc === null)
+        if (index < 0 || index >= this.length)
             return undefined;
         let event = this.#cache.get(index);
         if (event === undefined) {
-            event = this.#materializeAt(loc[0], loc[1]);
+            if (index < this.#committed) {
+                const loc = this.#locate(index);
+                event = this.#materializeAt(loc[0], loc[1]);
+            }
+            else {
+                event = this.#materializePending(index - this.#committed);
+            }
             this.#cache.set(index, event);
         }
         return event;
     }
     keyAt(index) {
-        const loc = this.#locate(index);
-        if (loc === null)
+        if (index < 0 || index >= this.length)
             return undefined;
         const cached = this.#cache.get(index);
         if (cached !== undefined)
             return cached.key();
-        return this.#keyAt(loc[0], loc[1]);
+        if (index < this.#committed) {
+            const loc = this.#locate(index);
+            return this.#keyAt(loc[0], loc[1]);
+        }
+        return new Time(this.#pending[index - this.#committed][0]);
     }
     beginAt(index) {
-        const loc = this.#locate(index);
-        if (loc === null)
+        if (index < 0 || index >= this.length)
             return undefined;
-        return this.#chunks[loc[0]].beginAt(loc[1]);
+        if (index < this.#committed) {
+            const loc = this.#locate(index);
+            return this.#chunks[loc[0]].beginAt(loc[1]);
+        }
+        return this.#pending[index - this.#committed][0];
     }
     last() {
-        return this.at(this.#total - 1);
+        return this.at(this.length - 1);
     }
     evictPrefix(n) {
         if (n <= 0)
@@ -185,24 +312,24 @@ export class ChunkedColumnarLiveStorage {
         this.#shiftCacheBy(n);
     }
     clear() {
-        const len = this.#total;
+        const len = this.length;
         if (len === 0)
             return [];
         const all = new Array(len);
         for (let i = 0; i < len; i += 1)
             all[i] = this.at(i);
         this.#chunks = [];
-        this.#total = 0;
+        this.#committed = 0;
+        this.#pending = [];
         this.#cache.clear();
         return all;
     }
     snapshot(name) {
-        // Walk chunks in order, materializing rows. (A columnar fast-path
-        // snapshot — concatSorted(chunks) → trusted TimeSeries — is a
-        // deferred follow-up; snapshot isn't the hot path. Matches the
-        // array backing's row-rebuild for now.)
+        // Walk committed chunks then the pending tier, materializing rows.
+        // (A columnar fast-path snapshot — concatSorted(chunks) → trusted
+        // TimeSeries — is a deferred follow-up; snapshot isn't the hot path.)
         const schema = this.#schema;
-        const rows = new Array(this.#total);
+        const rows = new Array(this.length);
         let r = 0;
         for (let c = 0; c < this.#chunks.length; c += 1) {
             const store = this.#chunks[c];
@@ -215,25 +342,37 @@ export class ChunkedColumnarLiveStorage {
                 r += 1;
             }
         }
+        for (let p = 0; p < this.#pending.length; p += 1) {
+            const pr = this.#pending[p];
+            rows[r] = [new Time(pr[0]), ...pr.slice(1)];
+            r += 1;
+        }
         return new TimeSeries({ name, schema, rows: rows });
     }
-    /** Drop exactly the oldest `n` rows: whole chunks then a boundary slice. */
+    /**
+     * Drop exactly the oldest `n` rows: whole committed chunks, then a
+     * boundary slice, then the pending tier (only reached when the
+     * retention window is smaller than the pending tail — tiny windows).
+     */
     #evictExact(n) {
         let toEvict = n;
         while (toEvict > 0 && this.#chunks.length > 0) {
             const c0 = this.#chunks[0];
             if (c0.length <= toEvict) {
                 toEvict -= c0.length;
-                this.#total -= c0.length;
+                this.#committed -= c0.length;
                 this.#chunks.shift();
             }
             else {
                 // Partial: slice the oldest `toEvict` rows off the boundary chunk.
                 this.#chunks[0] = sliceStore(c0, toEvict, c0.length);
-                this.#total -= toEvict;
+                this.#committed -= toEvict;
                 toEvict = 0;
             }
         }
+        if (toEvict > 0 && this.#pending.length > 0) {
+            this.#pending.splice(0, Math.min(toEvict, this.#pending.length));
+        }
     }
     /** Remap the cache after evicting `n` head rows: drop `<n`, shift the rest down. */
     #shiftCacheBy(n) {
@@ -257,6 +396,16 @@ export class ChunkedColumnarLiveStorage {
             end: store.endAt(localIdx),
         });
     }
+    /** Materialize an Event from a pending-tier row tuple (time-keyed). */
+    #materializePending(p) {
+        const row = this.#pending[p];
+        const key = new Time(row[0]);
+        const data = {};
+        for (let v = 0; v < this.#valueNames.length; v += 1) {
+            data[this.#valueNames[v]] = row[v + 1];
+        }
+        return new Event(key, data);
+    }
     #materializeAt(chunkIdx, localIdx) {
         const store = this.#chunks[chunkIdx];
         const begin = store.beginAt(localIdx);