pond-ts 0.44.1 → 0.46.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.44.1...HEAD
+[Unreleased]: https://github.com/pjm17971/pond-ts/compare/v0.46.0...HEAD
+[0.46.0]: https://github.com/pjm17971/pond-ts/compare/v0.45.0...v0.46.0
+[0.45.0]: https://github.com/pjm17971/pond-ts/compare/v0.44.1...v0.45.0
 [0.44.1]: https://github.com/pjm17971/pond-ts/compare/v0.44.0...v0.44.1
 [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
@@ -43,6 +45,146 @@ and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.46.0] — 2026-07-14
+
+### Changed
+
+- **charts:** the boundary (second-row) axis label's **context** now pins to
+  the plot's left edge instead of riding the first tick: it shows the period
+  the *domain start* is in, and a crossing label sliding toward the edge
+  pushes it off (the sticky-header behavior). On a live sliding window the
+  old first-tick anchoring made `Jan 01` hop tick-to-tick as ticks scrolled
+  out; pinned, it stays put until the period actually changes. Crossing
+  labels (day/year turns) still ride their ticks — including a first tick
+  whose period differs from the domain start's. `TradingTimeScale` gains
+  `boundaryContext(count)`; `tickBoundaries` now labels crossings only.
+
+### Fixed
+
+- **charts:** a live (sliding-window) time axis no longer flickers between two
+  tick grains: the clock-rung choice now derives from the window's live span
+  (constant while sliding) instead of the enumerated anchor count, which
+  oscillates ±1 with the window's phase and flipped the grain for single
+  frames whenever it sat exactly at the width-derived cap.
+
+### Added
+
+- **charts:** **dual x-axes** — two tick layouts on one shared scale. A second
+  `<XAxis>` stacks by declaration order (above/below the plot, either side,
+  same side twice); the new **`transform`** prop (`{ to, from }`, exported
+  `AxisTransform`) relabels an axis into a derived unit: strike ↔ moneyness on
+  a top axis, or a nonlinear BS-delta strip under a std-moneyness chart. Ticks
+  are nice derived-unit values chosen by a pixel-aware multi-resolution fill
+  (1-2-5 steps, coarsest first, admitted where they keep room), so a span the
+  transform compresses gets coarse ticks and a stretched span picks up finer
+  ones — and a label-honesty filter drops any tick whose formatted label would
+  lie about its position. Gridlines stay on the container's primary ticks; the
+  cursor pill on a transformed axis reads in the derived unit. Stories under
+  `Charts/Axes/DualX`. Each `<XAxis>` **and `<YAxis>`** also takes a
+  per-instance **`color`** (labels, tick marks, rule, title) — the lever that
+  distinguishes stacked x strips (a blue delta strip under a grey primary) and
+  colours a y axis to match its series (the dual-axis convention).
+
+### Fixed
+
+- **charts:** annotation label chips now clip to the plot: a marker whose pole
+  pans off-plot no longer leaves its chip floating in the axis gutter, and a
+  partially visible region's chip clamps to the plot's left edge (culled only
+  when the region is entirely out of view). The lines/fills were already
+  SVG-clipped — only the DOM chips escaped.
+
+## [0.45.0] — 2026-07-14
+
+### Added
+
+- **charts:** the time axis now walks a **logical tick ladder** — clock/calendar
+  units (1s…30s, 1m…30m, 1H…12H, day / week / month / quarter / year), picking
+  the finest grain that fits the width-derived cap — and renders **two-tier labels**:
+  a first row at the tick grain (`14:00`, `Feb 02`, `Feb`, `2026`) plus a
+  **boundary row** carrying the coarser context the first row omits (the date
+  under clock ticks, the year under day/week/month ticks — never a unit the
+  first row already shows), shown once under
+  the first tick of each new period. Hour anchors are generated in **live**
+  trading time, so none lands in a collapsed gap, an early close, or a lunch
+  break. `TradingTimeScale` gains `tickBoundaries(count)`; a cramped leading
+  partial-period anchor (the `"Jun 23Jul 07"` pile-up) is dropped. Systematic
+  story matrix under `Charts/TimeAxisTicks`.
+- **financial:** the rest of the first study batch — `rollingStdev`,
+  `rollingMin`, `rollingMax`, `rollingPercentile` (linear interpolation),
+  `zScore` (rolling), `envelope` (MA ± percent, `maType` sma/ema), and
+  `percentChange` (n-bar rate of change). Same shape as the others — `column` /
+  `output` (or `prefix`) on every one, bar-count periods, length-preserving
+  warm-up — and each has a fluent method (`bars.zScore({ period: 20 })`) and a
+  **pandas oracle** case (values cross-validated bar-for-bar). This completes the
+  #449 first batch.
+- **financial:** opt-in **fluent studies** via `import '@pond-ts/financial/fluent'`
+  — mounts `sma` / `ema` / `bollinger` as chainable `TimeSeries` methods so
+  composition reads like the core operators beside it:
+  `bars.sma({ period: 20 }).ema({ period: 12 }).bollinger({ period: 20 })`.
+  Opt-in by import (the default entry leaves `TimeSeries` untouched, so a
+  non-financial series never sees `.sma()`); the methods are exactly the
+  standalone functions bound to `this`, fully typed (each appends its column to
+  the schema). Same prototype-augmentation pattern core uses for column methods.
+- **financial:** `@pond-ts/financial` gains its first **studies** — `sma`, `ema`,
+  and `bollinger` (Bollinger Bands®) — pure functions that append a column (or a
+  `${prefix}Middle/Upper/Lower` family) to a bar series. Every study takes a
+  `column` source (default `'close'`) and an `output` name, so a study runs over
+  any numeric column including another study's output; periods are **bar counts**
+  (on core's count window, gap-correct); warm-up rows are `undefined`
+  (length-preserving). Plus the `OhlcvColumns` contract + `DEFAULT_OHLCV`. (Core
+  `AppendColumn` is now exported so study return types name their appended
+  column.)
+- **core:** `smooth(col, 'ema', …)` gains the financial **`span`** rate
+  convention (`α = 2/(span+1)`, e.g. `{ span: 12 }` for a 12-period EMA) as an
+  alternative to `alpha` (exactly one required), and a length-preserving
+  **`minSamples`** warm-up that emits `undefined` for the first `N` present
+  values while **keeping the row count** — mirroring `rolling`'s `minSamples`,
+  the one warm-up convention studies use so a smoothed line aligns on its
+  source's time axis. (The existing `warmup` option is unchanged — it still
+  *drops* the head rows; `minSamples` is the length-preserving counterpart.)
+- **core:** `TimeSeries.rolling` accepts a **count-based** window —
+  `rolling({ count: N }, mapping, opts?)` reduces the last / next / centered
+  `N` _rows_ (bars) by position instead of a time span. Unlike a duration
+  window, an N-bar window stays correct across session gaps (weekends,
+  overnight) where `N` bars do not equal `N × barSize` of time — the load-
+  bearing primitive for financial N-bar studies (SMA-20, Bollinger-20, rolling
+  stdev). Honours `alignment` and `minSamples` exactly like a duration window
+  (`minSamples: N` gives the conventional first-`N-1`-rows-`undefined` warmup);
+  per-row output only (not supported with a sequence). Same amortized-O(1)-per-
+  row sweep as the duration path.
+- **charts:** `<LineChart sessionBreaks>` breaks the line at each trading-axis
+  discontinuity (a session / day / lunch close→open) instead of connecting the
+  prior close straight to the next open across the collapsed gap. For intraday
+  data on a `discontinuities` / `calendar` axis this gives the terminal look —
+  the line ends at the close and re-starts at the open, so one session's price
+  doesn't visually flow into the next. It's a **scale** break (driven by the
+  axis's collapsed gaps), orthogonal to `gaps` (a **data** break, a NaN run) —
+  set both independently. Default `false`; a no-op on a continuous axis or a
+  provider without `boundaries`. New `Charts/TradingTimeAxis/SessionBreaks`
+  story (connected vs broken) + `sessionRuns` / `gappingTicks` helpers.
+
+### Changed
+
+- **charts:** a **plain continuous time axis** now runs the same ladder as a
+  trading-calendar axis (via an internal gap-free identity provider) instead of
+  d3's multi-scale default — so a year of daily data ticks cleanly on month
+  starts (`Jul Aug … Jun` + the year underneath) rather than mixed
+  `"Jun 23" / "Sep" / "Dec"` labels, and its tick count is now width-derived
+  like the trading axis's. Month/quarter-grain anchor labels are now bare
+  months (`Feb`, was `Feb 02`) with the year on the boundary row;
+  `coarsenCalendar`'s finest granularity is renamed `'session'` → `'day'`.
+
+### Fixed
+
+- **core:** `TimeSeries.withColumn` now appends an **optional** column
+  (`required: false`) rather than a required one. It already accepted
+  `(number | undefined)[]`, but marking the column required meant a later
+  strict-intake rebuild (`smooth`, any row reconstruction) threw on the gaps —
+  so a column with a warm-up (a rolling study fed into an EMA, e.g.
+  `ema(sma(bars, …), …)`) crashed. The appended column's type is now
+  `number | undefined`, matching `smooth`'s optional append. (`OptionalNumberColumn`
+  is exported for the widened return type.)
+
 ## [0.44.1] — 2026-07-13
 
 A `@pond-ts/charts` patch: fixes trading-time axis tick density. `pond-ts`,

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

