@pond-ts/process 0.64.0 → 0.66.0

package/CHANGELOG.md

@@ -8,7 +8,9 @@ The `@pond-ts` packages — `pond-ts`, `@pond-ts/react`, `@pond-ts/charts`,
 under a single `v*` 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/pond-ts/pond/compare/v0.64.0...HEAD
+[Unreleased]: https://github.com/pond-ts/pond/compare/v0.66.0...HEAD
+[0.66.0]: https://github.com/pond-ts/pond/compare/v0.65.0...v0.66.0
+[0.65.0]: https://github.com/pond-ts/pond/compare/v0.64.0...v0.65.0
 [0.64.0]: https://github.com/pond-ts/pond/compare/v0.63.0...v0.64.0
 [0.63.0]: https://github.com/pond-ts/pond/compare/v0.62.0...v0.63.0
 [0.62.0]: https://github.com/pond-ts/pond/compare/v0.61.0...v0.62.0
@@ -67,6 +69,1116 @@ include new features and type-level changes; patch bumps are strictly additive.
 
 ## [Unreleased]
 
+## [0.66.0] — 2026-09-07
+
+### Added
+
+- `@pond-ts/financial`: **the volume and miscellaneous leftovers** (corpus
+  §6.6 / §6.4 / §6.1) — six studies in the uniform shape (bar columns plus an
+  `output` or `prefix`, bar-count periods, a length-preserving per-column
+  warm-up, a fluent method), each with oracle cases. Two internal kernel
+  helpers ride with them: `trueRangeBoundsValues` (the true high / true low
+  the true range is the width of) and `moneyFlowVolumeValues` (the `clv ·
+volume` term the A/D line already accumulated, named so Twiggs can share
+  it).
+  - **`twiggsMoneyFlow({ period = 21, high, low, close, volume, output =
+'tmf' })`** — Colin Twiggs' correction to Chaikin Money Flow: the close's
+    location in the bar's **true** range (so a gap bar is scored against the
+    ground it covered), Wilder-smoothed against a matching smoothing of
+    volume rather than summed over a flat window. Bounded −1…1. **F-AMBIG**
+    on the smoothing: Wilder's exponential form ships (Incredible Charts /
+    Twiggs' own published algorithm) and the window-sum fork is measured at
+    **0.0706** away at `period 21`, where TMF itself spans −0.0279…0.1493;
+    `chaikinMoneyFlow(21)` sits **0.1494** away — wider than the whole
+    reading. Warm-up is `period` (bar 0 has no true range), and an interior
+    gap in any input **ends** the reading, where CMF recovers a window later.
+  - **`tradeVolumeIndex({ minTick, column = 'close', volume, output = 'tvi'
+})`** — tick-direction volume accumulation: `+1` above the dead band, `−1`
+    below it, and **the previous direction** on an undecided bar, which is
+    what the exchange tick rule does and what distinguishes it from `obv`
+    (which adds nothing for an unchanged close). **`minTick` is required**
+    and has no default — a fact about the instrument, like `swingIndex`'s
+    `limit`; `0`, negative and non-finite are rejected. The level starts at
+    `0`, no first direction is invented (the up-seeded vendor fork is pinned
+    by a unit test — the oracle input's first bar carries its largest move,
+    so the fork is invisible there, and the generator asserts that), and an
+    interior gap **ends** the index the way `obv` does rather than re-seeding
+    the way `negativeVolumeIndex` does.
+  - **`shinoharaIntensityRatio({ period = 26, open, high, low, close, prefix =
+'sir' })`** → `sirStrong`, `sirWeak` — Shinohara's A and B ratios,
+    `100·Σup/Σdown` over the window: A measured against each bar's **own
+    open**, B against the **previous close**. **F-AMBIG** on the A/B naming:
+    the arithmetic is the standard pair and the `strong` / `weak` labels come
+    from the corpus' own list; the alternative convention charts them the
+    other way round, and the two lines sit **23,312.47** apart on the oracle
+    input, so the labels carry information. Per-column warm-up (25 and 26 at
+    the default). Neither ratio is bounded, and **B inverts on a gappy tape**
+    — `prevClose − low` is negative on a bar that gapped up, which is the
+    definition, not a defect (documented, with the oracle input's own
+    −22,761…7,620 range as the worked case).
+  - **`elderImpulse({ emaPeriod = 13, fastPeriod = 12, slowPeriod = 26,
+signalPeriod = 9, column = 'close', output = 'impulse' })`** — Elder's
+    Impulse System: `+1` when the 13-bar EMA **and** the MACD histogram both
+    rise, `−1` when both fall, `0` otherwise. The column is **numeric**, not
+    the categorical colour the corpus describes — `TimeSeries.withColumn` has
+    no string door, so a study cannot append one; `+1 / 0 / −1` is signed, so
+    a chart maps it to Elder's green/blue/red in one expression. It calls
+    `macd()` under a scratch prefix rather than re-deriving the histogram, so
+    it is by construction the same MACD a caller charts beside it. Ties are
+    `0` (strict comparison on both sides), so it carries no state and needs
+    no gap rule of its own; warm-up 34 at the defaults.
+  - **`movingAverageCross({ fastPeriod = 10, slowPeriod = 30, maType = 'sma',
+column = 'close', output = 'maCross' })`** — a **signal** column: `+1` on
+    the bar the fast average crosses above the slow one, `−1` below, `0`
+    otherwise. The averages are not emitted (that is `movingAverage`'s job);
+    what this adds is the event, which needs memory of which side the pair
+    was last on — a K6 `foldRows` machine. **The tie rule is the design**: an
+    exact tie is not a cross, a touch-and-retreat is not a cross (the machine
+    carries the last **non-zero** sign), and a crossing _through_ a tie fires
+    on the far-side bar. `maType`, not `type`, because the column is a signal
+    rather than an average. The first bar on which both averages exist
+    reports `undefined`, not `0` — it is the seed. **What a gap costs depends
+    entirely on `maType`**, and the docstring carries the measured table: at
+    the default `sma` a hole costs _nothing_ (the K2 column door counts rows),
+    at `ema` two bars, at `wma`/`hull` a window, and at `smma`/`kama` the rest
+    of the series.
+  - **`anchoredVwap({ anchor, high, low, close, volume, output = 'avwap' })`**
+    — the cumulative `Σ typicalPrice·volume / Σ volume` from a chosen bar
+    onwards: the VWAP of the execution desk, and the half of VWAP that
+    `vwap()`'s docstring named and left open. **`anchor` is required** and is
+    a `Date` or epoch **milliseconds**, not a row index — the line starts at
+    the first bar at or after it, so an anchor between bars snaps forward, one
+    before the series covers all of it, and one after the last bar leaves the
+    column empty (not an error). The **session-reset** form still waits on
+    [PND-TCAL]; what makes this one shippable today is that its anchor is a
+    user parameter, so no calendar is consulted. An interior gap **ends** the
+    line (`obv`'s cumulative rule), and the volume sum is blanked wherever
+    the price sum is so the two consume the same bars.
+
+- `@pond-ts/financial`: **the momentum and trend leftovers** (corpus §6.3 /
+  §6.4 / §6.1) — ten studies in the uniform shape (a `column` or the bar
+  columns plus an `output` or `prefix`, bar-count periods, a length-preserving
+  per-column warm-up, a fluent method), each with oracle cases. Two internal
+  kernels ride with them: `swingIndexValues` (shared by the swing pair) and
+  `randomWalkValues` (the multi-horizon sweep the corpus flags as **G2**).
+  - **`stochasticMomentumIndex({ period = 13, longPeriod = 25, shortPeriod =
+2, signalPeriod = 3, high, low, close, prefix = 'smi' })`** → `smi`,
+    `smiSignal` — William Blau's SMI: the close against the **midpoint** of
+    the `period`-bar range, with the distance and the half-range each
+    double-EMA smoothed before the division, ×100. Bounded −100…100 and
+    signed, where the classic stochastic reads 50 at the midpoint. Option
+    names are `trueStrengthIndex`'s (Blau's other double-smoothed
+    study, same author, same `r`/`s`). Blau's `(13, 25, 2)` ship; the short
+    `(5, 3, 3)` fork sits **108.99** away and the unsmoothed reading
+    **126.95**, on a line spanning −48.19…74.33 (measured). A flat range for
+    the whole smoothed history reads `undefined` — the guard is live via a
+    redirected `close`.
+  - **`fisherTransform({ period = 10, high, low, prefix = 'fisher' })`** →
+    `fisher`, `fisherSignal` — John Ehlers' Fisher Transform (TASC Nov 2002),
+    a `foldRows` state machine. The range is over the **median price's** own
+    extremes, not over the bars' highs and lows: that port sits **5.95** away
+    on a line spanning −4.69…7.60 (measured). `0.33/0.67`, the `±0.99` clamp
+    test with its `±0.999` replacement, and the `0.5/0.5` second smoothing are
+    Ehlers' constants, not options. The signal is the line **delayed one
+    bar**. A gap — or a flat window — resets the machine ([PND-SFOLD]).
+  - **`schaffTrendCycle({ fastPeriod = 23, slowPeriod = 50, cyclePeriod = 10,
+column, output = 'stc' })`** — Doug Schaff's STC: a stochastic of the MACD,
+    `0.5`-smoothed, then a stochastic of that, `0.5`-smoothed again. Bounded
+    0…100; the raw double stochastic is **98.30** away (measured). Both
+    recursions are `foldRows` steps, so a gap resets them rather than
+    repeating the previous reading as the common port does — and that is
+    visible: a sustained trend pins the first stochastic, leaving the second
+    window flat and the line `undefined`, which on the package's own oracle
+    input delays the start from bar 67 to bar **74**.
+  - **`prettyGoodOscillator({ period = 14, column, high, low, close, output =
+'pgo' })`** — Mark Johnson's PGO, `(close − SMA)/EMA(TR)`, in units of
+    average daily ranges. **F-AMBIG**: Johnson's span-EMA denominator ships
+    and the Wilder-`ATR` port is named and measured (**0.211** apart at
+    period 14 on a line spanning −3.71…4.23). `column` defaults to whatever
+    `close` resolves to, as `atrBands` does.
+  - **`swingIndex({ limit, open, high, low, close, output = 'si' })`** and
+    **`accumulativeSwingIndex({ …, output = 'asi' })`** — Wilder's 1978 swing
+    index and its running total. **`limit` (Wilder's `T`, the instrument's
+    limit move) is required** and has no default: it is a fact about the
+    instrument, every possible default silently rescales the reading, and the
+    ±100 bound the study is defined by depends on it. A `limit` of 0 (or
+    negative, or non-finite) is rejected. `R = 0` — a tape frozen for two
+    bars — reads `undefined`, which for the ASI ends the level, the same rule
+    OBV follows.
+  - **`randomWalkIndex({ period = 14, high, low, close, prefix = 'rwi' })`** →
+    `rwiHigh`, `rwiLow` — E. Michael Poulos' RWI: the **maximum over horizons
+    `2 … period`** of `(high − low[−n]) / (meanTR(n)·√n)`. The denominator is
+    the `n`-bar **mean** true range, not Wilder's ATR (that variant is
+    **0.190** away at period 14; the single-horizon form **2.374**, measured).
+    Deliberately **O(N·period)** — the G2 shape no window kernel expresses —
+    with O(N) memory; 328 ms at `period 14` and 1194 ms at `period 50` on 1M
+    bars. Both columns go **negative** when every horizon fell.
+  - **`ravi({ shortPeriod = 7, longPeriod = 65, column, output = 'ravi' })`** —
+    Tushar Chande's Range Action Verification Index,
+    `100·|SMA(short) − SMA(long)|/SMA(long)`. The **absolute value** is the
+    study: it answers "is this trending" (above 3%), not "which way" — the
+    signed form is **26.98** away (measured). Scale-invariant, not
+    shift-invariant.
+  - **`trendIntensityIndex({ period = 30, maPeriod = 60, column, output =
+'tii' })`** — M. H. Pee's TII, `100·Σpos/(Σpos + Σneg)` over the last
+    `period` deviations from a `maPeriod` SMA. **F-AMBIG**: Pee's **sums**
+    ship, weighted by how far price strayed; the common **count** form is
+    **28.85** away (measured) and would deserve its own name. Bounded 0…100,
+    warm-up `maPeriod + period − 2` = **88** bars at the defaults.
+  - **`specialK({ column, output = 'specialK' })`** — Martin Pring's Special
+    K: the KST construction extended to **twelve** weighted smoothed rates of
+    change across three groups. The thirty-six constants are the study, so
+    there are no period options (the `kst` decision). **Warm-up 724 bars** —
+    a series shorter than 725 comes back entirely `undefined`, with the row
+    count preserved.
+- `@pond-ts/financial`: **the prime studies and Bill Williams' Market
+  Facilitation Index** (corpus §6.2 / §6.3 / §6.6) — three per-bar studies with
+  no window, no warm-up and no parameters beyond their column names.
+  - **`primeNumberBands({ high?, low?, prefix = 'pnb' })`** → `pnbUpper`,
+    `pnbLower` — the smallest prime at or above the bar's high and the largest
+    at or below its low, so the bands **contain** the bar. A step function of
+    the price _level_: it holds flat inside a prime gap and jumps across one,
+    and two instruments at the same price have identical bands.
+  - **`primeNumberOscillator({ column = 'close', output = 'pno' })`** —
+    `price − nearestPrime(price)`, positive when the price sits above the prime
+    nearest it and exactly `0` when it **is** an integer prime. Both open
+    conventions are pinned: the sign is `price − prime`, and an **equidistant
+    tie goes to the lower prime** (so `pno(6) = +1`).
+  - Both: **a price below 2 is outside the domain** and reads `undefined` — two
+    is the smallest prime, so there is nothing to bracket with. **Neither is
+    scale- nor shift-equivariant**, and the property tests assert that
+    _absence_ rather than skipping the check. **Cost grows with the price
+    magnitude**, the only operators in the package that do: measured at 1M
+    bars, ~78 ms and ~55 ms at ordinary equity prices and **~6.5 s each at
+    ~1e7**. There is no sieve; the kernel documents why and what would change
+    it.
+  - **`marketFacilitationIndex({ high?, low?, volume?, output = 'bwmfi' })`** —
+    Bill Williams' `(high − low) / volume`, the raw ratio with **no `scale`
+    option** (no vendor constant is standard, unlike `easeOfMovement`'s
+    published `100_000_000`). The default output is **`bwmfi`, not `mfi`**:
+    `moneyFlowIndex` — a different indicator published under the same
+    abbreviation — already owns that name, and both must be able to sit on one
+    series. A zero-volume bar reads `undefined`; a flat bar reads `0`.
+- `@pond-ts/financial`: **the bands and channels tail** (corpus §6.2) — four
+  studies in the uniform shape, each with oracle cases and a fluent method.
+  - **`starcBands({ period = 20, atrPeriod = 15, multiplier = 2, maType =
+'sma', high?, low?, close?, prefix = 'starc' })`** → `starcMiddle`,
+    `starcUpper`, `starcLower` — Manning Stoller's channel: a moving average
+    of the **close** with bands a multiple of the ATR away. The close-centred
+    sibling of `keltner` (typical-price centre) and of `atrBands` (bands
+    around an existing column, no centre). It **is** `movingAverage` followed
+    by `atrBands` around that average, pinned bit-for-bit by a test; it ships
+    for the name and the centre column. Per-column warm-up: centre at the
+    MA's own bar, bands at `max(centre, ATR)`.
+  - **`highLowBands({ period = 10, percent = 1, maType = 'trima', high?, low?,
+prefix = 'hlb' })`** → `hlbMiddle`, `hlbUpper`, `hlbLower` — a moving
+    average of the **median price** with bands `± percent`. It **is**
+    `envelope` over a `medianPrice` column, pinned bit-for-bit.
+  - **`bollingerBandwidth({ period = 20, stdDev = 2, column?, output =
+'bbWidth' })`** — `100·(upper − lower)/middle`, the **×100** StockCharts /
+    ChartIQ form rather than Bollinger's bare ratio. A **flat window reads
+    `0`**, not `undefined`: the numerator is `2·stdDev·σ`, forced to zero,
+    over a non-zero centre — so on a flat stretch it is deliberately **not**
+    recoverable from `bollinger`'s (missing) band columns, while everywhere
+    else it is bit-for-bit.
+  - **`bollingerPercentB({ period = 20, stdDev = 2, column?, output =
+'percentB' })`** — `(price − lower)/(upper − lower)`, the **decimal** form
+    (`0` = lower band, `1` = upper), unbounded so an out-of-band price still
+    reads. A flat window is a genuine `0/0` and reads `undefined` — the
+    opposite answer from BandWidth's on the same window, and the clearest
+    illustration of the "is the numerator _forced_ to zero?" test.
+- `@pond-ts/financial`: **the K3 price transforms and Balance of Power**
+  (corpus §6.8) — five studies in the uniform shape (each bar-column named by
+  its own option defaulting to its `DEFAULT_OHLCV` name, an `output`, a
+  fluent method), all five **exact** against TA-Lib bar-for-bar.
+  - **`typicalPrice({ high?, low?, close?, output = 'typicalPrice' })`**
+    (`(h+l+c)/3`, TA-Lib `TYPPRICE`),
+    **`medianPrice({ high?, low?, output = 'medianPrice' })`** (`(h+l)/2`,
+    `MEDPRICE`),
+    **`weightedClose({ high?, low?, close?, output = 'weightedClose' })`**
+    (`(h+l+2c)/4`, `WCLPRICE`) and
+    **`averagePrice({ open?, high?, low?, close?, output = 'averagePrice' })`**
+    (`(o+h+l+c)/4`, `AVGPRICE`). These are the per-bar summaries `vwap`, `cci`,
+    `mfi`, `keltner` and the Awesome Oscillator derive privately, now available
+    as **columns** so a caller can chart one or run another study over it
+    (`sma({ column: 'typicalPrice' })`). **No warm-up at all** — a bar's own
+    prices are all any of them reads, so bar 0 carries a value.
+  - **`balanceOfPower({ period?, maType?, open?, high?, low?, close?, output =
+'bop' })`** — Igor Livshin's `(close − open) / (high − low)`, the body over
+    the range, bounded −1…1. **Raw by default** (exact against TA-Lib `BOP`);
+    the optional `period` is ChartIQ's smoothed form over the shared `MaType`
+    menu. **F-AMBIG** — both conventions are published, and the one an oracle
+    can pin ships as the default. Passing `maType` without a `period` **throws**
+    rather than silently doing nothing. A **flat bar reads `0`, not
+    `undefined`**: a bar with no range traded at one price, so the numerator is
+    forced to zero (the `clvValues` rule from the volume group), which is
+    TA-Lib's answer too.
+- `@pond-ts/financial`: **the moving-average stacks and the smoothed-momentum
+  tail** (corpus §6.1 / §6.3) — seven studies in the uniform shape (a `column`
+  plus an `output` or `prefix`, bar-count periods, a length-preserving
+  per-column warm-up, a fluent method), each with oracle cases.
+  - **`guppy({ column = 'close', type = 'ema', prefix = 'gmma' })`** — Daryl
+    Guppy's Multiple Moving Average: the **fixed twelve** averages, short
+    `3, 5, 8, 10, 12, 15` as `gmmaS3 … gmmaS15` and long
+    `30, 35, 40, 45, 50, 60` as `gmmaL30 … gmmaL60`. There is deliberately no
+    "which periods" option — the twelve are the study — but `type` takes the
+    whole shared `MaType` menu. The periods are exported as
+    `GUPPY_SHORT_PERIODS` / `GUPPY_LONG_PERIODS` so a chart can label the
+    ribbon. Each column is checked against `talib.MA` **at its own period**
+    (exact for `sma`; for `ema` the formula on TA-Lib's SMA seed plus a
+    geometric-decay check on pond's first-sample seed). Warm-up is
+    **per column** — `gmmaS3` at bar 2, `gmmaL60` at bar 59, which is 57 real
+    values of the fast ribbon a shared warm-up would have discarded.
+  - **`rainbow({ column = 'close', period = 2, type = 'sma', prefix =
+'rainbow' })`** — Mel Widner's Rainbow Moving Average (TASC, July 1997):
+    ten **recursive** averages, each smoothing the previous one, as
+    `rainbow1 … rainbow10`. Stage `k` warms up at `k · (period − 1)`, so ten
+    2-bar averages are a ten-bar look-back. Deliberately **not** the
+    ten-increasing-lengths variant also published under the name: a recursive
+    2-bar mean is a binomial filter, and stage 10 sits **0.83** from the
+    11-bar SMA covering the same support (measured; the fixture's whole close
+    range is 19.4).
+  - **`rainbowOscillator({ column = 'close', period = 2, lookback = 10,
+prefix = 'rbo' })`** → `rbo`, `rboUpper`, `rboLower` — ChartIQ's:
+    `100·(price − mean of the ten)/(HH − LL)` over `lookback` bars of
+    `column`, with the stack's own `max − min` as bands mirrored about zero.
+    **F-AMBIG**, so the source is named and the alternatives measured: the
+    divide-by-price form is **67.27** away and a first-average numerator
+    **49.16**, against a reading spanning −68.6…63.8. A flat `lookback`
+    window reads `undefined` — nothing forces the numerators to zero, so it
+    is a real number over zero rather than a `0/0`.
+  - **`kst({ column = 'close', signalPeriod = 9, prefix = 'kst' })`** →
+    `kst`, `kstSignal` — Martin Pring's Know Sure Thing on his intermediate
+    **daily** set: four percent rates of change (look-backs 10 / 15 / 20 /
+    30), each smoothed by a simple average (10 / 10 / 10 / 15), weighted
+    1 / 2 / 3 / 4 and summed, with a simple-average signal. The twelve
+    constants are deliberately **not** options — Pring published several KSTs
+    (short daily, weekly, monthly) and they are different indicators, not one
+    with parameters — so only `signalPeriod` is exposed. The line warms up at
+    bar 44, the signal `signalPeriod − 1` later. Scale-invariant, not
+    shift-invariant.
+  - **`priceMomentumOscillator({ column = 'close', prefix = 'pmo' })`** →
+    `pmo`, `pmoSignal` — DecisionPoint's PMO. Its two smoothing stages use
+    DecisionPoint's **custom** multiplier `α = 2/n`, which is **not** the
+    span EMA's `2/(n+1)` and is the only non-span exponential in the package:
+    measured, building both stages on the span EMA instead puts the line
+    **0.106** away on a reading whose scale is 3.906 (2.7%). The **signal**
+    is a plain span `EMA(10)` — DecisionPoint's own asymmetry, and a
+    custom-smoothed signal would sit 0.088 away. No period options; the line
+    warms up at bar 54 and the signal at 63.
+  - **`stochasticRsi({ column = 'close', rsiPeriod = 14, stochPeriod = 14,
+kPeriod = 3, dPeriod = 3, prefix = 'stochRsi' })`** → `stochRsiK`,
+    `stochRsiD` — Chande & Kroll's Stochastic RSI, composed on the shipped
+    `rsi` rather than a private copy. **`stochRsiK` equals TA-Lib
+    `STOCHRSI`'s `fastd`** (not its `fastk`) bar-for-bar with identical
+    masks, measured to 9.9e-14; `stochRsiD` has no TA-Lib counterpart, since
+    `STOCHRSI` stops at `fastd`. Crossing the two columns is a 45-point error
+    on the oracle input, and the generator asserts both the match and the
+    mismatch. The option names are TradingView's, so **`stochPeriod` here is
+    `stochastic`'s `kPeriod`** and **`kPeriod` here is its `slowing`** — a
+    table in the docstring maps all three vocabularies.
+  - **`trueStrengthIndex({ column = 'close', longPeriod = 25, shortPeriod =
+13, signalPeriod = 7, prefix = 'tsi' })`** → `tsi`, `tsiSignal` — William
+    Blau's TSI: the bar-over-bar change double-smoothed, over its own
+    magnitude double-smoothed the same way, ×100. Bounded −100…100 by
+    construction. The smoothing **order is the definition** — `longPeriod`
+    first, `shortPeriod` to its output — and the swap sits **15.93** away on
+    a line spanning −28.7…80.7 (measured; the generator asserts it). A
+    perfectly flat column gives a zero denominator with the numerator forced
+    to zero, a genuine `0/0` → `undefined`. Scale- **and** shift-invariant,
+    unlike `kst` and `priceMomentumOscillator`. Options are named
+    `longPeriod` / `shortPeriod`, not `long` / `short`, which read as
+    position vocabulary in a financial package.
+  - **`movingAverageDeviation({ column = 'close', period = 20, maType =
+'sma', output = 'maDev' })`** — `price − MA`, in **price units**, over
+    the shared `MaType` menu. The corpus lists this study as "points **or**
+    percent"; the percent half is **already shipped** as `disparityIndex`,
+    and the two agree **bit for bit** (`100·maDev/MA === disparity`,
+    measured 0.0, asserted in the oracle), so only the points form ships and
+    there is no `mode` flag — two indicators behind an option is the
+    `keltner` precedent this package avoids. It is the one study in the pair
+    that is **shift-invariant** (the constant cancels between the price and
+    its own average) and the one with no division and so no
+    zero-denominator case.
+- `@pond-ts/financial`: **the K6 stateful-fold kernel and the state-machine
+  studies** (corpus §6.4 / §6.6, gap **G2**) — one new public kernel and six
+  studies in the uniform shape (`column` / `output` or a `prefix`, bar-count
+  periods, a length-preserving warm-up, a fluent method), each with oracle
+  cases.
+  - **`foldRows(inputs, outputCount, state, step)`** (kernel **K6**,
+    [PND-SFOLD]) — a per-bar fold with carried state over several row-aligned
+    `Float64Array` columns, the one shape the rolling kernels and core's
+    single-column `scan` cannot express. One O(N·k) pass, outputs allocated
+    and **NaN-filled** by the kernel, the state object the study's own and
+    mutated in place — no per-bar allocation. Exported with its `FoldStep`
+    type. Measured at 1M bars: **11.3 ms** for a two-column fold over a no-op
+    step, against `ema()`'s 6.3 ms and a 5.2 ms floor for the same scan with
+    no callback.
+    - **A missing cell RESETS the machine.** The step is offered only complete
+      rows, with `run` = how many consecutive complete rows end here; an
+      incomplete row leaves the outputs `undefined` and restarts `run` at 1.
+      The alternative — holding the state across the gap — was rejected: a
+      Parabolic SAR that did not see a bar cannot know whether it flipped, and
+      a recursion carried on the wrong side never recovers. `run` doubles as
+      the seeded flag, which is why there is no separate `seed` hook.
+  - **`parabolicSar({ step = 0.02, maxStep = 0.2, high?, low?, prefix = 'psar' })`**
+    → `psar` + `psarTrend` — Wilder's stop-and-reverse, **bar-for-bar
+    identical to TA-Lib `SAR`** (measured 0.0 maximum absolute difference at
+    `(0.02, 0.2)`, `(0.05, 0.5)` and `(0.01, 0.1)`, masks identical, first
+    value at bar 1). The three prose-ambiguous details — the `−DM` seed side,
+    the first bar's "yesterday is today" clamp, and the clamp against the last
+    two bars on a reversal — are pinned to TA-Lib's reading and **probed**
+    against it in the oracle generator.
+  - **`superTrend({ period = 10, multiplier = 3, high?, low?, close?, prefix = 'st' })`**
+    → `st` + `stTrend` — Olivier Seban's ratcheting ATR band, as TradingView's
+    `ta.supertrend` implements it, on the same Wilder `atrValues` `atr` and
+    `keltner` read. The two bands are **not** emitted: `st` already is
+    whichever one is live.
+  - **`atrTrailingStop({ period = 14, multiplier = 3, high?, low?, close?, prefix = 'ats' })`**
+    → `ats` + `atsTrend` — the close-anchored ratcheting stop (Vervoort's).
+    The **Chandelier** anchor (rolling extreme rather than the close) is a
+    different study, reachable as `donchian` + `atr`, and deliberately not a
+    knob here.
+  - **`negativeVolumeIndex` / `positiveVolumeIndex`
+    (`{ column = 'close', volume?, output = 'nvi' | 'pvi', start = 1000 }`)** —
+    Fosback's conditional cumulative indices. No period and no warm-up. A
+    **flat volume holds on both**, so the two do not partition the bars; a
+    zero previous close ends the index rather than inventing a level.
+  - **`klinger({ fastPeriod = 34, slowPeriod = 55, signalPeriod = 13, high?, low?, close?, volume?, prefix = 'kvo' })`**
+    → `kvo` + `kvoSignal` — Klinger's **original** volume force
+    (`volume × |2 × (dm/cm − 1)| × trend × 100`, with `cm` accumulating over
+    the trend leg) through an EMA pair plus a signal EMA. **F-AMBIG**:
+    TradingView's `ta.kvo`, which drops the `dm/cm` factor entirely, is a
+    different indicator sharing the name and is documented rather than offered
+    as an option.
+  - **The three stop machines append `${prefix}` and `${prefix}Trend`**, the
+    value under the bare prefix rather than `${prefix}Line`, with `+1` meaning
+    the line sits **below** price. The side is a separate column because it is
+    not recoverable from the value — all three clamp, so the line can print
+    exactly on an extreme or on the close.
+- `@pond-ts/financial`: **the rolling linear-regression family** (corpus §6.7,
+  plus the two §6.3 studies that hang off it) — one new public kernel and four
+  studies in the uniform shape (a `column` / `output` or `prefix`, bar-count
+  periods, a length-preserving warm-up, a fluent method), each with oracle
+  cases at two periods.
+  - **`linearRegressionValues(values, period)`** (kernel **K7**) — the rolling
+    ordinary-least-squares fit of a raw `Float64Array` against the bar index,
+    returning `{ slope, intercept, r2 }` in **one O(N) pass that is flat in
+    `period`** (measured at 1M bars: 29 ms at `period 14`, 29 ms at
+    `period 200`). `x` is deterministic, so `Σx` and `Σx²` are closed forms and
+    only `Σy`, `Σxy` and `Σy²` roll. Exported alongside its `RollingRegression`
+    result type.
+    Near-flat windows (changing by ulps, or a plateau the anchor has gone
+    stale across) are recomputed two-pass on a fresh local anchor when the
+    rolling spread falls below `1e-3` of the gross magnitude that has passed
+    through its sums since the last rebuild — the sign is not the tell — and
+    `r2` is pinned to 1; every changing window is tested against an exact
+    BigInt-rational reference (review, 2026-09-07).
+  - **`linearRegression({ period = 14, column = 'close', prefix = 'linreg' })`**
+    → `linregValue`, `linregSlope`, `linregIntercept`, `linregAngle`,
+    `linregR2` — five readings of **one** fit, all warming up together at
+    `period − 1`. Four are **exact against TA-Lib** (`LINEARREG`,
+    `LINEARREG_SLOPE`, `LINEARREG_INTERCEPT`, `LINEARREG_ANGLE`; measured
+    ≤ 1.3e-12 at `period 14`, masks identical); `linregR2` has no TA-Lib
+    equivalent and is a pandas replication.
+    - **`linregIntercept` is the fit at the window's FIRST bar** (`x = 0`),
+      TA-Lib's convention — `linregValue` is the fit at its last. On the
+      oracle input at `period 14` the two differ by up to **13.68 points** on
+      a series whose entire range is 19.4, so reading one for the other is a
+      real error rather than a rounding one.
+    - **`linregAngle` is scale-DEPENDENT**, and deliberately so: TA-Lib's
+      `LINEARREG_ANGLE` is `atan(slope)` in degrees with no normalisation, so
+      the same instrument quoted in cents reads a different angle. Stated on
+      the study and pinned by a property test that asserts scaling **moves**
+      it.
+  - **`timeSeriesForecast({ period = 14, column, output = 'tsf' })`** — the
+    same fit projected one bar past the window (`intercept + slope·period`),
+    **exact against TA-Lib `TSF`** (≤ 2.1e-13). Also known as the "time series
+    moving average" and deliberately **not** added to the K2 `MaType` menu:
+    every type there is the identity at `period 1`, and a one-bar window has
+    no slope.
+  - **`chandeForecastOscillator({ period = 14, column, output = 'cfo' })`** —
+    `100 · (price − TSF) / price` (Tushar Chande). No TA-Lib function; the
+    oracle is a pandas replication on the TA-Lib-checked `TSF`, separated from
+    the version that subtracts the in-window endpoint (0.89 at `period 14`).
+    Scale-invariant, **not** shift-invariant.
+  - **`centerOfGravity({ period = 10, column, output = 'cog' })`** — Ehlers'
+    position-weighted balance point (_Stocks & Commodities_, May 2002),
+    `−Σ(k+1)·price[i−k] / Σprice[i−k]` with the **newest** bar carrying weight
+    1. Negative and bounded `[−period, −1]` on positive prices (a
+       zero-crossing source column can read outside it), and a flat window balances at
+       `−(period+1)/2`. This is **TradingView's uncentred `ta.cog`**; Ehlers' own
+       EasyLanguage adds `(period+1)/2` to re-centre on zero, a constant offset
+       the oracle pins. It needs no new kernel: the descending weights are the
+       ascending ones subtracted from a constant, so the study is exactly
+       `(period + 1)·(WMA/(2·SMA) − 1)` over the K2 engine's `wma` and
+       `rollingMeanValues` — an identity pinned by a test against the naive
+       `O(N·period)` definition.
+  - **All four run the strict window**: a bar is emitted only when all
+    `period` cells are finite, because `x` names a _position_ and dropping a
+    cell would fit the line against the wrong abscissa (the `wma` rule). A
+    leading gap shifts the start; an interior gap blanks `period` bars and
+    then recovers.
+  - **A flat window: `slope` exactly `0`, `linregR2` `undefined`.** The
+    slope's numerator is forced to zero by the same condition that empties
+    the window, so `0` is a real reading; `R²` is a genuine `0/0` and is
+    missing. Both are decided by an O(1) count of the changes inside the
+    window rather than computed — without it the accumulator residue reads
+    `slope = −2.1e-14` and **`R² = −13.5`**, outside the statistic's own
+    range (measured).
+  - The regression periods must be **at least 2** (`n²(n²−1)/12` is `0` at
+    `n = 1`); `centerOfGravity` takes a moment rather than a fit, so it
+    accepts `period 1` and reads `−1`.
+- `@pond-ts/financial`: **the two-series / comparison family** (corpus §6.7,
+  kernel K8) — `correlation`, `beta`, `priceRelative` and `performanceIndex`,
+  plus the public kernel `rollingBivariateValues`. Seven oracle cases; the two
+  TA-Lib-backed studies agree with `CORREL` and `BETA` bar-for-bar.
+  - **The comparison series is a `benchmark` COLUMN on the same series, never a
+    second `TimeSeries`.** The consumer aligns and joins first
+    (`align` + `TimeSeries.joinMany`), and the study reads two columns of one
+    row — exactly as `atr` reads `high`/`low`/`close`. A study that took a
+    second series would have to invent an alignment policy (hold?
+    interpolate? inner or outer?) that core already expresses, better and once
+    for the whole pipeline. A `benchmark` or `column` that is not on the
+    series **throws** rather than reading empty.
+  - **`correlation({ period = 30, column = 'close', benchmark, output = 'corr' })`**
+    → Pearson's `r` over the two **price** columns, `= talib.CORREL`
+    bar-for-bar. TA-Lib correlates the raw inputs, not their returns; the
+    return correlation is the same study over two `percentChange` columns.
+  - **`beta({ period = 5, column = 'close', benchmark, output = 'beta' })`** →
+    `cov(returns, benchmarkReturns) / var(benchmarkReturns)` over `period`
+    one-bar returns. **Pass prices** — the returns are taken inside, as
+    `percentChangeValues(v, 1)`. Equals `talib.BETA(benchmark, close)`
+    bar-for-bar: TA-Lib regresses its **second** input on its **first**
+    (measured), so the benchmark goes first there; pond's option names remove
+    the ambiguity.
+  - **`priceRelative({ column = 'close', benchmark, output = 'priceRel' })`** →
+    the bare ratio, with **no period and no warm-up**. ChartIQ's _Price
+    Relative_ and _Relative Strength (comparative)_ are one implementation;
+    neither is Wilder's `rsi`.
+  - **`performanceIndex({ period = 20, column = 'close', benchmark, output = 'perf' })`**
+    → each side's own `period`-bar growth, divided, so `1` is parity. The
+    **ratio** form ships (some vendors publish `× 100` or `− 1`);
+    `(perf − 1) × 100` is `percentChange(priceRelative, period)` identically,
+    which a test asserts.
+  - **`rollingBivariateValues(x, y, period)`** → `{ covariance, varianceX,
+varianceY }`, population (`ddof = 0`), over a **strict** pair window: all
+    `period` rows of **both** columns, or nothing. Shifted-frame Welford with
+    the aligned rebuild ([PND-SHIFTFRAME] / [PND-PROCKERN]), never
+    `Σxy − ΣxΣy/n` — measured at 1e12-scale prices, the textbook form returns a
+    negative variance (a non-finite correlation) where this holds 2.4e-15.
+    Validates `period` (integer `≥ 2`) at the boundary like every public
+    kernel, and rebuilds a window on demand when a changing column's `m2`
+    falls below `1e-3` of the gross shifted magnitude that has passed through
+    it since the last rebuild, or `cxy² > m2x·m2y` past rounding slack — so
+    no near-flat window reports a false missing cell or an out-of-range
+    correlation; tested against an exact BigInt-rational reference (review,
+    2026-09-07).
+  - **Two deliberate TA-Lib deltas, both measured**: a flat window is
+    `undefined` here and `0.0` in TA-Lib (`CORREL` and `BETA` both substitute
+    zero for a zero denominator), and a zero price is a **missing** return here
+    where TA-Lib substitutes a return of `0`.
+
+- `@pond-ts/financial`: **the Wilder directional group** (corpus §6.4) — three
+  studies and two new public kernels, in the uniform shape (redirectable bar
+  inputs, bar-count periods, length-preserving warm-up, a fluent method), each
+  with oracle cases at two periods.
+  - **`directionalMovement({ period = 14, high?, low?, close?, prefix = 'dmi' })`**
+    → `dmiPlusDi`, `dmiMinusDi`, `dmiDx`, `dmiAdx`, `dmiAdxr`. Wilder's Directional
+    Movement System — `+DI`, `−DI`, `DX`, `ADX` and `ADXR` in **one** study
+    with a **per-column warm-up** (bars 14 / 14 / 14 / 27 / 40 at the default),
+    the `macd` precedent rather than five studies re-running the same pipeline.
+    The `DI` denominator **is** `atr()`'s array, so the two measure range
+    identically by construction.
+    - **Seeding is Wilder's, not TA-Lib's**, and this is the one delta.
+      Wilder's worksheet seeds `+DM`/`−DM`/`TR` on the mean of the first
+      `period` values (what `wilderValues` runs, and what TA-Lib's own `ATR`
+      uses); TA-Lib's `ADX` family instead seeds on the first `period − 1` and
+      takes one decayed step, so TA-Lib's `+DI` denominator disagrees with
+      TA-Lib's own `ATR` (measured on the oracle input: `1.515450` vs
+      `1.411787` at `period 14`). Warm-up masks are identical to TA-Lib's on
+      all five columns; the oracle proves the **formula** exactly by replaying
+      our pipeline on TA-Lib's seed (`≤ 2.9e-14`) and bounds the pond-seed
+      transient separately — at `period 14`, `+DI` 0.117 points at the first
+      shared bar decaying to 0.0092 by bar 79, `ADX` 0.421 → 0.0046.
+    - **`ADXR` looks back `period − 1` bars**, TA-Lib's reading and the
+      package's own bar-count convention (a `period`-bar window spans
+      `i − period + 1 … i`). The literal "`period` bars ago" reading differs
+      by up to 2.64 points at `period 14`.
+    - **`+DI + −DI = 0` → `DX = 0`**, not `undefined`: both legs are
+      non-negative, so a zero sum forces a zero numerator (the `clvValues`
+      flat-bar rule, not the `percentOfRangeValues` flat-window one). A zero
+      **true range** is a genuine `0/0` and does read `undefined`.
+  - **`aroon({ period = 25, high?, low?, prefix = 'aroon' })`** → `aroonUp`,
+    `aroonDown`, `aroonOsc`. `100 · (period − bars since the extreme) / period`
+    on each side, and their difference. **Matches TA-Lib `AROON` and
+    `AROONOSC` exactly** (delta `0`, identical masks). The window is
+    **`period + 1` bars** — `period` counts the oldest _age_ reportable, and
+    "`period` bars ago" is itself a reading — so the warm-up is `period` rows;
+    **ties go to the most recent bar** (measured against TA-Lib). Invariant to
+    any monotonic rescaling of price, not merely to scale and shift.
+  - **`vortex({ period = 14, high?, low?, close?, prefix = 'vi' })`** →
+    `viPlus`, `viMinus`. Botes & Siepman's `Σ|high − prevLow| / Σ TR` and
+    `Σ|low − prevHigh| / Σ TR`. No TA-Lib function; pandas replication, with
+    the plain-bar-range denominator asserted as a visible separation. Both
+    legs are positive and **not bounded by 1**; `Σ TR = 0` → `undefined`
+    (unlike `DX`, the numerator is not forced to zero with it).
+  - **`directionalMovementValues(high, low)`** (`kernels/directional-movement.ts`)
+    — Wilder's `+DM`/`−DM` split in one pass, with the tie and sign rules and
+    an explicit `NaN` guard (an unknown move must not read as a flat one).
+  - **`barsSinceExtremeValues(values, period, 'max' | 'min')`**
+    (`kernels/highest-lowest.ts`) — the corpus's **G3 argmax gap**: bars since
+    the window's extreme, via a **monotonic deque**, so it is O(N) and _flat in
+    `period`_. Measured at 1M bars: 26.7 ms at `period 25` and 26.5 ms at
+    `period 200`, against a naive re-scan's 78 ms and 545 ms. `aroon` costs
+    102 ms at 1M bars against `donchian`'s 247 ms — the first measured
+    evidence for the monotonic-deque fast path core's rolling min/max wants.
+- `@pond-ts/financial`: **the volatility tail** (assessment §6.5) — seven
+  studies of range and drawdown, **none of which TA-Lib implements**, so every
+  one is a pandas replication in the oracle with its analytic first-valid bar
+  asserted _and_ a measured separation from the plausible wrong turn. Each
+  ships with a fluent method, two oracle cases, hand-computed unit values,
+  missing-cell placement tests, property tests and a perf entry.
+  - **`chaikinVolatility({ period = 10, rocPeriod = 10, high?, low?, output = 'chaikinVol' })`**
+    → `chaikinVol`. The percent rate of change of `EMA(high − low, 10)` over
+    the last 10 bars — is the average bar getting wider? **Plain** range, not
+    true range (Chaikin's; 35.6 points from the true-range version on the
+    oracle input). Two separate periods, both defaulting to 10, because the
+    smoothing span and the look-back are different quantities. First valid at
+    `period − 1 + rocPeriod`.
+  - **`massIndex({ emaPeriod = 9, sumPeriod = 25, high?, low?, output = 'mass' })`**
+    → `mass`. Dorsey's `Σ EMA(range)/EMA(EMA(range))` — range expansion with no
+    direction at all, which is the point of it (the 27 → 26.5 "reversal bulge"
+    warns that a trend will turn without saying which way). A **sum**, so a
+    steady market reads ≈ `sumPeriod`, not 0 or 1; the mean version is 24.1
+    away and is asserted apart. The EMA∘EMA chain follows the `trix` rule, so
+    the first valid bar is `2·emaPeriod + sumPeriod − 3` (bar 40 at the
+    defaults).
+  - **`choppinessIndex({ period = 14, high?, low?, close?, output = 'chop' })`**
+    → `chop`, bounded `0..100`. Dreiss' `100·log10(ΣTR/(HH−LL))/log10(period)`:
+    path walked against ground covered, **high = choppy, low = trending**, and
+    silent about direction. **True** range, the package's own `trueRangeValues`
+    (asserted `== talib.TRANGE`), 7.7 points from the plain-range version. The
+    log base cancels, which the generator asserts rather than assumes.
+    `period` must be **≥ 2** — `log10(1)` is zero.
+  - **`ulcerIndex({ period = 14, column?, output = 'ulcer' })`** → `ulcer`.
+    Peter Martin's downside-only volatility: the RMS percentage drawdown from
+    the window's own highest close. Ships the **rolling (StockCharts) form**;
+    Martin's cumulative original is one number per portfolio, not a series, and
+    is a documented delta rather than an option — as is the mean-**absolute**
+    variant, which is the Pain Index (1.53 away, asserted apart). Warm-up is
+    **`2·period − 2`**: two chained windows.
+  - **`verticalHorizontalFilter({ period = 28, column?, output = 'vhf' })`** →
+    `vhf`, a **fraction** in `(0, 1]`. Adam White's `(HH−LL)/Σ|Δ|` — the
+    opposite polarity to `chop`. Both halves read the **same** column, which is
+    what makes it composable over another study's output. Warm-up is `period`,
+    not `period − 1`: `period` changes need `period + 1` values, and the
+    one-term-shorter version is asserted apart.
+  - **`gopalakrishnanRangeIndex({ period = 10, high?, low?, output = 'gapo' })`**
+    → `gapo`. `ln(HH − LL)/ln(period)` — which _is_ the log of the window's
+    range in base `period`, since the base cancels. The **one study in the
+    batch that is not scale-invariant**: scaling every price by `k` shifts the
+    reading by exactly `ln(k)/ln(period)`, pinned as an identity rather than an
+    invariance. `period` must be **≥ 2**.
+  - **`relativeVolatilityIndex({ period = 14, stdevPeriod = 10, column?, output = 'relVol' })`**
+    → `relVol`, bounded `0..100`. Dorsey's RSI form with the population σ of
+    the close in place of the price change, **Wilder-smoothed** (his
+    definition; TradingView's EMA-smoothed fork is 31.3 points away and
+    measured). **The column is `relVol`, not `rvi`** — that belongs to
+    `relativeVigorIndex`, a completely different study, and the two now sit on
+    one series without collision. An unchanged close counts as a **down** bar,
+    deliberately unlike `rsi`'s split, which gives a flat bar 0 on both legs.
+
+  **One new kernel**, `barRangeValues` (`kernels/typical-price.ts`, not
+  public): the plain `high − low`, shared by `chaikinVolatility` and
+  `massIndex`. It is deliberately **not** `trueRangeValues` — the Wilder family
+  (ATR, Keltner, Choppiness) takes true range and the Chaikin/Dorsey family
+  takes plain range, because that is what each author defined, and neither
+  study exposes a knob to swap them.
+
+  **Two sharp edges worth knowing.** (1) `ulcerIndex` is the first study to
+  take a **square root** of a rolling mean, and an incremental accumulator's
+  `O(ε)` residue in the mean of squares becomes `1.6e-9` in the reading — right
+  where the answer should be exactly `0` (a window at new highs). The
+  contributing bars are counted so that reading is exact; the oracle case at
+  `period 5` is what caught it. (2) `rollingValues`' answer to a **misnamed
+  column** depends on the reducer: `stdev`/`avg` take the range-exact path and
+  read all-missing, `max`/`min` fall through to core's sweep and throw. So
+  `relativeVolatilityIndex` answers empty where `ulcerIndex` and
+  `verticalHorizontalFilter` throw. Both behaviours are pinned by tests and
+  documented on the studies; the fix belongs in the kernel.
+
+  **Zero-denominator guards, where they are and are not.** `choppinessIndex`
+  and `gopalakrishnanRangeIndex` divide (or take a logarithm) at their
+  **output**, so a non-finite result would reach `withColumn` — which throws on
+  `±Infinity` — and their guards are load-bearing. `massIndex` and `ulcerIndex`
+  divide **upstream of a rolling summation**, which counts a non-finite cell as
+  missing exactly as it counts a `NaN`, so their guards were unobservable and
+  were removed after mutation testing; the behaviour (`undefined`, never an
+  infinity) is unchanged and still unit-tested. `verticalHorizontalFilter` and
+  `relativeVolatilityIndex` need none at all — a zero denominator forces a zero
+  numerator in both.
+
+- `@pond-ts/financial`: **the volume & money-flow group** (corpus §6.6) — eight
+  studies over one new kernel, all in the uniform shape (redirectable bar
+  inputs, bar-count periods, length-preserving warm-up, a fluent method) and
+  each with oracle cases at two parameterisations where it has a period.
+  - **`accumulationDistribution({ high?, low?, close?, volume?, output = 'ad' })`**
+    → `ad`. Chaikin's running total of `CLV × volume`, where
+    `CLV = ((close − low) − (high − close)) / (high − low)` grades _where in
+    its own range_ a bar closed. Like `obv` it has **no period** and no
+    warm-up. **Matches TA-Lib `AD` exactly** (delta `0`) on bars with a range.
+  - **`chaikinOscillator({ fastPeriod = 3, slowPeriod = 10, high?, low?, close?, volume?, output = 'chaikinOsc' })`**
+    → `chaikinOsc`. `EMA(A/D, 3) − EMA(A/D, 10)`, the A/D line's momentum.
+    **Matches TA-Lib `ADOSC` exactly** (delta `0`, identical masks) — the one
+    EMA-family study here with **no seed delta**, because TA-Lib's own `ADOSC`
+    seeds both EMAs on the first A/D value, which is pond's convention. (The
+    oracle also asserts the SMA-seeded reconstruction is visibly different, so
+    the case pins which seed ships.)
+  - **`priceVolumeTrend({ close?, volume?, output = 'pvt' })`** → `pvt`. The
+    running total of `volume × (close − prevClose)/prevClose` — OBV's idea
+    scaled by _how far_ price moved. The **fraction**, not the percent: it
+    composes on the `ROC` kernel and divides by 100, which is the one place
+    that constant appears. **`pvt[0]` is `undefined`, not `0`** — the term
+    needs a previous close, and unlike OBV there is no vendor convention to
+    seed from; every later level is identical either way.
+  - **`chaikinMoneyFlow({ period = 20, high?, low?, close?, volume?, output = 'cmf' })`**
+    → `cmf`. `Σ CLV·volume / Σ volume` over the window — the A/D term as a
+    **bounded** `[−1, +1]` reading. Runs on the same `rollingWeightedMeanValues`
+    kernel as `vwap`, so it inherits its edge rules; `Σ volume = 0` →
+    `undefined`.
+  - **`moneyFlowIndex({ period = 14, high?, low?, close?, volume?, output = 'mfi' })`**
+    → `mfi`. The RSI form on raw money flow (`typical price × volume`, split
+    by the direction of the typical price). **Matches TA-Lib `MFI`** to
+    `2.8e-14` with identical masks. Warm-up is **`period` rows, not
+    `period − 1`** (the first bar has no previous typical price), the `rsi` /
+    `atr` off-by-one.
+  - **`forceIndex({ period = 13, close?, volume?, output = 'force' })`** →
+    `force`. Elder's `EMA((close − prevClose) × volume, 13)`; **`period: 1` is
+    the raw, unsmoothed force**, so no `smooth: false` flag is needed. No
+    `maType` — Elder names the EMA (the `elderRay` precedent).
+  - **`easeOfMovement({ period = 14, maType = 'sma', scale = 100_000_000, high?, low?, volume?, output = 'eom' })`**
+    → `eom`. Arms' midpoint move divided by the box ratio
+    `(volume / scale) / (high − low)`, MA-smoothed. `scale` is StockCharts' /
+    ChartIQ's constant and is a **pure linear multiplier**, exposed because the
+    right value depends on the instrument's volume units, not on taste. A flat
+    bar and a zero-volume bar both report `undefined` (two zero denominators).
+  - **`volumeOscillator({ fastPeriod = 5, slowPeriod = 10, maType = 'sma', volume?, output = 'volOsc' })`**
+    → `volOsc`. `100 · (MA(volume, 5) − MA(volume, 10)) / MA(volume, 10)`. This
+    is **literally `priceOscillator`'s percent mode over the volume column**, so
+    it delegates to it rather than restating the arithmetic — a test pins the
+    identity. What the wrapper adds is the name and the volume-appropriate
+    defaults (5/10/sma against 12/26/ema).
+
+  **Volume Rate of Change is not a study**: the corpus names it, but
+  `percentChange({ column: 'volume' })` _is_ its definition (and is
+  TA-Lib-verified through `ROC`), so what ships is a recipe note in API.md and
+  a test that pins it — step 0 of the studies README.
+
+  **One new kernel**, `clvValues` / `accumulationDistributionValues`
+  (`kernels/close-location.ts`), shared by A/D, the Chaikin oscillator and CMF.
+  A **flat bar (`high === low`) has a close location of exactly `0`** — its
+  numerator `(c − l) − (h − c)` is forced to zero, so `0` is the value rather
+  than a convention — and so A/D matches TA-Lib's `AD` on every bar, halts
+  included, and CMF counts the bar's volume in its denominator as every
+  conventional CMF does. A window with **no money flow at all**
+  makes `mfi` `undefined` where TA-Lib reports `0` — and TA-Lib reports `0`
+  for any window whose total flow is merely below `1.0`, measured returning `0`
+  where the answer is `100` on a rising series with `1e-9` volume.
+
+- `@pond-ts/financial`: **the momentum tail** (assessment §6.3) — six
+  oscillators, all of them ratios rather than price-unit quantities, so all six
+  are invariant to **both** a scale factor and a constant shift (pinned by
+  property tests, which is the pair that catches a dropped normalisation).
+  Each ships with a fluent method, two oracle cases, hand-computed unit values,
+  missing-cell placement tests and a perf entry.
+  - **`chandeMomentum({ period = 14, column = 'close', output = 'cmo' })`** →
+    `cmo`, bounded `−100..100`. `100·(Σup − Σdown)/(Σup + Σdown)` over
+    **Chande's unsmoothed** window sums. **This is deliberately not TA-Lib's
+    `CMO`**, which Wilder-smooths the legs and is therefore exactly
+    `2 · rsi − 100` — a second name for a shipped column. The generator asserts
+    that identity (2.8e-14) as the reason, and measures the definition delta:
+    68.28 points at `period 14`, 131.55 at `period 5`, warm-ups identical.
+  - **`ultimateOscillator({ shortPeriod = 7, mediumPeriod = 14, longPeriod = 28, high?, low?, close?, output = 'uo' })`**
+    → `uo`, bounded `0..100`. Williams' three-horizon blend of buying pressure
+    over true range, weighted 4/2/1. Matches **TA-Lib `ULTOSC`** to 7.1e-15 with
+    identical masks; the true range is the package's own kernel, asserted equal
+    to `talib.TRANGE` exactly. Three **named** periods (not a tuple — the
+    weights are positional), validated strictly increasing.
+  - **`commodityChannelIndex({ period = 20, high?, low?, close?, output = 'cci' })`**
+    → `cci`. `(tp − SMA(tp))/(0.015 · meanAbsDev(tp))`, matching **TA-Lib
+    `CCI`** to 3.6e-12. Unbounded — ±100 is a convention, not a limit. A
+    zero-deviation window is `undefined` rather than TA-Lib's `0`.
+  - **`intradayMomentumIndex({ period = 14, open?, close?, output = 'imi' })`**
+    → `imi`, bounded `0..100`. RSI's form over the candle **body**, with
+    **plain** window sums rather than Wilder smoothing (Chande's definition; the
+    corpus's "RSI form" is the ambiguity this pins). Warm-up is `period − 1`, a
+    row shorter than `rsi`/`chandeMomentum`, because a body needs no previous
+    bar. Over identical legs `imi = (cmo + 100)/2`, which a test pins.
+  - **`relativeVigorIndex({ period = 10, open?, high?, low?, close?, prefix = 'rvi' })`**
+    → `rvi` / `rviSignal`. TradingView's definition: ratio of `SWMA(close −
+open)` sums to `SWMA(high − low)` sums, signal a fourth SWMA. **SWMA is the
+    symmetric `(1,2,2,1)/6` filter, not the K2 engine's linear `wma(4)`** — a
+    test pins the impulse response. The first study to read all four OHLC
+    columns.
+  - **`psychologicalLine({ period = 12, column = 'close', output = 'psy' })`** →
+    `psy`, bounded `0..100` and quantised to multiples of `100/period`. An
+    unchanged close is **not** an up bar (strict `>`), and a bar with no close
+    leaves both itself and its successor undirected.
+
+  **Kernels.** Three additions, none public: `rollingMeanAbsDevValues`
+  (CCI's denominator — the package's only **O(N·period)** kernel; the cost is
+  measured, and the `O(N log period)` order-statistic form that would replace
+  it is written down rather than left to be rediscovered),
+  `symmetricWeightedValues` (the 4-bar SWMA), and `upDownLegValues` (the
+  gain/loss split, now shared by `rsi`, `chandeMomentum` and
+  `intradayMomentumIndex` — `rsi` was moved onto it, with no change to its
+  numbers).
+
+- `@pond-ts/financial`: **five K2 consumers** — the first studies built on the
+  moving-average engine, two channels and three smoothed rates. All five take
+  the uniform shape (bar-count periods, redirectable inputs, length-preserving
+  warm-up, a fluent method) and each has two oracle cases.
+  - **`keltner({ period = 20, atrPeriod = 10, multiplier = 2, maType = 'ema', high?, low?, close?, prefix = 'kc' })`**
+    → `kcMiddle` / `kcUpper` / `kcLower`. A moving average of **typical price**
+    with bands at ±`multiplier` × **ATR**. The variant is pinned: this is the
+    **modern** form (Chester Keltner via Linda Raschke, and ChartIQ's default) —
+    EMA(20) of typical price ± 2 × ATR(10). Keltner's 1960 original used ±1 ×
+    the SMA of the **plain** high−low range; the half-width here is always
+    _true_ range, which is a documented delta rather than an option.
+    Warm-up is **per column** (the `macd` rule): the centre from the MA's own
+    first bar, the bands from `max(centre, ATR)`.
+  - **`atrBands({ period = 14, multiplier = 2, column = 'close', high?, low?, close?, prefix = 'atrb' })`**
+    → `atrbUpper` / `atrbLower`. **Two** columns, not three: the middle is
+    `column` itself, already on the series. `column` (what the bands are drawn
+    around) is separate from `close` (what the ATR is measured from), so the
+    bands can sit on an `sma` while the volatility still comes off the raw bars.
+    `atrbUpper === column + multiplier × atr()` **bit-for-bit** — both call one
+    shared `atrValues` kernel — and a test pins it against the shipped `atr`.
+  - **`qstick({ period = 8, maType = 'sma', open?, close?, output = 'qstick' })`**
+    → `qstick`. Chande's moving average of the candle body, `close − open`; the
+    candlestick chart's colour, quantified, read against its zero line. The
+    **first study to read `open`**, which joins the named bar inputs.
+  - **`trix({ period = 15, signalPeriod = 9, column?, prefix = 'trix' })`** →
+    `trix` / `trixSignal`. The 1-bar **percent** rate of change of a
+    triple-smoothed EMA, plus an EMA signal (9 is ChartIQ's default; TA-Lib
+    returns the line alone). The line takes the prefix itself, not
+    `${prefix}Line`. It composes **three** EMA passes — TRIX wants `EMA³`, which
+    is _not_ the menu's `tema` (`3·EMA − 3·EMA² + EMA³`), and a test pins the
+    difference.
+  - **`coppock({ longPeriod = 14, shortPeriod = 11, wmaPeriod = 10, column?, output = 'coppock' })`**
+    → `coppock`. `WMA(ROC(14) + ROC(11), 10)`. Coppock's lengths are **months**
+    on a monthly index chart; the study is bar-count like every other here, so
+    on daily bars it is a short-horizon oscillator and not the indicator he
+    defined — stated on the study. The weighted average is part of the
+    definition, so there is no `maType` knob.
+
+  **Oracle.** `trix` is cross-checked against **TA-Lib `TRIX`**: the formula is
+  asserted **bit-exact on TA-Lib's own SMA seed** (2.2e-14, identical null
+  masks — which is what catches a log-vs-percent rate of change, a dropped
+  stage, or a `tema` substitution), with pond's first-sample EMA seed bounded as
+  a decaying transient (8.75% of scale at the first shared bar → 0.85% over the
+  last 20 at `period 15`, against 8.5% / 9.8% for the wrong smoothing rates).
+  TA-Lib has no Keltner, ATR-band, QStick or Coppock function, so those four are
+  pandas replications — but the ATR half-width and the rates of change reuse the
+  references TA-Lib already validates, so what each case adds is the assembly
+  and its composed warm-up, each asserted as an analytic first-valid bar. The
+  oracle fixture gains an **`opens`** column (the previous close pulled inside
+  its own bar; 30 of 80 bodies negative, all 80 distinct).
+
+- `@pond-ts/financial`: **five price-vs-moving-average oscillators** — the
+  first consumers of the K2 moving-average engine. All five ship with fluent
+  methods, oracle cases at two parameterisations each, and property tests.
+  - **`priceOscillator({ fastPeriod = 12, slowPeriod = 26, maType = 'ema',
+mode = 'percent', column = 'close', output = 'priceOsc' })`** — the
+    spread between two moving averages, as a percent of the slow one
+    (TA-Lib's **PPO**) or in price units (`mode: 'absolute'`, TA-Lib's
+    **APO**). **Percent is the default** for two reasons: the absolute form
+    at the default parameters is `macd()`'s line bar-for-bar (a test pins the
+    identity), and the percent form is the scale-invariant, cross-instrument
+    comparable one. `{ maType: 'sma', mode: 'absolute' }` matches TA-Lib's
+    `APO(matype=0)` to `7.1e-14` with an identical mask; on `'ema'` pond's
+    first-sample EMA seed is kept (the `macd` precedent), so the generator
+    proves the **formula** on TA-Lib's own SMA seed (`2.8e-14`) and bounds
+    the **seed transient** separately — 6.61% of scale at the first shared
+    bar, 0.41% at its worst over the last 20.
+  - **`disparityIndex({ period = 14, maType = 'sma', column, output =
+'disparity' })`** — `100·(price − MA)/MA`, scale-invariant. No TA-Lib
+    function; pandas replication with the analytic first-valid bar asserted.
+  - **`detrendedPriceOscillator({ period = 20, maType = 'sma', column,
+output = 'dpo' })`** — `price[i] − MA[i − shift]` with
+    `shift = ⌊period/2⌋ + 1` (it **floors** on odd periods). This is the
+    **non-centered** alignment (TradingView's default); StockCharts'
+    centered `price[i − shift] − MA[i]` is a different series, not a
+    re-plotting of this one, and is documented as such on the study. First
+    value on bar `period − 1 + shift` (bar 30 at the defaults).
+  - **`elderRay({ period = 13, high, low, close, prefix = 'elder' })`** —
+    appends `elderBull` = `high − EMA(close)` and `elderBear` =
+    `low − EMA(close)`. Elder's definition names the EMA, so there is no
+    `maType` knob. No TA-Lib function; pandas replication on pond's EMA seed.
+  - **`awesomeOscillator({ fastPeriod = 5, slowPeriod = 34, high, low,
+output = 'ao' })`** — `SMA(5) − SMA(34)` of the median price
+    `(high + low)/2`. Both legs wait for that many finite **values** (the
+    derived-array rule), so a gap masks the windows containing it. No TA-Lib
+    function; pandas replication.
+
+  Internally this adds one kernel helper, `medianPriceValues(high, low)`,
+  beside `typicalPriceValues` — 7.6 ms at 1M bars, and named consumers next
+  (Alligator, Gator, High-Low Bands). It is not a public export.
+
+- `@pond-ts/financial`: **the K2 moving-average engine** — one **MA-type
+  vocabulary** shared by every study that exposes a "MA Type" input (~25 of
+  them in the corpus assessment). New study **`movingAverage({ period, type =
+'sma', column = 'close', output = 'ma' })`** with fluent
+  `.movingAverage()`, new exported type **`MaType`** and its **`MA_TYPES`**
+  menu, and the raw-array kernel **`movingAverageValues(values, period,
+type)`** for studies whose input is derived rather than a column (Keltner's
+  typical price, Coppock's WMA of two ROCs, the Price Oscillator).
+
+  Ten types: `sma`, `ema`, `wma` (linear weights), `smma` (Wilder/RMA),
+  `dema` (`2·EMA − EMA²`), `tema` (`3·EMA − 3·EMA² + EMA³`), `trima`
+  (TA-Lib's SMA-of-SMA, lengths summing to `period + 1`), `hull`
+  (`WMA(2·WMA(n/2) − WMA(n), round √n)`), `kama` (Kaufman, TA-Lib's fast 2 /
+  slow 30) and `zlema` (`EMA(2x − x[i−lag])`, `lag = ⌊(period−1)/2⌋` — it
+  floors, so `zlema(10)` and `zlema(11)` share a lag). Deferred, and named as
+  deferred: MAMA/FAMA, T3, VIDYA (needs the K6 recursion) and the
+  time-series/regression forecast MA (kernel K7).
+
+  **`type: 'sma'` and `type: 'ema'` are the calls `sma()` and `ema()` already
+  make** — routed back to `rollingValues` / `smooth('ema')`, so they are the
+  same doubles rather than a second implementation, and stay on their
+  accelerated paths. Pinned bit-for-bit by test.
+
+  **Oracle**: every type has cases at two periods. `sma` / `wma` / `trima` /
+  `kama` match TA-Lib's `MA(matype=…)` **exactly** (≤ 5.7e-13, identical null
+  masks; `kama` to `0`). `ema` / `dema` / `tema` keep **pond's first-sample
+  EMA seed** rather than TA-Lib's SMA seed — the `macd` precedent, so
+  `movingAverage({ type: 'ema' })` cannot disagree with `ema()` inside our own
+  package. Masks are still identical; the values are a decaying seed
+  transient, measured at 0.210% / 0.529% / 0.059% of scale at the first shared
+  bar (period 21) falling to 0.0008% / 0.0155% / 0.0144% by bar 79, and
+  asserted as a tail bound. `smma` / `hull` / `zlema` have no TA-Lib function
+  and are pandas replications with their analytic warm-up asserted (`smma`
+  also pinned bit-for-bit against the `wilderValues` kernel RSI and ATR run
+  on).
+
+  **Interior gaps differ by type, deliberately** (the Wilder asymmetry, now
+  stated per type on the kernel): the window types recover once the gap leaves
+  the window, the `ema` family skips the missing bar and carries on, and
+  `smma` and `kama` propagate to the end — a recursion that consumes every bar
+  has no state to carry across a hole. `sma` is also the one type a leading
+  gap does **not** shift, because it keeps `sma()`'s row-counting window.
+
+### Changed
+
+- `@pond-ts/financial`: **`envelope`'s `maType` widens from `'sma' | 'ema'` to
+  the full `MaType` menu** and routes through the shared engine. Strictly
+  additive for existing callers — the `sma` and `ema` centre lines are the
+  same kernel calls as before, pinned bit-for-bit — and an unknown `maType`
+  now throws instead of silently falling back to SMA. (On the raw-array door,
+  `movingAverageValues(…, 'sma')` waits for `period` finite values like every
+  other type; the column door keeps `sma()`'s rows window.)
+- `pond-ts`: `partitionBy(column, options)` now throws a `TypeError` on an
+  unknown option key (e.g. `maxPartitions`, which was never implemented)
+  instead of silently ignoring it. Only JS callers passing a key the type
+  rejects are affected; the error names the known keys ([PND-LIVFIX]).
+
+### Fixed
+
+- `pond-ts` live layer, the [PND-LIVFIX] cluster — the five confirmed
+  wrong-answer defects from the 2026-06 audits, each now pinned by a test:
+  - **Listener errors are isolated.** A `LiveSeries` / `LiveView` listener
+    that throws no longer aborts the push: every row still commits, the
+    remaining listeners still run, retention still runs and `'batch'` /
+    `'evict'` still fire; the first error is rethrown to the caller once
+    the push has completed. Before, a throw skipped retention (the buffer
+    sat over `maxEvents` until the next push) and left every later
+    subscriber — a derived `filter()` view included — permanently out of
+    sync.
+  - **Re-entrancy.** A listener may subscribe or unsubscribe during
+    dispatch without disturbing the fan-out (a listener added mid-event
+    does not fire for that event), and a `push` made from inside a
+    listener is queued and delivered after the current push, in order.
+    Before, a re-entrant push emitted out of order, was spuriously
+    rejected as out-of-order on the chunked backing, and broke an attached
+    view with an error that read `[object Object]` (keys in that message
+    now print as ISO timestamps).
+  - **Quiet partitions evict by age.** Per-partition `maxAge` was
+    push-driven, so a partition that stopped receiving events kept them
+    forever. `partitionBy` now sweeps every partition against the source
+    watermark as it advances (throttled to `maxAge / 8`), emitting
+    `'evict'` as push-driven retention does.
+  - **Chain-aware `LiveView.dispose()`.** Disposing the last view of
+    `live.filter(p).map(f)` now disposes the unreachable intermediate too
+    (a source view left with no subscribers is torn down; one with another
+    subscriber is not). `dispose()` is idempotent and documented.
+  - **`LiveReduce` windowed reducers on a `reorder` source with
+    retention.** `min` / `max` / `first` / `last` reported stale or
+    `undefined` values because their sliding-window state assumed
+    oldest-arrived-first eviction; over a `reorder` source they now use
+    removal-by-any-index structures (exact in any eviction order, O(n)
+    per update, selected only on that source shape).
+
+## [0.65.0] — 2026-09-06
+
+### Added
+
+- `@pond-ts/financial`: **`stochastic(...)`**, **`williamsR(...)`** and
+  **`donchian(...)`** — the three range-position studies, built on one new
+  kernel (`highestLowestValues`: the trailing highest high / lowest low in a
+  single `rolling` scan) plus fluent `.stochastic()` / `.williamsR()` /
+  `.donchian()`. All name their bar inputs per column (`high` / `low` /
+  `close`, defaulting to `DEFAULT_OHLCV`), the `atr` shape.
+
+  **`stochastic`** — `{ kPeriod = 14, slowing = 3, dPeriod = 3, prefix =
+'stoch' }` appending `stochK` / `stochD`: the slow stochastic, with
+  `slowing: 1` giving the fast one (TA-Lib's `STOCHF`) from the same
+  function. Values match TA-Lib's `STOCH`/`STOCHF` to `5.7e-14` on every bar
+  TA-Lib emits, `%D` with an identical warm-up. Two deliberate deltas,
+  both documented on the study: **`%K` starts when it can** (bar 15 at the
+  defaults) where TA-Lib masks it back to `%D`'s first bar (17), discarding
+  `dPeriod − 1` real values — the `macd` precedent; and **a flat window
+  (`HH === LL`) is `undefined`** where TA-Lib reports `0`, which is also its
+  value for "close at the very bottom of a real range" — the `rsi` precedent.
+  The smoothing uses a new raw-array kernel, `rollingMeanValues`, that waits
+  for `slowing` _values_ rather than rows: a scratch-column SMA would have
+  put a "3-bar" `%K` on bar 13 with one value in it.
+
+  **`williamsR`** — `{ period = 14, output = 'williamsR' }`, bounded
+  `−100..0`. Matches TA-Lib's `WILLR` bar-for-bar to `1.4e-14` with an
+  identical warm-up; the only delta is the same flat-window `undefined`.
+  It is fast `%K − 100`, computed on the same kernel, and a test pins that
+  identity against `stochastic({ slowing: 1 })`.
+
+  **`donchian`** — `{ period = 20, prefix = 'dc' }` appending `dcUpper` /
+  `dcLower` / `dcMiddle`. `upper` is exactly `rollingMax(high)` and `lower`
+  exactly `rollingMin(low)` (pinned), in one scan plus the midpoint; pandas
+  oracle only (TA-Lib has no Donchian). Scales linearly with price, like
+  `atr`; a missing `high`/`low` is skipped (core's reducer policy), not
+  propagated.
+
+- `@pond-ts/financial`: **`obv(...)`** and **`vwap(...)`** — the first two
+  **volume** studies, plus fluent `.obv()` / `.vwap()`. Both name their inputs
+  per column (`close` / `volume`, and `high` / `low` for VWAP), each
+  defaulting to its `DEFAULT_OHLCV` name, the rule `atr` established.
+
+  **`obv`** is Granville's On-Balance Volume — the running total of each bar's
+  volume signed by its close change — and is the first study with **no
+  `period`**: it is read for its shape, not its level, so there is nothing to
+  size a window over. It is **TA-Lib's OBV exactly**, including the seed
+  (`OBV[0] = volume[0]`) and an unchanged close adding nothing; the oracle
+  asserts equality, with an identical (empty) warm-up mask. On **interior
+  gaps** it deliberately departs from TA-Lib: a running sum has no local
+  answer for a missing term, so a missing close or volume leaves the level
+  `undefined` from that bar on (the same asymmetry the Wilder recursion has —
+  a leading gap shifts the seed, an interior one propagates). TA-Lib has no
+  gap semantics; measured on a seven-bar series it is 400 out of level at
+  the gap bar and 100 out from then on, presented as a value.
+
+  **`vwap`** is a **rolling** Volume-Weighted Average Price:
+  `Σ typicalPrice · volume / Σ volume` over `period` bars, typical price
+  `(high + low + close) / 3`. There is no TA-Lib VWAP and no single
+  definition, so this is a documented design choice: the rolling form fits
+  the package's count-window shape, and the intraday desk's _anchored_ VWAP
+  is not a special case of it (a count window emits only once it spans
+  `period` rows) — that one needs a session reset and is deferred to the
+  session-anchored phase. `period` is **required** (no conventional length to
+  default to). A window with no volume is `undefined`; a bar missing any
+  input is dropped from **both** sums so the ratio is never biased. Verified
+  against a pandas replication on a fixture whose volume spikes make a
+  dropped weighting visible (≥ 1.24 price units from the plain mean).
+
+  The oracle fixture gains a `volumes` input, and four kernels land under
+  them for the studies that follow: `cumulativeValues` (A/D line, PVT),
+  `signedVolumeValues`, `typicalPriceValues` (CCI, MFI, Keltner) and
+  `rollingWeightedMeanValues` (VWMA).
+
+- `@pond-ts/financial`: **`atr(...)`** — Wilder's Average True Range, the third
+  [PND-STUDY] named indicator, plus a fluent `.atr()`. `{ period = 14,
+high = 'high', low = 'low', close = 'close', output = 'atr' }`. Verified
+  against **TA-Lib** bar-for-bar in the oracle — exact agreement at both
+  periods tested, with identical warm-up.
+
+  **The first multi-input study.** Where every study so far took a single
+  `column`, ATR names each of its three inputs, each defaulting to its
+  `DEFAULT_OHLCV` name — the same "never hard-code a column" rule applied per
+  input rather than a new mechanism. Because the inputs are columns of one
+  series they are aligned by construction, so the mismatched-length error
+  array-based libraries must check for at every call is unrepresentable here.
+
+  Warm-up is `period` rows, not `period − 1`: true range needs a previous
+  close, so bar 0 has none.
+
+- `@pond-ts/financial`: **`macd(...)`** — Moving Average Convergence/Divergence,
+  the second [PND-STUDY] named indicator. `{ fastPeriod = 12, slowPeriod = 26,
+signalPeriod = 9, column = 'close', prefix = 'macd' }`, appending
+  `macdLine` / `macdSignal` / `macdHist`, plus a fluent `.macd()`.
+
+  Two deliberate deltas from TA-Lib, both documented on the study:
+  **each column warms up when it can** (the line at bar 25, signal and
+  histogram at 33) where TA-Lib masks all three back to 33, keeping eight real
+  values it discards; and the EMAs are **pond's own** (`α = 2/(span+1)` seeded
+  on the first sample — what `ema()` already ships) rather than TA-Lib's
+  SMA-seeded ones. The second is a _seed_ difference, so it decays: measured
+  at 3.8% of the line's magnitude at the first shared bar, 0.089% by bar 79.
+  Seeding TA-Lib's way would make `macd()` disagree with
+  `ema(fast) − ema(slow)` inside this package, which is the worse surprise —
+  and is pinned by a test.
+
+- `@pond-ts/financial`: **`rsi(...)`** — Wilder's Relative Strength Index, the
+  first of the [PND-STUDY] named indicators. `{ period = 14, column = 'close',
+output = 'rsi' }`, length-preserving warm-up (`period` rows, not `period − 1`
+  — RSI averages _differences_, so it needs one extra bar), and a fluent
+  `.rsi()`. Verified against **TA-Lib** bar-for-bar in the oracle fixture,
+  agreeing to `1.4e-14`.
+
+  Worth knowing which RSI this is: the gain/loss averages are seeded on the
+  arithmetic mean of the first `period` differences, then carried by Wilder's
+  recursion — TA-Lib's definition and Wilder's original. Implementations that
+  instead smooth with a plain first-sample-seeded EMA of the same `α = 1/period`
+  produce a **materially different** series: on this package's own oracle input
+  the two sit up to **7.03 RSI points** apart, and are still `0.15` apart 65
+  bars later. That is enough to move a reading across the conventional 70/30
+  thresholds, so it is a definition choice rather than a rounding detail.
+
+- `@pond-ts/financial`: **`momentum(...)`** — the absolute `period`-bar
+  difference, `value − value[i − period]`. `{ period = 10, column = 'close',
+output = 'momentum' }`, warm-up `period` rows, plus a fluent `.momentum()`.
+  Verified against **TA-Lib's `MOM`** bar-for-bar in the oracle: exact
+  agreement with identical warm-up masks. The additive companion to
+  `percentChange`'s ratio; it is in the price's units and scales with them
+  (pinned by a property test).
+
+- `@pond-ts/financial`: **`historicalVolatility(...)`** — the standard
+  deviation of log returns over `period` bars, annualised.
+  `{ period = 20, annualize = 252, column = 'close', output = 'hv' }`, plus a
+  fluent `.historicalVolatility()`. Warm-up is `period` rows, not
+  `period − 1` — `period` returns need `period + 1` prices, the same
+  off-by-one RSI and ATR have.
+
+  TA-Lib has no HV to arbitrate the conventions, so they are pinned on the
+  study and in the pandas oracle (`np.log(s).diff().rolling(n).std(ddof=0)
+· √annualize`): **population σ** (`ddof = 0`, the package convention shared
+  with Bollinger / `rollingStdev` / `zScore`; a sample σ is
+  `√(n/(n−1))` larger — 2.6% at 20); **log returns**, not simple; annualised
+  by `√annualize` with `252` the default for daily bars and an **option**
+  rather than a hidden constant (`1` for per-bar σ, `252·390` for one-minute
+  bars); and a **decimal** (`0.18` = 18%), the form volatility is consumed
+  in. Scale-invariant, pinned by a property test. A non-positive price has
+  no log return: both returns touching it are missing (explicitly, since
+  `ln(−4/−5)` is a finite non-answer). A leading gap shifts the start so the
+  first window still covers `period` real returns, matching pandas'
+  `min_periods` and the Wilder-family studies — the σ is computed by calling
+  the range-exact kernel on the returns array directly, because a scratch
+  column through `rollingValues` counts rows and would emit one bar early
+  over one return too few.
+
+- `@pond-ts/financial`: **`percentChange` is ROC** — TA-Lib's `ROC` is the same
+  `(price / prevPrice − 1) × 100`, and the oracle now cross-checks the study
+  against it: exact agreement (`0.0`) with identical warm-up masks at both
+  periods. Documented on the study and in API.md; there is deliberately no
+  separate `roc` study.
+
 ## [0.64.0] — 2026-08-28
 
 ### Added