pond-ts 0.42.0 → 0.44.0

package/CHANGELOG.md

@@ -8,7 +8,9 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 tag, so this file covers them all. 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.42.0...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.44.0...HEAD
+[0.44.0]: https://github.com/pjm17971/pond-ts/compare/v0.43.0...v0.44.0
+[0.43.0]: https://github.com/pjm17971/pond-ts/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/pjm17971/pond-ts/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/pjm17971/pond-ts/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/pjm17971/pond-ts/compare/v0.39.0...v0.40.0
@@ -40,6 +42,157 @@ and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.44.0] — 2026-07-11
+
+The **value-axis charts** release: cross-sectional data (a volatility smile keyed
+by strike) becomes a first-class charting surface. `ValueSeries.fromColumns` is
+the direct columnar door; `<ScatterChart>` and `<BoxPlot>` join `<LineChart>` on
+the value axis; `<BoxPlot>` gains range-only (bid→ask) marks, `offset` pairing,
+and `capWidth`; and the region cursor works on value axes and snaps to histogram
+bins.
+
+### Added
+
+- **`<BoxPlot>` finished for the value axis + range-only marks** (`@pond-ts/charts`).
+  Four coordinated changes, driven by the volatility smile's per-strike bid/ask IV
+  segments (`docs/notes/vol-smile-followups-2026-07.md` §1):
+  - **Accepts a `ValueSeries`** (`series.byValue('strike')` /
+    `ValueSeries.fromColumns`) — boxes on a value axis, the same instanceof branch
+    as `<LineChart>` / `<ScatterChart>`. The box **width** now comes from neighbour
+    spacing for a **point** key (a `ValueSeries`, or a point-keyed `TimeSeries`) —
+    like bars/candles — instead of collapsing to the 1px floor; an interval-keyed
+    `TimeSeries` still uses its `[begin, end)`.
+  - **Optional `q1`/`median`/`q3`** — omit `q1`+`q3` for a **range-only** box: a
+    whisker-only `lower→upper` segment, no body (a bid→ask IV mark honestly named,
+    not a candlestick abuse). Omitting exactly one of `q1`/`q3` throws.
+  - **`offset` prop** (`<BoxPlot>` and `<ScatterChart>`) — a **pixel** shift for
+    pairing same-key marks (call/put at one strike) side by side, zoom-stable. On
+    the scatter it moves the draw **and** the click hit-test together; on the box
+    the readout hit-tests in un-shifted data space (keep the offset small).
+  - **`capWidth` prop** (`<BoxPlot>`) — the whisker end-cap width in **pixels**
+    (else half the box width). A small fixed cap keeps two `offset`-paired marks'
+    T-bars from overlapping when the value-axis slot is wide; clamped to the box
+    width, `'whisker'` shape only.
+  - **Readout labels** carry the series' `as` identity (`iv upper`, `iv median`)
+    when set, instead of bare column names — the `as ?? column` convention
+    Line/Scatter already use.
+- **`<ScatterChart>` accepts a `ValueSeries`** (`@pond-ts/charts`) — scatter
+  marks on the value axis, the same instanceof-branched adapter as
+  `<LineChart>` (the container infers the x kind from the data). The
+  data-driven `radius` / `color` encodings work unchanged on a value axis;
+  the per-point `label` reads through a new columnar branch (a `ValueSeries`
+  has no per-row events) — IV marks keyed by strike with open-interest
+  radius is the driving composition (vol smile). New value-axis Storybook
+  fan-out (`ValueAxis` / `ValueAxisEncoded` / `ValueAxisSmile` /
+  `ValueAxisFlag`) + Linux visual baselines.
+
+- **`ValueSeries.fromColumns({ name, schema, columns, sort? })`** (`pond-ts`) —
+  the direct columnar door into value-land, for data that is _natively_
+  value-keyed (cross-sectional): an options chain keyed by strike, a spectrum
+  keyed by frequency. Exact `TimeSeries.fromColumns` contract with the axis in
+  place of time — same polymorphic `number[]` / `Float64Array` inputs, same
+  zero-copy adoption, same stable opt-in `sort`, same gap rule — the two doors
+  share one ingest engine. Previously cross-sectional callers had to launder
+  the axis through a fake `time` column (`TimeSeries.fromColumns` +
+  `byValue`); that detour is no longer needed.
+
+- **The region cursor snaps to a histogram's bins** (`@pond-ts/charts`). On a
+  `<BarChart>` histogram, `cursor="region"` now snaps **bar by bar** with no
+  `cursorSequence`: hovering highlights the bar under the pointer, a drag extends
+  across whole bars, and `onRegionSelect` reports the selected bin range
+  `[lo, hi]` at the bar edges. The bar layer publishes its `[begin, end)` spans
+  (a new internal `binIntervals` channel) as the region cursor's snap buckets —
+  the same machinery a `cursorSequence` drives on a time axis, so it also covers a
+  time-axis histogram. Only a **vertical** bar layer on a continuous (time /
+  value) x axis publishes bins; a horizontal chart (value on x) and a categorical
+  axis stay freeform / excluded. An explicit `cursorSequence` still takes
+  precedence. New `HistogramBins` region-cursor story.
+
+### Changed
+
+- **BREAKING (`@pond-ts/charts`): the region cursor works on a value x-axis, and
+  `onRegionSelect` reports a neutral `[lo, hi]` pair.** The drag-select callback
+  fired a `TimeRange`; it now fires `readonly [number, number]` in **axis units** —
+  epoch ms on a time axis, the axis value (strike, distance, …) on a value axis —
+  mirroring the container's polymorphic `range` input (which never takes the axis
+  _kind_ from its value). A time-axis consumer that wants a `TimeRange` builds one
+  from the pair (`new TimeRange({ start: lo, end: hi })`). The cursor itself is
+  ungated from time-only to any **continuous** x-axis (time **or** value; a
+  **category** axis stays excluded — an ordinal-slot select is a different gesture).
+  Bucket **snapping** stays time-only (a `cursorSequence` bucket is a time
+  interval), so a value axis is always **freeform** (hover line + raw-span drag).
+
+## [0.43.0] — 2026-07-11
+
+The **categorical x-axis** release: a first-class ordinal band scale (ticker /
+account / expiry on x — the transpose view of a time series), plus the charts
+**interaction** wave that landed after v0.42.0 was cut — the region cursor and
+its drag-to-select gesture, per-bin band colour, and annotation edges that snap
+to session boundaries.
+
+### Added
+
+- **`@pond-ts/charts`: a first-class categorical x-axis.** `<BarChart
+categories={[{ label, value }]}>` draws one bar per category on an ordinal
+  **band scale** (the transpose view's "columns on x" — ticker / account / zone
+  on x). The container infers `xKind:'category'` and builds a `scaleBand` over the
+  labels; `<CategoryAxis>` ticks once per category. Colour per category via
+  `binColors`; selection reports the category name. **Negative** category values
+  draw below the baseline (the P&L / delta case) — a single-series category bar
+  honours its sign. New exports `scaleBand` / `ScaleBand`, `CategoryAxis`,
+  `categoryStack` / `CategoryDatum`. Additive — a new x-kind alongside time /
+  value; existing charts are unchanged. First slice of the categorical-axis RFC
+  (`docs/rfcs/categorical-axis.md`, Phase 1).
+- **`@pond-ts/charts`: `transposeRow`** — read one **row** of a wide `TimeSeries`
+  **across** into `{ label, value }[]` for `<BarChart categories>`: the schema's
+  numeric columns (a `pivotByGroup` output's per-group columns, a term
+  structure's per-expiry columns) become the categories at one instant. Pick the
+  row with `at` (`'last'` — the head/live row — by default; `'first'`, an index,
+  or `{ time }`); bound / order the set with `columns`.
+- **`@pond-ts/charts`: stable per-column selection identity.** `SelectInfo` gains
+  an optional **`mark`** — a stable per-mark identity within a layer. A categorical
+  bar reports its **column name** as `mark`, and a controlled `selected` echo /
+  the highlight match key on `(id, mark)`, so a pinned selection survives a column
+  reorder (the slot index doesn't; the name does). Additive — `mark` is
+  `undefined` for a time / value bar (whose sample `key` is already its identity).
+  Plus a category-axis **label policy**: a dense axis thins (keeps every k-th) and
+  ellipsis-truncates its labels so they stay legible while every bar draws.
+- **`@pond-ts/charts`: region cursor (`cursor="region"`).** A shaded **band**
+  highlights the bucket under the pointer, bucketed by a new **`cursorSequence`**
+  prop — a `Sequence` (`Sequence.every('15m')`, `Sequence.calendar('week')`)
+  realized over the view, or a `BoundedSequence` (a `TradingCalendar`'s
+  `sessionSequence()` / `barSequence()`) used as-is. The band maps through the x
+  scale, so on a trading-time axis the closed part of a bucket collapses (crops
+  to live sessions). Time-axis only (a no-op on a value axis). (#409, #413)
+- **`@pond-ts/charts`: draggable region cursor → one-shot select.** Opt-in
+  **`onRegionSelect?: (range: TimeRange) => void`** makes the region cursor
+  draggable: the band extends bucket by bucket and fires **once** on release
+  with the selected `[start, end)` `TimeRange` (the cursor doesn't keep it —
+  typical use is to zoom the view). With **no `cursorSequence`** it degenerates
+  to a hover **line** + **freeform** drag. **`regionSelectModifier="shift"`**
+  resolves the gesture conflict with `panZoom` (plain drag pans, shift-drag
+  selects); omitted, a region-drag preempts pan. (#416)
+- **`@pond-ts/charts`: `binColors` — per-bin colour for single-series bars.**
+  `<BarChart binColors={[...]}>` colours each bar/band segment individually (one
+  colour per bin, in order), the single-series analog of the stacked `colors`
+  prop — used by the category axis (colour per category) and any single-series
+  band chart. (#408)
+- **`@pond-ts/charts`: annotation edges snap to session boundaries.** When a
+  `<ChartContainer>` carries a trading calendar (disjoint x axis), dragging a
+  `<Region>` edge (or creating one) snaps to the nearest **session boundary**
+  rather than raw wall-clock, so a drawn span aligns with real market sessions.
+  (#410)
+
+### Fixed
+
+- **`@pond-ts/charts`: region body-move no longer distorts across a session
+  boundary.** On a trading-time (discontinuous) axis, dragging a `<Region>`
+  annotation by its body now translates it rigidly in pixel space, so the box
+  keeps its width as it crosses a collapsed gap (it previously applied one
+  value-delta to both edges, which stretched the box in the different
+  rate-contexts either side of a session boundary). No-op on a continuous axis.
+  (#405)
+
 ## [0.42.0] — 2026-07-10
 
 The **trading-calendar** release: a new `@pond-ts/financial` package (its first
@@ -82,6 +235,16 @@ collapses closed-market time (weekends, holidays, overnight, lunch breaks).
     (`theme.axis.sessionDivider`), aligned with the labels.
   - `Charts/TradingTimeAxis` stories (weekend/holiday/half-day/intraday,
     continuous-vs-trading, daily-months, proportional-vs-uniform).
+- **`@pond-ts/charts`: first-class histograms.** `<BarChart>` gains **stacking**
+  — a group-by dimension → stacked segments, from a wide series (`columns`), a
+  `Map<group, TimeSeries>` (the `partitionBy().aggregate().toMap()` shape), or a
+  `byColumn` `bins` array; per-group colour via `colors` or theme roles — and an
+  **`orientation`** prop (`'vertical'` default | `'horizontal'`, bars grow right
+  with the bins on a y band axis). New readers `stacksFromGroups` /
+  `stacksFromColumns` / `stacksFromBins` plus `StackedBarSeries` / `BinRecord` /
+  `Orientation` types. All data generation composes from existing operators
+  (`aggregate` / `byColumn` / `partitionBy`); no core changes. Guide: How-to
+  guides → Histograms. (#401)
 - **`@pond-ts/charts`:** selection now has a stable series identity. `SelectInfo`
   carries an `id`, and `BarChart` / `ScatterChart` take an optional `id` prop —
   the series identity used for selection + hover. An `id` **gates interactivity**:

package/dist/batch/operators/ingest-columns.d.ts

@@ -0,0 +1,33 @@
+import { ColumnarStore, type ColumnSchema, type KeyColumn } from '../../columnar/index.js';
+/** The per-column raw input the `fromColumns` doors accept. */
+export type RawColumns = Record<string, ReadonlyArray<number | null | undefined> | Float64Array>;
+/**
+ * The shared columnar-ingress engine behind `TimeSeries.fromColumns` and
+ * `ValueSeries.fromColumns`. Both doors are the same machine — normalize the
+ * key column (adopt a `Float64Array` zero-copy, convert a `number[]`),
+ * optionally sort by key (stable permutation, disables adoption), enforce the
+ * non-decreasing-key invariant, pack each `'number'` value column
+ * (`null`/`undefined` → `NaN`, one gap rule for both input types) — and differ
+ * only in the key column they mint (`TimeKeyColumn` vs `ValueKeyColumn`) and
+ * the words their errors use. `op` prefixes every message (so a throw names
+ * the door the caller went through) and `keyNoun` names the key in the
+ * out-of-order error (`timestamps` / `axis values`).
+ *
+ * `makeKey` runs **before** the ordering scan, matching the original inline
+ * order of checks: a non-finite key fails in the key-column constructor first,
+ * ordering second. The per-element loops are the measured hot path
+ * (`scripts/perf-from-columns.mjs`) — moved here verbatim, including the
+ * manual copy loops (see the inline notes on why not `Float64Array.from`).
+ *
+ * The caller owns what stays door-specific: the schema[0] kind gate (with its
+ * own message) and wrapping the returned store in its series type.
+ */
+export declare function ingestColumnsToStore(input: {
+    op: string;
+    keyNoun: string;
+    schema: ColumnSchema;
+    columns: RawColumns;
+    sort: boolean;
+    makeKey: (begin: Float64Array, count: number) => KeyColumn;
+}): ColumnarStore<ColumnSchema>;
+//# sourceMappingURL=ingest-columns.d.ts.map

package/dist/batch/operators/ingest-columns.js

@@ -0,0 +1,146 @@
+import { ColumnarStore, Float64Column, validityFromPredicate, } from '../../columnar/index.js';
+import { ValidationError } from '../../core/errors.js';
+/**
+ * The shared columnar-ingress engine behind `TimeSeries.fromColumns` and
+ * `ValueSeries.fromColumns`. Both doors are the same machine — normalize the
+ * key column (adopt a `Float64Array` zero-copy, convert a `number[]`),
+ * optionally sort by key (stable permutation, disables adoption), enforce the
+ * non-decreasing-key invariant, pack each `'number'` value column
+ * (`null`/`undefined` → `NaN`, one gap rule for both input types) — and differ
+ * only in the key column they mint (`TimeKeyColumn` vs `ValueKeyColumn`) and
+ * the words their errors use. `op` prefixes every message (so a throw names
+ * the door the caller went through) and `keyNoun` names the key in the
+ * out-of-order error (`timestamps` / `axis values`).
+ *
+ * `makeKey` runs **before** the ordering scan, matching the original inline
+ * order of checks: a non-finite key fails in the key-column constructor first,
+ * ordering second. The per-element loops are the measured hot path
+ * (`scripts/perf-from-columns.mjs`) — moved here verbatim, including the
+ * manual copy loops (see the inline notes on why not `Float64Array.from`).
+ *
+ * The caller owns what stays door-specific: the schema[0] kind gate (with its
+ * own message) and wrapping the returned store in its series type.
+ */
+export function ingestColumnsToStore(input) {
+    const { op, keyNoun, schema, columns, sort, makeKey } = input;
+    const keyDef = schema[0];
+    if (keyDef === undefined) {
+        throw new ValidationError(`${op}: schema must have at least a key column`);
+    }
+    const keyRaw = columns[keyDef.name];
+    if (keyRaw === undefined) {
+        throw new ValidationError(`${op}: missing key column '${keyDef.name}'`);
+    }
+    // Key buffer; the key-column constructor asserts all finite. A manual loop,
+    // not `Float64Array.from(arr, mapFn)`: supplying a map function forces V8's
+    // generic iterable-protocol path even for a plain array, ~15-20x slower
+    // than a preallocated-buffer copy at 100k-element scale — measured, not
+    // theoretical (see the pond-columnar-ingest spike's ingest regression).
+    let rawBegin;
+    if (keyRaw instanceof Float64Array) {
+        rawBegin = keyRaw;
+    }
+    else {
+        rawBegin = new Float64Array(keyRaw.length);
+        for (let j = 0; j < keyRaw.length; j += 1) {
+            const v = keyRaw[j];
+            rawBegin[j] = v == null ? NaN : Number(v);
+        }
+    }
+    const count = rawBegin.length;
+    // `sort: true` — reorder every column by ascending key before construction.
+    // Compute the row permutation once (a stable sort of the index array; V8's
+    // Array.sort is stable, so equal keys keep input order, matching fromJSON's
+    // stable intake), then remap the key + each value column through it below.
+    // `order` stays null on the (default) trusted fast path, so no allocation /
+    // copy is paid unless asked. A non-finite key is left for the key column's
+    // constructor to reject — sorting can't make it valid.
+    let begin;
+    let order = null;
+    if (sort) {
+        const idx = Array.from({ length: count }, (_, i) => i);
+        idx.sort((a, b) => rawBegin[a] - rawBegin[b]);
+        order = Uint32Array.from(idx);
+        begin = new Float64Array(count);
+        for (let j = 0; j < count; j += 1)
+            begin[j] = rawBegin[order[j]];
+    }
+    else {
+        begin = rawBegin;
+    }
+    // Throws on any non-finite key value.
+    const keys = makeKey(begin, count);
+    // Enforce the non-decreasing-key invariant that `fromJSON`'s
+    // `validateAndNormalize` guarantees. Trusted construction skips row
+    // materialization + kind re-validation, but NOT this correctness contract:
+    // bisect-based operators (crop, `atTime`, range queries) rely on it, so an
+    // unsorted columnar input must fail loudly here rather than build a silently
+    // broken series. One O(N) scan over already-finite values — negligible next
+    // to decode. (When `sort` is set the keys are now non-decreasing, so this is
+    // a cheap post-condition check rather than a rejection.)
+    for (let j = 1; j < count; j += 1) {
+        if (begin[j] < begin[j - 1]) {
+            throw new ValidationError(`${op}: key column '${keyDef.name}' is out of order at index ${j} ` +
+                `(${begin[j]} < ${begin[j - 1]}) — ${keyNoun} must be non-decreasing; ` +
+                `pass { sort: true } or pre-sort the columns`);
+        }
+    }
+    // Value columns — packed directly (missing-aware) from the arrays.
+    const columnMap = new Map();
+    for (let i = 1; i < schema.length; i += 1) {
+        const def = schema[i];
+        if (def.kind !== 'number') {
+            throw new ValidationError(`${op}: v1 supports 'number' value columns; column '${def.name}' is '${def.kind}'`);
+        }
+        const raw = columns[def.name];
+        if (raw === undefined) {
+            throw new ValidationError(`${op}: missing column '${def.name}'`);
+        }
+        if (raw.length !== count) {
+            throw new ValidationError(`${op}: column '${def.name}' length ${raw.length} does not match key length ${count}`);
+        }
+        // Normalize to a Float64Array either way — adopt if already typed (the
+        // fast path a protobuf / fixed-point decoder hits, zero-copy), else
+        // convert (`null`/`undefined` -> `NaN`) — then apply ONE validity rule
+        // to both: a cell is a gap iff it's non-finite. This must be identical
+        // regardless of input type: an earlier version used `float64ColumnFromArray`
+        // for the `number[]` branch, which treats a `NaN` *value* (as opposed to
+        // `null`) as defined-but-non-finite rather than missing, diverging from
+        // the `Float64Array` branch's `Number.isFinite` gap signal — the same
+        // wire value would silently mean different things depending on which
+        // array type decoded it.
+        // Manual loop, not `Float64Array.from(arr, mapFn)` — see the key-column
+        // comment above; the cost applies identically here.
+        let values;
+        if (order !== null) {
+            // Sorting: reorder into a fresh buffer through the key permutation (no
+            // zero-copy adoption — the rows are being moved). Same missing rule
+            // (`null`/`undefined` → NaN) applied while remapping.
+            values = new Float64Array(count);
+            if (raw instanceof Float64Array) {
+                for (let j = 0; j < count; j += 1)
+                    values[j] = raw[order[j]];
+            }
+            else {
+                for (let j = 0; j < count; j += 1) {
+                    const v = raw[order[j]];
+                    values[j] = v == null ? NaN : v;
+                }
+            }
+        }
+        else if (raw instanceof Float64Array) {
+            values = raw;
+        }
+        else {
+            values = new Float64Array(count);
+            for (let j = 0; j < count; j += 1) {
+                const v = raw[j];
+                values[j] = v == null ? NaN : v;
+            }
+        }
+        const validity = validityFromPredicate(count, (j) => Number.isFinite(values[j]));
+        columnMap.set(def.name, new Float64Column(values, count, validity, validity === undefined));
+    }
+    return ColumnarStore.fromTrustedStore(schema, keys, columnMap);
+}
+//# sourceMappingURL=ingest-columns.js.map

package/dist/batch/time-series.d.ts

@@ -131,9 +131,10 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * value columns throw for now — extend as consumers need.
      *
      * @throws ValidationError on a missing column, a length mismatch, an
-     *   unsupported kind, a non-finite timestamp key, or an out-of-order
-     *   (decreasing) timestamp when `sort` is not set — keys must be non-decreasing,
-     *   same as `fromJSON`.
+     *   unsupported kind, or an out-of-order (decreasing) timestamp when `sort`
+     *   is not set — keys must be non-decreasing, same as `fromJSON`. Throws
+     *   RangeError on a non-finite timestamp key (from the key-column
+     *   constructor) or a duplicate column name.
      */
     static fromColumns<S extends SeriesSchema>(input: {
         name: string;

package/dist/batch/time-series.js

@@ -2,6 +2,7 @@ import { isAggregateOutputSpec, normalizeAggregateColumns, tryAggregateColumnarT
 import { cumulativeOp, } from './operators/cumulative.js';
 import { scanOp } from './operators/scan.js';
 import { byValueOp } from './operators/by-value.js';
+import { ingestColumnsToStore } from './operators/ingest-columns.js';
 import { ValueSeries } from './value-series.js';
 import { diffRateOp } from './operators/diff-rate.js';
 import { fillOp } from './operators/fill.js';
@@ -18,7 +19,7 @@ import { TimeRange } from '../core/time-range.js';
 import { compareEventKeys } from '../core/temporal.js';
 import { PartitionedTimeSeries } from './partitioned-time-series.js';
 import { Sequence } from '../sequence/sequence.js';
-import { ColumnarStore, Float64Column, IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, float64ColumnFromArray, stringColumnFromArray, validityFromPredicate, withColumnAppended, withColumnsRenamed, withColumnsSelected, withKeyColumn, withRowRange, withRowSelection, } from '../columnar/index.js';
+import { ColumnarStore, IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, float64ColumnFromArray, stringColumnFromArray, withColumnAppended, withColumnsRenamed, withColumnsSelected, withKeyColumn, withRowRange, withRowSelection, } from '../columnar/index.js';
 import { ValidationError } from '../core/errors.js';
 import { SeriesStore } from '../live/series-store.js';
 import { parseDuration } from '../core/duration.js';
@@ -530,9 +531,10 @@ export class TimeSeries {
      * value columns throw for now — extend as consumers need.
      *
      * @throws ValidationError on a missing column, a length mismatch, an
-     *   unsupported kind, a non-finite timestamp key, or an out-of-order
-     *   (decreasing) timestamp when `sort` is not set — keys must be non-decreasing,
-     *   same as `fromJSON`.
+     *   unsupported kind, or an out-of-order (decreasing) timestamp when `sort`
+     *   is not set — keys must be non-decreasing, same as `fromJSON`. Throws
+     *   RangeError on a non-finite timestamp key (from the key-column
+     *   constructor) or a duplicate column name.
      */
     static fromColumns(input) {
         const { name, schema, columns, sort = false } = input;
@@ -544,121 +546,17 @@ export class TimeSeries {
         if (keyDef.kind !== 'time') {
             throw new ValidationError(`fromColumns: v1 supports a 'time' key; schema[0] '${keyDef.name}' is '${keyDef.kind}'`);
         }
-        const keyRaw = columns[keyDef.name];
-        if (keyRaw === undefined) {
-            throw new ValidationError(`fromColumns: missing key column '${keyDef.name}'`);
-        }
-        // epoch-ms buffer; TimeKeyColumn asserts all finite. A manual loop, not
-        // `Float64Array.from(arr, mapFn)`: supplying a map function forces V8's
-        // generic iterable-protocol path even for a plain array, ~15-20x slower
-        // than a preallocated-buffer copy at 100k-element scale — measured, not
-        // theoretical (see the pond-columnar-ingest spike's ingest regression).
-        let rawBegin;
-        if (keyRaw instanceof Float64Array) {
-            rawBegin = keyRaw;
-        }
-        else {
-            rawBegin = new Float64Array(keyRaw.length);
-            for (let j = 0; j < keyRaw.length; j += 1) {
-                const v = keyRaw[j];
-                rawBegin[j] = v == null ? NaN : Number(v);
-            }
-        }
-        const count = rawBegin.length;
-        // `sort: true` — reorder every column by ascending key before construction.
-        // Compute the row permutation once (a stable sort of the index array; V8's
-        // Array.sort is stable, so equal keys keep input order, matching fromJSON's
-        // stable intake), then remap the key + each value column through it below.
-        // `order` stays null on the (default) trusted fast path, so no allocation /
-        // copy is paid unless asked. A non-finite key is left for `TimeKeyColumn` to
-        // reject — sorting can't make it valid.
-        let begin;
-        let order = null;
-        if (sort) {
-            const idx = Array.from({ length: count }, (_, i) => i);
-            idx.sort((a, b) => rawBegin[a] - rawBegin[b]);
-            order = Uint32Array.from(idx);
-            begin = new Float64Array(count);
-            for (let j = 0; j < count; j += 1)
-                begin[j] = rawBegin[order[j]];
-        }
-        else {
-            begin = rawBegin;
-        }
-        // Throws on any non-finite timestamp.
-        const keys = new TimeKeyColumn(begin, count);
-        // Enforce the non-decreasing-key invariant that `fromJSON`'s
-        // `validateAndNormalize` guarantees. Trusted construction skips row
-        // materialization + kind re-validation, but NOT this correctness contract:
-        // bisect-based operators (crop, `atTime`, range queries) rely on it, so an
-        // unsorted columnar input must fail loudly here rather than build a silently
-        // broken series. One O(N) scan over already-finite values — negligible next
-        // to decode. (When `sort` is set the keys are now non-decreasing, so this is
-        // a cheap post-condition check rather than a rejection.)
-        for (let j = 1; j < count; j += 1) {
-            if (begin[j] < begin[j - 1]) {
-                throw new ValidationError(`fromColumns: key column '${keyDef.name}' is out of order at index ${j} ` +
-                    `(${begin[j]} < ${begin[j - 1]}) — timestamps must be non-decreasing; ` +
-                    `pass { sort: true } or pre-sort the columns`);
-            }
-        }
-        // Value columns — packed directly (missing-aware) from the arrays.
-        const columnMap = new Map();
-        for (let i = 1; i < schema.length; i += 1) {
-            const def = schema[i];
-            if (def.kind !== 'number') {
-                throw new ValidationError(`fromColumns: v1 supports 'number' value columns; column '${def.name}' is '${def.kind}'`);
-            }
-            const raw = columns[def.name];
-            if (raw === undefined) {
-                throw new ValidationError(`fromColumns: missing column '${def.name}'`);
-            }
-            if (raw.length !== count) {
-                throw new ValidationError(`fromColumns: column '${def.name}' length ${raw.length} does not match key length ${count}`);
-            }
-            // Normalize to a Float64Array either way — adopt if already typed (the
-            // fast path a protobuf / fixed-point decoder hits, zero-copy), else
-            // convert (`null`/`undefined` -> `NaN`) — then apply ONE validity rule
-            // to both: a cell is a gap iff it's non-finite. This must be identical
-            // regardless of input type: an earlier version used `float64ColumnFromArray`
-            // for the `number[]` branch, which treats a `NaN` *value* (as opposed to
-            // `null`) as defined-but-non-finite rather than missing, diverging from
-            // the `Float64Array` branch's `Number.isFinite` gap signal — the same
-            // wire value would silently mean different things depending on which
-            // array type decoded it.
-            // Manual loop, not `Float64Array.from(arr, mapFn)` — see the key-column
-            // comment above; the cost applies identically here.
-            let values;
-            if (order !== null) {
-                // Sorting: reorder into a fresh buffer through the key permutation (no
-                // zero-copy adoption — the rows are being moved). Same missing rule
-                // (`null`/`undefined` → NaN) applied while remapping.
-                values = new Float64Array(count);
-                if (raw instanceof Float64Array) {
-                    for (let j = 0; j < count; j += 1)
-                        values[j] = raw[order[j]];
-                }
-                else {
-                    for (let j = 0; j < count; j += 1) {
-                        const v = raw[order[j]];
-                        values[j] = v == null ? NaN : v;
-                    }
-                }
-            }
-            else if (raw instanceof Float64Array) {
-                values = raw;
-            }
-            else {
-                values = new Float64Array(count);
-                for (let j = 0; j < count; j += 1) {
-                    const v = raw[j];
-                    values[j] = v == null ? NaN : v;
-                }
-            }
-            const validity = validityFromPredicate(count, (j) => Number.isFinite(values[j]));
-            columnMap.set(def.name, new Float64Column(values, count, validity, validity === undefined));
-        }
-        const store = ColumnarStore.fromTrustedStore(schema, keys, columnMap);
+        // The normalize -> sort -> key -> order-check -> pack pipeline is shared
+        // with `ValueSeries.fromColumns` -- one ingest engine, two key kinds (see
+        // `operators/ingest-columns.ts`).
+        const store = ingestColumnsToStore({
+            op: 'fromColumns',
+            keyNoun: 'timestamps',
+            schema: schema,
+            columns,
+            sort,
+            makeKey: (begin, count) => new TimeKeyColumn(begin, count),
+        });
         return TimeSeries.#fromTrustedStore(name, schema, store);
     }
     /**

package/dist/batch/value-series.d.ts

@@ -3,7 +3,12 @@ import type { ValueSeriesColumnName, ValueSeriesSchema } from '../schema/index.j
 /**
  * A **value-keyed series** — the closed value-axis counterpart of
  * `TimeSeries`. Its key is a monotonic non-time axis (distance, cumulative
- * work, …) rather than time, produced by `TimeSeries.byValue(axis)`.
+ * work, …). Two doors in: **project** a `TimeSeries` onto one of its monotonic
+ * columns (`TimeSeries.byValue(axis)` — a track re-keyed by cumulative
+ * distance), or **construct directly** from columnar arrays
+ * ({@link ValueSeries.fromColumns}) when the data is natively value-keyed and
+ * never had a meaningful time key per row — cross-sectional data such as an
+ * options chain keyed by strike or a spectrum keyed by frequency.
  *
  * `ValueSeries` carries the **ordering-based** operators (read the axis, read
  * value columns, nearest-by-value, slice-by-value) — the part of the series
@@ -21,6 +26,57 @@ export declare class ValueSeries<VS extends ValueSeriesSchema> {
     #private;
     readonly name: string;
     readonly schema: VS;
+    /**
+     * Example: `ValueSeries.fromColumns({ name, schema, columns })`.
+     *
+     * The **direct columnar door** into value-land — for data that is *natively*
+     * value-keyed and never had a meaningful per-row time key: an options chain
+     * keyed by strike, a spectrum keyed by frequency, a profile keyed by depth.
+     * (Data that starts life time-keyed projects in via `TimeSeries.byValue`
+     * instead; before this door existed, cross-sectional callers had to launder
+     * their axis through a fake `time` column just to reach
+     * `TimeSeries.fromColumns` + `byValue`.)
+     *
+     * The exact `TimeSeries.fromColumns` contract, with the axis in place of
+     * time — the two doors share one ingest engine. `schema[0]` is the
+     * `'value'`-kind **axis** column; each `columns` entry is one column's
+     * values, keyed by schema column name and aligned by index. Values may be a
+     * plain `number[]` **or** a `Float64Array`; a value cell is a gap (missing)
+     * iff it's `null`/`undefined` or non-finite — identical rule for both input
+     * types.
+     *
+     * **`Float64Array` inputs are adopted, not copied** (zero-copy): the
+     * resulting series' columns alias the caller's buffers; pass a fresh buffer
+     * if that matters. (**`sort` disables the adoption** — a reorder needs its
+     * own buffers.)
+     *
+     * **Ordering.** The axis must be **defined, finite, and non-decreasing** —
+     * it becomes the index (the same contract `byValue` enforces with
+     * `assertMonotonicAxis`), so an out-of-order axis throws by default. Pass
+     * **`sort: true`** to sort the rows by axis value before construction — the
+     * stable sort every unordered snapshot wants (e.g. a keyed live feed that
+     * delivers rows in update order, not axis order).
+     *
+     * **v1 scope:** `number` value columns, matching `TimeSeries.fromColumns`.
+     *
+     * @throws ValidationError on a non-`'value'` axis kind, a missing column, a
+     *   length mismatch, a non-`'number'` value column, or an out-of-order axis
+     *   when `sort` is not set. Throws RangeError on a non-finite
+     *   (`null`/`NaN`/`±Infinity`) axis cell — sorting can't make it valid — or
+     *   a duplicate column name (the axis name repeated among the value columns).
+     */
+    static fromColumns<VS extends ValueSeriesSchema>(input: {
+        name: string;
+        schema: VS;
+        columns: Record<string, ReadonlyArray<number | null | undefined> | Float64Array>;
+        /**
+         * Sort the rows by axis value before construction (off by default), for a
+         * payload whose rows aren't guaranteed ordered. Stable; disables the
+         * `Float64Array` zero-copy adoption (columns are reordered into fresh
+         * buffers).
+         */
+        sort?: boolean;
+    }): ValueSeries<VS>;
     private constructor();
     /** Number of rows. */
     get length(): number;

package/dist/batch/value-series.js

@@ -1,8 +1,15 @@
-import { withRowRange, } from '../columnar/index.js';
+import { ValueKeyColumn, withRowRange, } from '../columnar/index.js';
+import { ValidationError } from '../core/errors.js';
+import { ingestColumnsToStore } from './operators/ingest-columns.js';
 /**
  * A **value-keyed series** — the closed value-axis counterpart of
  * `TimeSeries`. Its key is a monotonic non-time axis (distance, cumulative
- * work, …) rather than time, produced by `TimeSeries.byValue(axis)`.
+ * work, …). Two doors in: **project** a `TimeSeries` onto one of its monotonic
+ * columns (`TimeSeries.byValue(axis)` — a track re-keyed by cumulative
+ * distance), or **construct directly** from columnar arrays
+ * ({@link ValueSeries.fromColumns}) when the data is natively value-keyed and
+ * never had a meaningful time key per row — cross-sectional data such as an
+ * options chain keyed by strike or a spectrum keyed by frequency.
  *
  * `ValueSeries` carries the **ordering-based** operators (read the axis, read
  * value columns, nearest-by-value, slice-by-value) — the part of the series
@@ -23,11 +30,70 @@ export class ValueSeries {
     /**
      * @internal Trusted construction — `store` must be value-keyed and structurally
      * match `schema` (the invariant `TimeSeries.byValue` / `byValueOp` establish).
-     * Not for general use; construct a `ValueSeries` via `TimeSeries.byValue`.
+     * Not for general use; construct a `ValueSeries` via `TimeSeries.byValue` or
+     * {@link ValueSeries.fromColumns}.
      */
     static fromTrustedStore(name, schema, store) {
         return new ValueSeries(name, schema, store);
     }
+    /**
+     * Example: `ValueSeries.fromColumns({ name, schema, columns })`.
+     *
+     * The **direct columnar door** into value-land — for data that is *natively*
+     * value-keyed and never had a meaningful per-row time key: an options chain
+     * keyed by strike, a spectrum keyed by frequency, a profile keyed by depth.
+     * (Data that starts life time-keyed projects in via `TimeSeries.byValue`
+     * instead; before this door existed, cross-sectional callers had to launder
+     * their axis through a fake `time` column just to reach
+     * `TimeSeries.fromColumns` + `byValue`.)
+     *
+     * The exact `TimeSeries.fromColumns` contract, with the axis in place of
+     * time — the two doors share one ingest engine. `schema[0]` is the
+     * `'value'`-kind **axis** column; each `columns` entry is one column's
+     * values, keyed by schema column name and aligned by index. Values may be a
+     * plain `number[]` **or** a `Float64Array`; a value cell is a gap (missing)
+     * iff it's `null`/`undefined` or non-finite — identical rule for both input
+     * types.
+     *
+     * **`Float64Array` inputs are adopted, not copied** (zero-copy): the
+     * resulting series' columns alias the caller's buffers; pass a fresh buffer
+     * if that matters. (**`sort` disables the adoption** — a reorder needs its
+     * own buffers.)
+     *
+     * **Ordering.** The axis must be **defined, finite, and non-decreasing** —
+     * it becomes the index (the same contract `byValue` enforces with
+     * `assertMonotonicAxis`), so an out-of-order axis throws by default. Pass
+     * **`sort: true`** to sort the rows by axis value before construction — the
+     * stable sort every unordered snapshot wants (e.g. a keyed live feed that
+     * delivers rows in update order, not axis order).
+     *
+     * **v1 scope:** `number` value columns, matching `TimeSeries.fromColumns`.
+     *
+     * @throws ValidationError on a non-`'value'` axis kind, a missing column, a
+     *   length mismatch, a non-`'number'` value column, or an out-of-order axis
+     *   when `sort` is not set. Throws RangeError on a non-finite
+     *   (`null`/`NaN`/`±Infinity`) axis cell — sorting can't make it valid — or
+     *   a duplicate column name (the axis name repeated among the value columns).
+     */
+    static fromColumns(input) {
+        const { name, schema, columns, sort = false } = input;
+        const keyDef = schema[0];
+        if (keyDef === undefined) {
+            throw new ValidationError('ValueSeries.fromColumns: schema must have at least an axis column');
+        }
+        if (keyDef.kind !== 'value') {
+            throw new ValidationError(`ValueSeries.fromColumns: schema[0] '${keyDef.name}' must be the 'value'-kind axis column; got '${keyDef.kind}'`);
+        }
+        const store = ingestColumnsToStore({
+            op: 'ValueSeries.fromColumns',
+            keyNoun: 'axis values',
+            schema: schema,
+            columns,
+            sort,
+            makeKey: (begin, count) => new ValueKeyColumn(begin, count),
+        });
+        return new ValueSeries(name, schema, store);
+    }
     constructor(name, schema, store) {
         this.name = name;
         this.schema = Object.freeze(schema.slice());

package/package.json

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