@@ -1,4 +1,4 @@
-import type { AlignSchema, MaterializeSchema, ArrayAggregateAppendSchema, ArrayAggregateReplaceSchema, ArrayColumnNameForSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, BaselineSchema, AggregateReducer, AggregateSchema, AppendColumn, CollapseSchema, EventDataForSchema, EventForSchema, FirstColKind, IntervalKeyedSchema, JsonRowFormat, JoinManySchema, JoinSchema, JoinType, NumericColumnNameForSchema, NormalizedObjectRow, NormalizedRowForSchema, PivotByGroupSchema, PointRowForSchema, PrefixedJoinManySchema, PrefixedJoinSchema, ReduceResult, RenameMap, ValidatedAggregateMap } from '../schema/index.js';
+import type { AlignSchema, MaterializeSchema, ArrayAggregateAppendSchema, ArrayAggregateReplaceSchema, ArrayColumnNameForSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, BaselineSchema, AggregateReducer, AggregateSchema, AppendColumn, OptionalNumberColumn, CollapseSchema, EventDataForSchema, EventForSchema, FirstColKind, IntervalKeyedSchema, JsonRowFormat, JoinManySchema, JoinSchema, JoinType, NumericColumnNameForSchema, NormalizedObjectRow, NormalizedRowForSchema, PivotByGroupSchema, PointRowForSchema, PrefixedJoinManySchema, PrefixedJoinSchema, ReduceResult, RenameMap, ValidatedAggregateMap } from '../schema/index.js';
 import type { RenameSchema, RollingAlignment, RollingSchema, ColumnValue, DedupeKeep, DiffSchema, FillMapping, FillStrategy, ScalarKind, ScalarValue, SmoothMethod, SmoothAppendSchema, SmoothSchema, SelectSchema, SeriesSchema, TimeKeyedSchema, TimeSeriesJsonInput, TimeSeriesInput, TimeRangeKeyedSchema, ValueColumnKindForName, ValueColumnNameForSchema, ValueColumnsForSchema, ValueKeyedSchema } from '../schema/index.js';
 import { type ScanStep } from './operators/scan.js';
 import { ValueSeries } from './value-series.js';
@@ -1076,10 +1076,22 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * Computes sequence-driven rolling aggregations and returns an interval-keyed series on the
      * supplied grid.
      *
+     * Example: `series.rolling({ count: 20 }, { close: "avg" }, { minSamples: 20 })`.
+     * A **count-based** window of the last `N` *rows* (bars), keyed on row
+     * position not time. `{ count: N }` in place of a duration reduces, for each
+     * row, the `N` rows in its index window — so an "N-bar" study (SMA-20,
+     * Bollinger-20, rolling stdev) stays correct across session gaps (weekends,
+     * overnight) where a duration window silently spans the wrong number of bars.
+     * Honours `alignment` and `minSamples` exactly like a duration window
+     * (`minSamples: N` gives the conventional warmup — the first `N-1` rows emit
+     * `undefined`). Per-row output only; not supported with a sequence.
+     *
      * Rolling windows are anchored either at each event's `begin()` time or at the sample point of
-     * each sequence bucket. Membership is determined from source event `begin()` times.
+     * each sequence bucket. Membership is determined from source event `begin()` times (a duration
+     * window) or from row position (a `{ count }` window).
      *
-     * Supported alignments:
+     * Supported alignments (a `{ count: N }` window applies the same shape in row-index space, with
+     * a centered window biased one row toward `leading` when `N` is even):
      * - `"trailing"`: `(t - window, t]`
      * - `"leading"`: `[t, t + window)`
      * - `"centered"`: `[t - window/2, t + window/2)`
@@ -1114,7 +1126,9 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * therefore read as distinct values here. Scalar columns
      * (number / string / boolean) are unaffected (value semantics).
      */
-    rolling<const Mapping extends ValidatedAggregateMap<S, Mapping>>(window: DurationInput, mapping: Mapping, options?: {
+    rolling<const Mapping extends ValidatedAggregateMap<S, Mapping>>(window: DurationInput | {
+        count: number;
+    }, mapping: Mapping, options?: {
         alignment?: RollingAlignment;
         minSamples?: number;
     }): TimeSeries<RollingSchema<S, Mapping>>;
@@ -1129,6 +1143,16 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * Applies a smoothing transform to one numeric payload column while preserving the original key
      * type, key values, and all non-target payload fields.
      *
+     * **EMA rate + warm-up.** Give the rate as either `alpha` (0,1] **or** the
+     * financial `span` convention (`α = 2/(span+1)` — a `span`-period EMA, e.g.
+     * `{ span: 12 }`), exactly one of the two. Two warm-up options, both optional:
+     * `warmup: N` **drops** the first N rows (length-changing — hides the noisy
+     * initial convergence); `minSamples: N` **keeps** the rows but emits
+     * `undefined` until N present values have been consumed (length-preserving —
+     * mirrors {@link TimeSeries.rolling}'s `minSamples`, the convention studies
+     * use so a smoothed line aligns on its source's time axis). The EMA converges
+     * on the real values underneath either way.
+     *
      * Example: `series.smooth("value", "movingAverage", { window: "5m", alignment: "centered", output: "valueAvg" })`.
      * Computes a moving average over the selected numeric column using anchor points derived from
      * event keys. `Time` keys use their timestamp. `TimeRange` and `Interval` keys use the midpoint
@@ -1162,6 +1186,12 @@ export declare class TimeSeries<S extends SeriesSchema> {
     smooth<const Target extends NumericColumnNameForSchema<S>, const Output extends string | undefined = undefined>(column: Target, method: SmoothMethod, options: {
         alpha: number;
         warmup?: number;
+        minSamples?: number;
+        output?: Output;
+    } | {
+        span: number;
+        warmup?: number;
+        minSamples?: number;
         output?: Output;
     } | {
         window: DurationInput;
@@ -1336,7 +1366,7 @@ export declare class TimeSeries<S extends SeriesSchema> {
      * (`fromTrustedColumns`, skipping the finite scan) is a deferred sibling for
      * when a perf-critical consumer earns it.
      */
-    withColumn<const Name extends string>(name: Name, values: ReadonlyArray<number | undefined> | Float64Array): TimeSeries<AppendColumn<S, Name, 'number'>>;
+    withColumn<const Name extends string>(name: Name, values: ReadonlyArray<number | undefined> | Float64Array): TimeSeries<readonly [S[0], ...ValueColumnsForSchema<S>, OptionalNumberColumn<Name>]>;
     /** Example: `series.collapse(["in", "out"], "avg", fn)`. Collapses selected payload fields into a single derived field across each event in the series. */
     collapse<const Keys extends readonly (keyof EventDataForSchema<S>)[], Name extends string, R extends ScalarValue>(keys: Keys, output: Name, reducer: (values: Pick<EventDataForSchema<S>, Keys[number]>) => R): TimeSeries<CollapseSchema<S, Keys[number] & string, Name, R>>;
     collapse<const Keys extends readonly (keyof EventDataForSchema<S>)[], Name extends string, R extends ScalarValue>(keys: Keys, output: Name, reducer: (values: Pick<EventDataForSchema<S>, Keys[number]>) => R, options: {

package/dist/batch/time-series.js

@@ -2114,7 +2114,21 @@ export class TimeSeries {
             kind: spec.kind,
             required: false,
         }));
-        const windowMs = parseDuration(window);
+        // A `{ count: N }` window reduces the last/next/centered `N` rows by index
+        // rather than a time span — the count-based (N-bar) window. Detected here so
+        // the duration is never parsed for it.
+        const countWindow = typeof window === 'object' && window !== null && 'count' in window
+            ? window.count
+            : null;
+        if (countWindow !== null) {
+            if (!Number.isInteger(countWindow) || countWindow < 1) {
+                throw new TypeError('rolling { count } must be a positive integer (row count)');
+            }
+            if (sequence) {
+                throw new TypeError('rolling count windows ({ count }) are not supported with a sequence');
+            }
+        }
+        const windowMs = countWindow === null ? parseDuration(window) : 0;
         const alignment = options.alignment ?? 'trailing';
         // Default 0 disables the gate — preserves prior behavior where
         // empty windows still invoke the reducer (custom reducers may
@@ -2229,7 +2243,46 @@ export class TimeSeries {
                 }
             }
         };
-        if (alignment === 'trailing') {
+        if (countWindow !== null) {
+            // Count-based window: for each row, the `N` rows in its index window (not
+            // a time span). `lo`/`hi` are both monotonic non-decreasing in the row
+            // index for every alignment, so the same reducer add/remove sweep stays
+            // amortized O(1) per row — each row enters and leaves the window once.
+            // Rows are the unit (no equal-timestamp grouping — `N` counts bars), and a
+            // centered even `N` biases one row toward the leading side.
+            const n = countWindow;
+            const leftSpan = Math.floor((n - 1) / 2);
+            const rightSpan = n - 1 - leftSpan;
+            for (let index = 0; index < rowCount; index++) {
+                let lo;
+                let hi;
+                if (alignment === 'trailing') {
+                    lo = index - n + 1 < 0 ? 0 : index - n + 1;
+                    hi = index;
+                }
+                else if (alignment === 'leading') {
+                    lo = index;
+                    hi = index + n - 1 < rowCount ? index + n - 1 : rowCount - 1;
+                }
+                else {
+                    lo = index - leftSpan < 0 ? 0 : index - leftSpan;
+                    hi = index + rightSpan < rowCount ? index + rightSpan : rowCount - 1;
+                }
+                while (windowEnd <= hi) {
+                    addEvent(windowEnd);
+                    windowEnd += 1;
+                }
+                while (windowStart < lo) {
+                    removeEvent(windowStart);
+                    windowStart += 1;
+                }
+                const aggregated = snapshotWindow();
+                for (let c = 0; c < outValues.length; c++) {
+                    outValues[c][index] = aggregated[c];
+                }
+            }
+        }
+        else if (alignment === 'trailing') {
             for (let groupStart = 0; groupStart < rowCount;) {
                 const anchor = beginTimes[groupStart];
                 let groupEnd = groupStart + 1;
@@ -2323,6 +2376,16 @@ export class TimeSeries {
      * Applies a smoothing transform to one numeric payload column while preserving the original key
      * type, key values, and all non-target payload fields.
      *
+     * **EMA rate + warm-up.** Give the rate as either `alpha` (0,1] **or** the
+     * financial `span` convention (`α = 2/(span+1)` — a `span`-period EMA, e.g.
+     * `{ span: 12 }`), exactly one of the two. Two warm-up options, both optional:
+     * `warmup: N` **drops** the first N rows (length-changing — hides the noisy
+     * initial convergence); `minSamples: N` **keeps** the rows but emits
+     * `undefined` until N present values have been consumed (length-preserving —
+     * mirrors {@link TimeSeries.rolling}'s `minSamples`, the convention studies
+     * use so a smoothed line aligns on its source's time axis). The EMA converges
+     * on the real values underneath either way.
+     *
      * Example: `series.smooth("value", "movingAverage", { window: "5m", alignment: "centered", output: "valueAvg" })`.
      * Computes a moving average over the selected numeric column using anchor points derived from
      * event keys. `Time` keys use their timestamp. `TimeRange` and `Interval` keys use the midpoint
@@ -2364,27 +2427,56 @@ export class TimeSeries {
             return typeof raw === 'number' ? raw : undefined;
         });
         if (method === 'ema') {
-            if (!('alpha' in options)) {
-                throw new TypeError('ema smoothing requires an alpha option');
+            // Rate parameter: `alpha` directly, or the financial `span` convention
+            // (α = 2/(span+1) — a `span`-period EMA), exactly one of the two.
+            const hasAlpha = 'alpha' in options && options.alpha !== undefined;
+            const hasSpan = 'span' in options && options.span !== undefined;
+            if (hasAlpha === hasSpan) {
+                throw new TypeError('ema smoothing requires exactly one of alpha or span');
+            }
+            let alpha;
+            if (hasSpan) {
+                const span = options.span;
+                if (typeof span !== 'number' || !Number.isFinite(span) || span < 1) {
+                    throw new TypeError('ema smoothing requires span to be a finite number >= 1');
+                }
+                alpha = 2 / (span + 1);
             }
-            const alpha = options.alpha;
-            if (typeof alpha !== 'number' ||
-                !Number.isFinite(alpha) ||
-                alpha <= 0 ||
-                alpha > 1) {
-                throw new TypeError('ema smoothing requires alpha to be a finite number in the range (0, 1]');
+            else {
+                alpha = options.alpha;
+                if (typeof alpha !== 'number' ||
+                    !Number.isFinite(alpha) ||
+                    alpha <= 0 ||
+                    alpha > 1) {
+                    throw new TypeError('ema smoothing requires alpha to be a finite number in the range (0, 1]');
+                }
             }
             // Optional warm-up: drop the first N output rows to hide the
             // noisy initial convergence of the EMA. The smoother still
             // processes those events so `previous` is correctly warmed up
-            // by the time we keep a row.
+            // by the time we keep a row. **Length-changing** (rows are removed) —
+            // for the length-preserving warmup that studies want (align on a shared
+            // time axis), use `minSamples` instead.
             const warmup = 'warmup' in options && options.warmup !== undefined
                 ? options.warmup
                 : 0;
             if (!Number.isInteger(warmup) || warmup < 0 || !Number.isFinite(warmup)) {
                 throw new TypeError('ema smoothing requires warmup to be a non-negative integer');
             }
+            // Length-preserving warm-up: emit `undefined` until `minSamples` present
+            // source values have been consumed, keeping the row (mirrors `rolling`'s
+            // `minSamples`). The EMA still converges on the real values underneath —
+            // only the emitted value is masked — so the kept tail is unchanged.
+            const minSamples = 'minSamples' in options && options.minSamples !== undefined
+                ? options.minSamples
+                : 0;
+            if (!Number.isInteger(minSamples) ||
+                minSamples < 0 ||
+                !Number.isFinite(minSamples)) {
+                throw new TypeError('ema smoothing requires minSamples to be a non-negative integer');
+            }
             let previous;
+            let seen = 0;
             const resultRows = this.events.map((event) => {
                 const raw = event.get(column);
                 const smoothed = typeof raw !== 'number'
@@ -2394,10 +2486,14 @@ export class TimeSeries {
                         : alpha * raw + (1 - alpha) * previous;
                 if (smoothed !== undefined) {
                     previous = smoothed;
+                    seen += 1;
                 }
+                // Mask the emitted value during the length-preserving warm-up, but keep
+                // `previous`/`seen` advancing on the real value above.
+                const emitted = seen < minSamples ? undefined : smoothed;
                 const nextEvent = output === undefined
-                    ? event.set(column, smoothed)
-                    : event.merge({ [output]: smoothed });
+                    ? event.set(column, emitted)
+                    : event.merge({ [output]: emitted });
                 return Object.freeze([
                     nextEvent.key(),
                     ...resultSchema
@@ -2435,7 +2531,7 @@ export class TimeSeries {
             // `missing: 'skip'` — a cell whose own value is missing stays missing
             // (don't fit a fabricated value across the hole from its present
             // neighbours). Default `'bridge'` is the prior behaviour (fit everywhere).
-            const skipMissing = options.missing === 'skip';
+            const skipMissing = 'missing' in options && options.missing === 'skip';
             const resultRows = this.events.map((event, index) => {
                 const smoothed = skipMissing && sourceValues[index] === undefined
                     ? undefined
@@ -2967,9 +3063,15 @@ export class TimeSeries {
         assertColumnValuesMatchKind('number', values, `withColumn '${String(name)}'`);
         const column = columnFromValuesByKind('number', values);
         const reshaped = withColumnAppended(this.#store.store, name, column);
+        // The appended column is **optional** (`required: false`): `values` may
+        // carry `undefined` (a missing cell), so the column can have gaps. Marking
+        // it required would make a later strict-intake rebuild (`smooth`, a row
+        // reconstruction) reject those gaps — breaking composition on a column with
+        // a warm-up (e.g. a rolling study fed into an EMA). Matches `smooth`'s
+        // `OptionalNumberColumn` append.
         const resultSchema = Object.freeze([
             ...this.schema,
-            { name, kind: 'number' },
+            { name, kind: 'number', required: false },
         ]);
         return TimeSeries.#fromTrustedStore(this.name, resultSchema, reshaped);
     }

package/dist/index.d.ts

@@ -30,7 +30,7 @@ export { ArrayColumn } from './columnar/array-column.js';
 export { ChunkedArrayColumn, ChunkedBooleanColumn, ChunkedFloat64Column, ChunkedStringColumn, } from './columnar/chunked-column.js';
 export { type IntervalLabelKind, type KeyColumn, IntervalKeyColumn, TimeKeyColumn, TimeRangeKeyColumn, ValueKeyColumn, } from './columnar/key-column.js';
 export { type ValidityBitmap } from './columnar/validity.js';
-export type { AlignSchema, ArrayColumnNameForSchema, BaselineSchema, AggregateFunction, AggregateReducer, AggregateOutputMap, AggregateOutputSpec, AggregateMap, AggregateSchema, ValidatedAggregateMap, ColumnDef, CollapseData, ArrayAggregateAppendSchema, ArrayAggregateKind, ArrayAggregateReplaceSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, CollapseSchema, DedupeKeep, EventDataForSchema, EventForSchema, EventKeyForKind, FillMapping, FillStrategy, MaterializeSchema, EventKeyForSchema, FirstColKind, FirstColumn, IntervalKeyedSchema, JsonIntervalInput, JsonObjectRowForSchema, JsonRowFormat, JsonRowForSchema, JsonTimeRangeInput, JsonTimestampInput, JsonValueForKind, RollingAlignment, RollingSchema, JoinConflictMode, JoinManySchema, PrefixedJoinManySchema, PrefixedJoinSchema, LiveSource, JoinType, JoinSchema, NormalizedRowForSchema, NormalizedObjectRowForSchema, NormalizedObjectRow, NormalizedValueForKind, ReduceResult, RenameData, RenameMap, RenameSchema, RekeySchema, RowForSchema, ArrayValue, ColumnValue, ScalarKind, ScalarValue, CustomAggregateReducer, DiffSchema, NumericColumnNameForSchema, SmoothMethod, SmoothAppendSchema, SmoothSchema, SelectData, SelectSchema, SeriesSchema, TimeKeyedSchema, TimeSeriesInput, TimeSeriesJsonInput, TimeRangeKeyedSchema, ValueColumnsForSchema, ValueColumn, ValueForKind, ValueFirstColumn, ValueKeyedSchema, ValueSeriesColumnName, ValueSeriesSchema, ValueSeriesValueColumns, } from './schema/index.js';
+export type { AlignSchema, ArrayColumnNameForSchema, BaselineSchema, AggregateFunction, AggregateReducer, AggregateOutputMap, AggregateOutputSpec, AggregateMap, AggregateSchema, ValidatedAggregateMap, ColumnDef, CollapseData, ArrayAggregateAppendSchema, ArrayAggregateKind, ArrayAggregateReplaceSchema, ArrayExplodeAppendSchema, ArrayExplodeReplaceSchema, CollapseSchema, DedupeKeep, EventDataForSchema, EventForSchema, EventKeyForKind, FillMapping, FillStrategy, MaterializeSchema, EventKeyForSchema, FirstColKind, FirstColumn, IntervalKeyedSchema, JsonIntervalInput, JsonObjectRowForSchema, JsonRowFormat, JsonRowForSchema, JsonTimeRangeInput, JsonTimestampInput, JsonValueForKind, RollingAlignment, RollingSchema, JoinConflictMode, JoinManySchema, PrefixedJoinManySchema, PrefixedJoinSchema, LiveSource, JoinType, JoinSchema, NormalizedRowForSchema, NormalizedObjectRowForSchema, NormalizedObjectRow, NormalizedValueForKind, ReduceResult, RenameData, RenameMap, RenameSchema, RekeySchema, RowForSchema, AppendColumn, OptionalNumberColumn, ArrayValue, ColumnValue, ScalarKind, ScalarValue, CustomAggregateReducer, DiffSchema, NumericColumnNameForSchema, SmoothMethod, SmoothAppendSchema, SmoothSchema, SelectData, SelectSchema, SeriesSchema, TimeKeyedSchema, TimeSeriesInput, TimeSeriesJsonInput, TimeRangeKeyedSchema, ValueColumnsForSchema, ValueColumn, ValueForKind, ValueFirstColumn, ValueKeyedSchema, ValueSeriesColumnName, ValueSeriesSchema, ValueSeriesValueColumns, } from './schema/index.js';
 export type { CalendarOptions, CalendarUnit, TimeZoneOptions, } from './core/calendar.js';
 export type { EventKey, IntervalInput, IntervalValue, TemporalLike, TimeRangeInput, TimestampInput, } from './core/temporal.js';
 export type { DurationInput } from './core/duration.js';

package/package.json

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