@hoox-sh/pynets 0.1.0

package/src/runtime/ta.ts

@@ -0,0 +1,2093 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Incremental TA (Python `TechnicalHelpers` SoT).
+ * Stateful per call-site; one sample per bar.
+ */
+
+export type Cell = number | null;
+
+interface SmaState {
+  period: number;
+  window: Cell[];
+  sum: number;
+  count: number;
+}
+
+interface EmaState {
+  period: number;
+  ema: number | null;
+  seeded: boolean;
+  seedBuf: number[];
+}
+
+interface RmaState {
+  period: number;
+  rma: number | null;
+  seeded: boolean;
+  started: boolean;
+  seedBuf: number[];
+}
+
+interface AtrState {
+  period: number;
+  prevClose: Cell;
+  rma: RmaState;
+}
+
+interface RsiState {
+  period: number;
+  prev: number | null;
+  gainSeed: number[];
+  lossSeed: number[];
+  avgGain: number | null;
+  avgLoss: number | null;
+  seeded: boolean;
+}
+
+interface TrState {
+  prevClose: Cell;
+}
+
+interface HighestLowestState {
+  period: number;
+  window: Cell[];
+}
+
+interface StdevState {
+  period: number;
+  window: Cell[];
+  sum: number;
+  sumsq: number;
+  count: number;
+}
+
+interface ChangeState {
+  length: number;
+  window: Cell[];
+}
+
+interface WmaState {
+  period: number;
+  window: Cell[];
+}
+
+interface VwmaState {
+  period: number;
+  srcWindow: Cell[];
+  volWindow: Cell[];
+  sumPv: number;
+  sumV: number;
+  naCount: number;
+}
+
+interface CrossState {
+  prevA: Cell;
+  prevB: Cell;
+  started: boolean;
+}
+
+interface LinregState {
+  period: number;
+  offset: number;
+  window: Cell[];
+}
+
+interface VwapState {
+  cumPv: number;
+  cumV: number;
+  value: Cell;
+}
+
+interface RiseFallState {
+  length: number;
+  prev: Cell;
+  streak: number;
+  started: boolean;
+}
+
+interface AlmaState {
+  period: number;
+  offset: number;
+  sigma: number;
+  window: Cell[];
+  weights: number[];
+  wsum: number;
+}
+
+interface CmoState {
+  period: number;
+  window: Cell[];
+  up: number;
+  down: number;
+}
+
+interface KamaState {
+  period: number;
+  fast: number;
+  slow: number;
+  prices: number[];
+  diffs: number[];
+  vol: number;
+  kama: number | null;
+  seeded: boolean;
+  bars: number;
+}
+
+interface ObvState {
+  prev: Cell;
+  obv: number;
+  bars: number;
+}
+
+interface AccdistState {
+  ad: number;
+}
+
+interface PivotState {
+  left: number;
+  right: number;
+  window: Cell[];
+  n: number;
+}
+
+interface MfiState {
+  period: number;
+  tps: Cell[];
+  mfs: Cell[];
+}
+
+interface SarState {
+  start: number;
+  increment: number;
+  maximum: number;
+  started: boolean;
+  sar: Cell;
+  ep: Cell;
+  trend: number;
+  af: number;
+}
+
+interface AdxState {
+  period: number;
+  prevH: Cell;
+  prevL: Cell;
+  prevC: Cell;
+  n: number;
+}
+
+interface DmiState {
+  diLen: number;
+  prevH: Cell;
+  prevL: Cell;
+  prevC: Cell;
+}
+
+interface CorrState {
+  length: number;
+  a: Cell[];
+  b: Cell[];
+}
+
+interface SwmaState {
+  period: number;
+  window: Cell[];
+  weights: number[];
+  wsum: number;
+}
+
+interface WindowState {
+  period: number;
+  window: Cell[];
+}
+
+interface TsiState {
+  longPeriod: number;
+  shortPeriod: number;
+  prev: Cell;
+  nBars: number;
+  value: Cell;
+}
+
+interface CumState {
+  total: number;
+}
+
+interface BarsSinceState {
+  everTrue: boolean;
+  barsSince: number;
+}
+
+interface ValueWhenState {
+  occurrence: number;
+  hits: Cell[];
+}
+
+interface PercentileState {
+  period: number;
+  percentage: number;
+  window: Cell[];
+}
+
+interface PvtState {
+  pvt: number;
+  prev: Cell;
+}
+
+interface WadState {
+  wad: number;
+  prev: Cell;
+  started: boolean;
+}
+
+interface VolIndexState {
+  value: number;
+  prevClose: Cell;
+  prevVol: Cell;
+  started: boolean;
+}
+
+interface WvadState {
+  value: number;
+}
+
+export type PivotPoints = {
+  pp: Cell;
+  r1: Cell;
+  s1: Cell;
+  r2: Cell;
+  s2: Cell;
+};
+
+function finiteCell(value: Cell): Cell {
+  return value !== null && Number.isFinite(value) ? value : null;
+}
+
+/** Near-integer floats round (14.0000000001 → 14); else floor. Python `_float_to_period_int`. */
+const PERIOD_INT_EPS = 1e-9;
+
+/** Pine length: finite, >= 1 after near-int round / floor. */
+function pinePeriod(period: number): number | null {
+  if (!Number.isFinite(period) || period <= 0) return null;
+  const nearest = Math.round(period);
+  const n = Math.abs(period - nearest) <= PERIOD_INT_EPS ? nearest : Math.floor(period);
+  return n > 0 ? n : null;
+}
+
+function rmaStep(st: RmaState, x: Cell, n: number): Cell {
+  const alpha = 1 / n;
+  if (!st.started) {
+    if (x === null) return null;
+    st.started = true;
+  }
+  if (!st.seeded) {
+    if (x !== null) st.seedBuf.push(x);
+    if (st.seedBuf.length < n) return null;
+    const seed = st.seedBuf.reduce((a, b) => a + b, 0) / n;
+    st.rma = seed;
+    st.seeded = true;
+    st.seedBuf = [];
+    return seed;
+  }
+  if (x === null) return st.rma;
+  st.rma = alpha * x + (1 - alpha) * (st.rma ?? x);
+  return st.rma;
+}
+
+export class TaEngine {
+  private readonly smaSites = new Map<string, SmaState>();
+  private readonly emaSites = new Map<string, EmaState>();
+  private readonly rmaSites = new Map<string, RmaState>();
+  private readonly atrSites = new Map<string, AtrState>();
+  private readonly rsiSites = new Map<string, RsiState>();
+  private readonly trSites = new Map<string, TrState>();
+  private readonly highestSites = new Map<string, HighestLowestState>();
+  private readonly lowestSites = new Map<string, HighestLowestState>();
+  private readonly stdevSites = new Map<string, StdevState>();
+  private readonly changeSites = new Map<string, ChangeState>();
+  private readonly wmaSites = new Map<string, WmaState>();
+  private readonly sumSites = new Map<string, SmaState>();
+  private readonly rocSites = new Map<string, ChangeState>();
+  private readonly vwmaSites = new Map<string, VwmaState>();
+  private readonly cciSites = new Map<string, WmaState>();
+  private readonly crossoverSites = new Map<string, CrossState>();
+  private readonly crossunderSites = new Map<string, CrossState>();
+  private readonly linregSites = new Map<string, LinregState>();
+  private readonly vwapSites = new Map<string, VwapState>();
+  private readonly risingSites = new Map<string, RiseFallState>();
+  private readonly fallingSites = new Map<string, RiseFallState>();
+  private readonly almaSites = new Map<string, AlmaState>();
+  private readonly cmoSites = new Map<string, CmoState>();
+  private readonly kamaSites = new Map<string, KamaState>();
+  private readonly obvSites = new Map<string, ObvState>();
+  private readonly pivotHighSites = new Map<string, PivotState>();
+  private readonly pivotLowSites = new Map<string, PivotState>();
+  private readonly mfiSites = new Map<string, MfiState>();
+  private readonly sarSites = new Map<string, SarState>();
+  private readonly adxSites = new Map<string, AdxState>();
+  private readonly dmiSites = new Map<string, DmiState>();
+  private readonly correlationSites = new Map<string, CorrState>();
+  private readonly highestBarsSites = new Map<string, HighestLowestState>();
+  private readonly lowestBarsSites = new Map<string, HighestLowestState>();
+  private readonly swmaSites = new Map<string, SwmaState>();
+  private readonly cogSites = new Map<string, WindowState>();
+  private readonly tsiSites = new Map<string, TsiState>();
+  private readonly devSites = new Map<string, SmaState>();
+  private readonly varianceSites = new Map<string, StdevState>();
+  private readonly medianSites = new Map<string, WindowState>();
+  private readonly modeSites = new Map<string, WindowState>();
+  private readonly percentrankSites = new Map<string, WindowState>();
+  private readonly percentileNearestSites = new Map<string, PercentileState>();
+  private readonly percentileLinearSites = new Map<string, PercentileState>();
+  private readonly cumSites = new Map<string, CumState>();
+  private readonly barssinceSites = new Map<string, BarsSinceState>();
+  private readonly valuewhenSites = new Map<string, ValueWhenState>();
+  private readonly accdistSites = new Map<string, AccdistState>();
+  private readonly pvtSites = new Map<string, PvtState>();
+  private readonly wadSites = new Map<string, WadState>();
+  private readonly nviSites = new Map<string, VolIndexState>();
+  private readonly pviSites = new Map<string, VolIndexState>();
+  private readonly wvadSites = new Map<string, WvadState>();
+
+  sma(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+
+    let st = this.smaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], sum: 0, count: 0 };
+      this.smaSites.set(site, st);
+    }
+
+    const x = finiteCell(source);
+    if (st.window.length === n) {
+      const old = st.window.shift()!;
+      if (old !== null) {
+        st.sum -= old;
+        st.count -= 1;
+      }
+    }
+    st.window.push(x);
+    if (x !== null) {
+      st.sum += x;
+      st.count += 1;
+    }
+
+    // Full window required; any na in the window → na (`_sma_inc_update`).
+    if (st.window.length < n || st.count !== n) return null;
+    return st.sum / n;
+  }
+
+  /** Pine EMA: SMA seed of first `period` finite samples, then α=2/(n+1). */
+  ema(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.emaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, ema: null, seeded: false, seedBuf: [] };
+      this.emaSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    const alpha = 2 / (n + 1);
+    if (!st.seeded) {
+      if (x === null) return null;
+      st.seedBuf.push(x);
+      if (st.seedBuf.length < n) return null;
+      const seed = st.seedBuf.reduce((a, b) => a + b, 0) / n;
+      st.ema = seed;
+      st.seeded = true;
+      st.seedBuf = [];
+      return seed;
+    }
+    if (x === null) return st.ema;
+    st.ema = st.ema == null ? x : alpha * x + (1 - alpha) * st.ema;
+    return st.ema;
+  }
+
+  /** Wilder RMA: mean seed, then α=1/n. na after seed keeps previous. */
+  rma(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.rmaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, rma: null, seeded: false, started: false, seedBuf: [] };
+      this.rmaSites.set(site, st);
+    }
+    return rmaStep(st, finiteCell(source), n);
+  }
+
+  /** `ta.atr(length)` ≡ `ta.rma(ta.tr, length)`. First bar is na (no prev close). */
+  atr(site: string, high: Cell, low: Cell, close: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.atrSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = {
+        period: n,
+        prevClose: null,
+        rma: { period: n, rma: null, seeded: false, started: false, seedBuf: [] },
+      };
+      this.atrSites.set(site, st);
+    }
+    const prev = st.prevClose;
+    st.prevClose = finiteCell(close);
+    if (prev === null) return null;
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (h === null || l === null || c === null) return null;
+    const tr = Math.max(h - l, Math.abs(h - prev), Math.abs(l - prev));
+    return rmaStep(st.rma, tr, n);
+  }
+
+  rsi(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+
+    let st = this.rsiSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = {
+        period: n,
+        prev: null,
+        gainSeed: [],
+        lossSeed: [],
+        avgGain: null,
+        avgLoss: null,
+        seeded: false,
+      };
+      this.rsiSites.set(site, st);
+    }
+
+    const x = finiteCell(source);
+    // NA source: emit na and leave Wilder state untouched.
+    if (x === null) return null; // leave Wilder state untouched (no NaN-poison)
+
+    const prev = st.prev;
+    st.prev = x;
+    if (prev === null) return null;
+
+    const change = x - prev;
+    const gain = change > 0 ? change : 0;
+    const loss = change < 0 ? -change : 0;
+    const alpha = 1 / n;
+
+    if (!st.seeded) {
+      st.gainSeed.push(gain);
+      st.lossSeed.push(loss);
+      if (st.gainSeed.length < n) return null;
+      let gSum = 0;
+      let lSum = 0;
+      for (let i = 0; i < n; i++) {
+        gSum += st.gainSeed[i]!;
+        lSum += st.lossSeed[i]!;
+      }
+      st.avgGain = gSum / n;
+      st.avgLoss = lSum / n;
+      st.seeded = true;
+      st.gainSeed = [];
+      st.lossSeed = [];
+    } else {
+      st.avgGain = alpha * gain + (1 - alpha) * st.avgGain!;
+      st.avgLoss = alpha * loss + (1 - alpha) * st.avgLoss!;
+    }
+
+    // Python `_rsi_inc_update`: avg_loss == 0 → 100 (including both-zero).
+    if (st.avgLoss === 0) return 100;
+    const rs = st.avgGain! / st.avgLoss;
+    return 100 - 100 / (1 + rs);
+  }
+
+  /**
+   * Keltner: mid=EMA(close,length); bands=mid ± mult*ATR(length).
+   * Mid na → all na. Nested EMA/ATR keep their own per-site state.
+   */
+  kc(
+    site: string,
+    high: Cell,
+    low: Cell,
+    close: Cell,
+    length: number,
+    mult: number,
+  ): { mid: Cell; up: Cell; lo: Cell } {
+    const n = pinePeriod(length);
+    if (n === null) return { mid: null, up: null, lo: null };
+    const mid = this.ema(`${site}:ema`, close, n);
+    const atrVal = this.atr(`${site}:atr`, high, low, close, n);
+    if (mid === null) return { mid: null, up: null, lo: null };
+    // `_kc_inc_update`: None ATR → 0 width (nan ATR is not produced here).
+    const width = (atrVal ?? 0) * mult;
+    return { mid, up: mid + width, lo: mid - width };
+  }
+
+  /**
+   * Supertrend: ATR; mid=(h+l)/2; dir=-1 if close>=mid else 1;
+   * st=lower if dir<0 else upper. None/nan ATR → 0 (`_supertrend_inc_update`).
+   */
+  supertrend(
+    site: string,
+    high: Cell,
+    low: Cell,
+    close: Cell,
+    factor: number,
+    atrPeriod: number,
+  ): { st: Cell; dir: Cell } {
+    const n = pinePeriod(atrPeriod);
+    const atrVal = n === null ? null : this.atr(`${site}:atr`, high, low, close, n);
+    const atrF = atrVal === null || !Number.isFinite(atrVal) ? 0 : atrVal;
+    const h = finiteCell(high) ?? 0;
+    const l = finiteCell(low) ?? 0;
+    const c = finiteCell(close) ?? h;
+    const mid = (h + l) / 2;
+    const upper = mid + factor * atrF;
+    const lower = mid - factor * atrF;
+    const dir = c >= mid ? -1 : 1;
+    return { st: dir < 0 ? lower : upper, dir };
+  }
+
+  /** True range. First bar na (no prev close); else max(h-l, |h-prevC|, |l-prevC|). */
+  tr(site: string, high: Cell, low: Cell, close: Cell): Cell {
+    let st = this.trSites.get(site);
+    if (st === undefined) {
+      st = { prevClose: null };
+      this.trSites.set(site, st);
+    }
+    const prev = st.prevClose;
+    st.prevClose = finiteCell(close);
+    if (prev === null) return null;
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    if (h === null || l === null) return null;
+    return Math.max(h - l, Math.abs(h - prev), Math.abs(l - prev));
+  }
+
+  /** Highest in last `period` samples (na skipped). */
+  highest(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.highestSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.highestSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let best: number | null = null;
+    for (const v of st.window) {
+      if (v !== null && (best === null || v > best)) best = v;
+    }
+    return best;
+  }
+
+  /** Lowest in last `period` samples (na skipped). */
+  lowest(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.lowestSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.lowestSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let best: number | null = null;
+    for (const v of st.window) {
+      if (v !== null && (best === null || v < best)) best = v;
+    }
+    return best;
+  }
+
+  /** Sample stdev (ddof=1). Any na in window → na; period<=1 → na. */
+  stdev(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null || n <= 1) return null;
+    let st = this.stdevSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], sum: 0, sumsq: 0, count: 0 };
+      this.stdevSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (st.window.length === n) {
+      const old = st.window.shift()!;
+      if (old !== null) {
+        st.sum -= old;
+        st.sumsq -= old * old;
+        st.count -= 1;
+      }
+    }
+    st.window.push(x);
+    if (x !== null) {
+      st.sum += x;
+      st.sumsq += x * x;
+      st.count += 1;
+    }
+    if (st.window.length < n || st.count !== n) return null;
+    let v = (st.sumsq - (st.sum * st.sum) / n) / (n - 1);
+    if (v < 0) v = 0;
+    return Math.sqrt(v);
+  }
+
+  /** `source - source[length]`. na if lookback missing. */
+  change(site: string, source: Cell, length = 1): Cell {
+    if (!Number.isFinite(length) || length < 0) return null;
+    const n = Math.trunc(length);
+    const x = finiteCell(source);
+    if (n === 0) return x === null ? null : 0;
+    let st = this.changeSites.get(site);
+    if (st === undefined || st.length !== n) {
+      st = { length: n, window: [] };
+      this.changeSites.set(site, st);
+    }
+    if (st.window.length === n + 1) st.window.shift();
+    st.window.push(x);
+    if (st.window.length <= n) return null;
+    const curr = st.window[st.window.length - 1]!;
+    const prev = st.window[0]!;
+    if (curr === null || prev === null) return null;
+    return curr - prev;
+  }
+
+  /** Weighted MA, weights 1..n (oldest=1). Any na in window → na. */
+  wma(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.wmaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.wmaSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let acc = 0;
+    for (let i = 0; i < n; i++) {
+      const v = st.window[i];
+      if (v == null) return null;
+      acc += v * (i + 1);
+    }
+    return acc / (n * (n + 1) / 2);
+  }
+
+  /** 1 when prev a<=b and now a>b; first bar 0. */
+  crossover(site: string, a: Cell, b: Cell): Cell {
+    return this.crossStep(this.crossoverSites, site, a, b, false);
+  }
+
+  /** 1 when prev a>=b and now a<b; first bar 0. */
+  crossunder(site: string, a: Cell, b: Cell): Cell {
+    return this.crossStep(this.crossunderSites, site, a, b, true);
+  }
+
+  /**
+   * MACD via nested EMA sites (`${site}:fast` / `:slow` / `:signal`).
+   * Either EMA na → macd null; hist only when macd and signal both finite.
+   */
+  macd(
+    site: string,
+    source: Cell,
+    fast = 12,
+    slow = 26,
+    signal = 9,
+  ): { macd: Cell; signal: Cell; hist: Cell } {
+    const ef = this.ema(`${site}:fast`, source, fast);
+    const es = this.ema(`${site}:slow`, source, slow);
+    const macdVal = ef === null || es === null ? null : ef - es;
+    const sigVal = this.ema(`${site}:signal`, macdVal, signal);
+    const hist =
+      macdVal !== null && sigVal !== null && Number.isFinite(macdVal) && Number.isFinite(sigVal)
+        ? macdVal - sigVal
+        : null;
+    return { macd: macdVal, signal: sigVal, hist };
+  }
+
+  /**
+   * Bollinger: mid=SMA, dev=sample stdev, bands=mid ± mult*dev.
+   * All null if mid or stdev null.
+   */
+  bb(
+    site: string,
+    source: Cell,
+    length: number,
+    mult = 2,
+  ): { mid: Cell; up: Cell; lo: Cell } {
+    const mid = this.sma(`${site}:sma`, source, length);
+    const dev = this.stdev(`${site}:stdev`, source, length);
+    if (mid === null || dev === null) return { mid: null, up: null, lo: null };
+    return { mid, up: mid + mult * dev, lo: mid - mult * dev };
+  }
+
+  /** Rolling sum. Full window required; any na in the window → na (like sma). */
+  sum(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+
+    let st = this.sumSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], sum: 0, count: 0 };
+      this.sumSites.set(site, st);
+    }
+
+    const x = finiteCell(source);
+    if (st.window.length === n) {
+      const old = st.window.shift()!;
+      if (old !== null) {
+        st.sum -= old;
+        st.count -= 1;
+      }
+    }
+    st.window.push(x);
+    if (x !== null) {
+      st.sum += x;
+      st.count += 1;
+    }
+
+    if (st.window.length < n || st.count !== n) return null;
+    return st.sum;
+  }
+
+  /** `100 * (source - source[length]) / source[length]`. na if lookback missing, denom 0, or length<=0. */
+  roc(site: string, source: Cell, length: number): Cell {
+    if (!Number.isFinite(length) || length <= 0) return null;
+    const n = Math.trunc(length);
+    const x = finiteCell(source);
+    if (n <= 0) return null;
+    let st = this.rocSites.get(site);
+    if (st === undefined || st.length !== n) {
+      st = { length: n, window: [] };
+      this.rocSites.set(site, st);
+    }
+    if (st.window.length === n + 1) st.window.shift();
+    st.window.push(x);
+    if (st.window.length <= n) return null;
+    const curr = st.window[st.window.length - 1]!;
+    const prev = st.window[0]!;
+    if (curr === null || prev === null || prev === 0) return null;
+    return 100 * (curr - prev) / prev;
+  }
+
+  /** `source - source[length]`. Same lag math as `change`. */
+  mom(site: string, source: Cell, length: number): Cell {
+    return this.change(site, source, length);
+  }
+
+  /** Volume-weighted MA: sum(src*vol)/sum(vol). Any na in window → na. */
+  vwma(site: string, source: Cell, volume: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.vwmaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, srcWindow: [], volWindow: [], sumPv: 0, sumV: 0, naCount: 0 };
+      this.vwmaSites.set(site, st);
+    }
+    const s = finiteCell(source);
+    const v = finiteCell(volume);
+    if (st.srcWindow.length === n) {
+      const oldS = st.srcWindow.shift()!;
+      const oldV = st.volWindow.shift()!;
+      if (oldS === null || oldV === null) st.naCount -= 1;
+      else {
+        st.sumPv -= oldS * oldV;
+        st.sumV -= oldV;
+      }
+    }
+    st.srcWindow.push(s);
+    st.volWindow.push(v);
+    if (s === null || v === null) st.naCount += 1;
+    else {
+      st.sumPv += s * v;
+      st.sumV += v;
+    }
+    if (st.srcWindow.length < n || st.naCount > 0 || st.sumV === 0) return null;
+    return st.sumPv / st.sumV;
+  }
+
+  /** CCI: (tp - sma(tp)) / (0.015 * meanDev). Any na in window → na. */
+  cci(site: string, typicalPrice: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.cciSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.cciSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(typicalPrice));
+    if (st.window.length < n) return null;
+    let acc = 0;
+    for (const v of st.window) {
+      if (v == null) return null;
+      acc += v;
+    }
+    const sma = acc / n;
+    let mad = 0;
+    for (const v of st.window) mad += Math.abs(v! - sma);
+    const meanDev = mad / n;
+    if (meanDev === 0) return null;
+    return (st.window[n - 1]! - sma) / (0.015 * meanDev);
+  }
+
+  /** Williams %R: -100*(hh-c)/(hh-ll). na if incomplete window or hh==ll. */
+  willr(site: string, high: Cell, low: Cell, close: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    const hh = this.highest(`${site}:hh`, high, n);
+    const ll = this.lowest(`${site}:ll`, low, n);
+    const c = finiteCell(close);
+    if (hh === null || ll === null || c === null || hh === ll) return null;
+    return -100 * (hh - c) / (hh - ll);
+  }
+
+  /** Stochastic %K: 100*(c-ll)/(hh-ll). na if incomplete window or hh==ll. */
+  stoch(site: string, source: Cell, high: Cell, low: Cell, length: number): Cell {
+    const n = pinePeriod(length);
+    if (n === null) return null;
+    const hh = this.highest(`${site}:hh`, high, n);
+    const ll = this.lowest(`${site}:ll`, low, n);
+    const c = finiteCell(source);
+    if (hh === null || ll === null || c === null || hh === ll) return null;
+    return 100 * (c - ll) / (hh - ll);
+  }
+
+  /** Least-squares line value at `length-1-offset`. Any na in window → na. */
+  linreg(site: string, source: Cell, length: number, offset = 0): Cell {
+    const n = pinePeriod(length);
+    if (n === null || n < 2) return null;
+    const off = Number.isFinite(offset) ? Math.trunc(offset) : 0;
+    let st = this.linregSites.get(site);
+    if (st === undefined || st.period !== n || st.offset !== off) {
+      st = { period: n, offset: off, window: [] };
+      this.linregSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let sumY = 0;
+    for (const v of st.window) {
+      if (v == null) return null;
+      sumY += v;
+    }
+    const meanX = (n - 1) / 2;
+    const meanY = sumY / n;
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+      const dx = i - meanX;
+      num += dx * (st.window[i]! - meanY);
+      den += dx * dx;
+    }
+    if (den === 0) return meanY;
+    const slope = num / den;
+    return meanY + slope * ((n - 1 - off) - meanX);
+  }
+
+  /** Cumulative VWAP: sum(src*vol)/sum(vol). Skips na source; no session reset. */
+  vwap(site: string, source: Cell, volume: Cell): Cell {
+    let st = this.vwapSites.get(site);
+    if (st === undefined) {
+      st = { cumPv: 0, cumV: 0, value: null };
+      this.vwapSites.set(site, st);
+    }
+    const p = finiteCell(source);
+    if (p === null) return st.value;
+    const v = finiteCell(volume) ?? 0;
+    st.cumPv += p * v;
+    st.cumV += v;
+    st.value = st.cumV !== 0 ? st.cumPv / st.cumV : p;
+    return st.value;
+  }
+
+  /** 1 if `source > source[1]` for `length` bars; else 0. Warmup 0. */
+  rising(site: string, source: Cell, length: number): Cell {
+    return this.riseFallStep(this.risingSites, site, source, length, false);
+  }
+
+  /** 1 if `source < source[1]` for `length` bars; else 0. Warmup 0. */
+  falling(site: string, source: Cell, length: number): Cell {
+    return this.riseFallStep(this.fallingSites, site, source, length, true);
+  }
+
+  private riseFallStep(
+    sites: Map<string, RiseFallState>,
+    site: string,
+    source: Cell,
+    length: number,
+    falling: boolean,
+  ): Cell {
+    const n = pinePeriod(length);
+    if (n === null) return 0;
+    let st = sites.get(site);
+    if (st === undefined || st.length !== n) {
+      st = { length: n, prev: null, streak: 0, started: false };
+      sites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (!st.started) {
+      st.prev = x;
+      st.started = true;
+      st.streak = 0;
+      return 0;
+    }
+    const prev = st.prev;
+    const step = x !== null && prev !== null && (falling ? x < prev : x > prev);
+    st.streak = step ? st.streak + 1 : 0;
+    st.prev = x;
+    return st.streak >= n ? 1 : 0;
+  }
+
+  private crossStep(
+    sites: Map<string, CrossState>,
+    site: string,
+    a: Cell,
+    b: Cell,
+    under: boolean,
+  ): Cell {
+    let st = sites.get(site);
+    if (st === undefined) {
+      st = { prevA: null, prevB: null, started: false };
+      sites.set(site, st);
+    }
+    const aF = finiteCell(a);
+    const bF = finiteCell(b);
+    let hit = 0;
+    if (st.started && st.prevA !== null && st.prevB !== null && aF !== null && bF !== null) {
+      const crossed = under
+        ? st.prevA >= st.prevB && aF < bF
+        : st.prevA <= st.prevB && aF > bF;
+      hit = crossed ? 1 : 0;
+    }
+    st.prevA = aF;
+    st.prevB = bF;
+    st.started = true;
+    return hit;
+  }
+
+  /** 1 if crossover or crossunder this bar. */
+  cross(site: string, a: Cell, b: Cell): Cell {
+    const up = this.crossover(`${site}:up`, a, b);
+    const down = this.crossunder(`${site}:down`, a, b);
+    return up === 1 || down === 1 ? 1 : 0;
+  }
+
+  /** `(up - lo) / mid` from `bb`. */
+  bbw(site: string, source: Cell, length: number, mult = 2): Cell {
+    const r = this.bb(site, source, length, mult);
+    if (r.mid === null || r.up === null || r.lo === null || r.mid === 0) return null;
+    return (r.up - r.lo) / r.mid;
+  }
+
+  /** `2*ema - ema(ema)`. */
+  dema(site: string, source: Cell, period: number): Cell {
+    const e1 = this.ema(`${site}:e1`, source, period);
+    const e2 = this.ema(`${site}:e2`, e1, period);
+    if (e1 === null || e2 === null) return null;
+    return 2 * e1 - e2;
+  }
+
+  /** `3*ema - 3*ema(ema) + ema(ema(ema))`. */
+  tema(site: string, source: Cell, period: number): Cell {
+    const e1 = this.ema(`${site}:e1`, source, period);
+    const e2 = this.ema(`${site}:e2`, e1, period);
+    const e3 = this.ema(`${site}:e3`, e2, period);
+    if (e1 === null || e2 === null || e3 === null) return null;
+    return 3 * e1 - 3 * e2 + e3;
+  }
+
+  /**
+   * Offset (negative, TradingView style) of the highest in the window.
+   * `0` = current bar is the high; `-n+1` = oldest bar.
+   */
+  highestbars(site: string, source: Cell, period: number): Cell {
+    return this.extremeBars(this.highestBarsSites, site, source, period, true);
+  }
+
+  /** Offset of the lowest in the window (negative TV style). */
+  lowestbars(site: string, source: Cell, period: number): Cell {
+    return this.extremeBars(this.lowestBarsSites, site, source, period, false);
+  }
+
+  private extremeBars(
+    sites: Map<string, HighestLowestState>,
+    site: string,
+    source: Cell,
+    period: number,
+    highest: boolean,
+  ): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = sites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      sites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let bestI = -1;
+    let best: number | null = null;
+    for (let i = 0; i < st.window.length; i++) {
+      const v = st.window[i];
+      if (v === null) continue;
+      // Strict compare so ties keep the oldest bar (Python `_highestbars`).
+      if (best === null || (highest ? v > best : v < best)) {
+        best = v;
+        bestI = i;
+      }
+    }
+    if (bestI < 0) return null;
+    return bestI - (st.window.length - 1);
+  }
+
+  /** Arnaud Legoux MA. na in window → na. Defaults offset=0.85, sigma=6. */
+  alma(site: string, source: Cell, period: number, offset = 0.85, sigma = 6): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    if (!Number.isFinite(offset) || !Number.isFinite(sigma)) return null;
+    const off = offset;
+    const sig = sigma;
+    let st = this.almaSites.get(site);
+    if (st === undefined || st.period !== n || st.offset !== off || st.sigma !== sig) {
+      const m = off * (n - 1);
+      const s = sig === 0 ? 0 : n / sig;
+      const weights: number[] = [];
+      let wsum = 0;
+      for (let i = 0; i < n; i++) {
+        const w = s === 0 ? 1 : Math.exp(-((i - m) ** 2) / (2 * s * s));
+        weights.push(w);
+        wsum += w;
+      }
+      st = { period: n, offset: off, sigma: sig, window: [], weights, wsum };
+      this.almaSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n || st.wsum === 0) return null;
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+      const v = st.window[i];
+      if (v == null) return null;
+      total += v * st.weights[i]!;
+    }
+    return total / st.wsum;
+  }
+
+  /** Chande Momentum Oscillator. Window of length+1; denom 0 → 0. */
+  cmo(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.cmoSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], up: 0, down: 0 };
+      this.cmoSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (st.window.length === n + 1) {
+      const old = st.window[0]!;
+      const nxt = st.window[1]!;
+      if (old !== null && nxt !== null) {
+        const d = nxt - old;
+        if (d > 0) st.up -= d;
+        else st.down -= -d;
+      }
+      st.window.shift();
+    }
+    const prev = st.window.length === 0 ? null : st.window[st.window.length - 1]!;
+    st.window.push(x);
+    if (prev !== null && x !== null) {
+      const d = x - prev;
+      if (d > 0) st.up += d;
+      else st.down += -d;
+    }
+    if (st.window.length < n + 1) return null;
+    const denom = st.up + st.down;
+    if (denom === 0) return 0;
+    return (100 * (st.up - st.down)) / denom;
+  }
+
+  /** Kaufman AMA. First output on bar index `length` (need length+1 samples). */
+  kama(site: string, source: Cell, period: number, fast = 2, slow = 30): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    const f = Number.isFinite(fast) ? Math.trunc(fast) : 2;
+    const sl = Number.isFinite(slow) ? Math.trunc(slow) : 30;
+    // 2/(fast+1) / 2/(slow+1) — reject the singular -1 case (NaN-poison).
+    if (f === -1 || sl === -1) return null;
+    let st = this.kamaSites.get(site);
+    if (st === undefined || st.period !== n || st.fast !== f || st.slow !== sl) {
+      st = {
+        period: n,
+        fast: f,
+        slow: sl,
+        prices: [],
+        diffs: [],
+        vol: 0,
+        kama: null,
+        seeded: false,
+        bars: 0,
+      };
+      this.kamaSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (x === null) return null;
+    const prev = st.prices.length === 0 ? null : st.prices[st.prices.length - 1]!;
+    if (st.prices.length === n + 1) st.prices.shift();
+    st.prices.push(x);
+    st.bars += 1;
+    if (prev !== null) {
+      const d = Math.abs(x - prev);
+      if (st.diffs.length === n) st.vol -= st.diffs.shift()!;
+      st.diffs.push(d);
+      st.vol += d;
+    }
+    if (!st.seeded) {
+      if (st.bars < n) return null;
+      st.kama = x;
+      st.seeded = true;
+      return null;
+    }
+    const oldest = st.prices[0]!;
+    const change = Math.abs(x - oldest);
+    const volatility = st.vol;
+    let sc: number;
+    if (volatility !== 0) {
+      const efficiency = change / volatility;
+      const fastest = 2 / (f + 1);
+      const slowest = 2 / (sl + 1);
+      const smoothing = efficiency * (fastest - slowest) + slowest;
+      sc = smoothing * smoothing;
+    } else {
+      sc = (2 / (sl + 1)) ** 2;
+    }
+    st.kama = (st.kama ?? x) + sc * (x - (st.kama ?? x));
+    return st.kama;
+  }
+
+  /**
+   * On-Balance Volume. Python `_obv`: 0 until 3 samples; then signed volume
+   * from index 2 onward.
+   */
+  obv(site: string, close: Cell, volume: Cell): Cell {
+    let st = this.obvSites.get(site);
+    if (st === undefined) {
+      st = { prev: null, obv: 0, bars: 0 };
+      this.obvSites.set(site, st);
+    }
+    const c = finiteCell(close);
+    const v = finiteCell(volume) ?? 0;
+    st.bars += 1;
+    if (st.bars < 3) {
+      st.prev = c;
+      return 0;
+    }
+    if (c !== null && st.prev !== null) {
+      if (c > st.prev) st.obv += v;
+      else if (c < st.prev) st.obv -= v;
+    }
+    st.prev = c;
+    return st.obv;
+  }
+
+  /** Left-only pivothigh (Python incremental). */
+  pivothigh(site: string, source: Cell, left: number, right: number): Cell {
+    return this.pivotStep(this.pivotHighSites, site, source, left, right, true);
+  }
+
+  /** Left-only pivotlow (Python incremental). */
+  pivotlow(site: string, source: Cell, left: number, right: number): Cell {
+    return this.pivotStep(this.pivotLowSites, site, source, left, right, false);
+  }
+
+  private pivotStep(
+    sites: Map<string, PivotState>,
+    site: string,
+    source: Cell,
+    left: number,
+    right: number,
+    high: boolean,
+  ): Cell {
+    if (!Number.isFinite(left) || !Number.isFinite(right) || left < 0 || right < 0) return null;
+    const L = Math.trunc(left);
+    const R = Math.trunc(right);
+    let st = sites.get(site);
+    if (st === undefined || st.left !== L || st.right !== R) {
+      st = { left: L, right: R, window: [], n: 0 };
+      sites.set(site, st);
+    }
+    const need = L + 1;
+    if (st.window.length === need) st.window.shift();
+    st.window.push(finiteCell(source));
+    st.n += 1;
+    if (st.n <= L + R || st.window.length < need) return null;
+    const current = st.window[st.window.length - 1];
+    if (current === null) return null;
+    for (let i = 1; i <= L; i++) {
+      const leftVal = st.window[st.window.length - 1 - i];
+      if (leftVal === null) continue;
+      if (high ? leftVal >= current : leftVal <= current) return null;
+    }
+    return current;
+  }
+
+  /**
+   * Hull MA: WMA(2*WMA(n/2)-WMA(n), sqrt(n)).
+   * Nested wma sites `${site}:half` / `:full` / `:sqrt` (`_hma_inc_update`).
+   */
+  hma(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    const half = Math.max(1, Math.trunc(n / 2));
+    const sqrtN = Math.max(1, Math.trunc(Math.sqrt(n)));
+    const wh = this.wma(`${site}:half`, source, half);
+    const wf = this.wma(`${site}:full`, source, n);
+    const raw = wh === null || wf === null ? null : 2 * wh - wf;
+    return this.wma(`${site}:sqrt`, raw, sqrtN);
+  }
+
+  /**
+   * Money Flow Index. Needs `period+1` typical prices; equal TP is neither side.
+   * Only +MF → 100; only −MF → 0; both 0 → 50 (`_mfi_inc_update`).
+   */
+  mfi(
+    site: string,
+    high: Cell,
+    low: Cell,
+    close: Cell,
+    volume: Cell,
+    period: number,
+  ): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.mfiSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, tps: [], mfs: [] };
+      this.mfiSites.set(site, st);
+    }
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (st.tps.length === n + 1) {
+      st.tps.shift();
+      st.mfs.shift();
+    }
+    if (h === null || l === null || c === null) {
+      st.tps.push(null);
+      st.mfs.push(null);
+      return null;
+    }
+    const vol = finiteCell(volume) ?? 0;
+    const tp = (h + l + c) / 3;
+    st.tps.push(tp);
+    st.mfs.push(tp * vol);
+    if (st.tps.length <= n) return null;
+
+    let pos = 0;
+    let neg = 0;
+    const startK = st.tps.length - n;
+    for (let k = startK; k < st.tps.length; k++) {
+      const tpCur = st.tps[k]!;
+      const tpPrev = st.tps[k - 1]!;
+      const mf = st.mfs[k]!;
+      if (tpCur === null || tpPrev === null || mf === null) return null;
+      if (tpCur > tpPrev) pos += mf;
+      else if (tpCur < tpPrev) neg += mf;
+    }
+    if (neg === 0) return pos === 0 ? 50 : 100;
+    const ratio = pos / neg;
+    return 100 - 100 / (1 + ratio);
+  }
+
+  /**
+   * Parabolic SAR. First valid bar is low; leading na stays na (`_sar_inc_update`).
+   */
+  sar(
+    site: string,
+    high: Cell,
+    low: Cell,
+    start = 0.02,
+    increment = 0.02,
+    maximum = 0.2,
+  ): Cell {
+    if (!Number.isFinite(start) || !Number.isFinite(increment) || !Number.isFinite(maximum)) {
+      return null;
+    }
+    const startF = start;
+    const incF = increment;
+    const maxF = maximum;
+    let st = this.sarSites.get(site);
+    if (
+      st === undefined ||
+      st.start !== startF ||
+      st.increment !== incF ||
+      st.maximum !== maxF
+    ) {
+      st = {
+        start: startF,
+        increment: incF,
+        maximum: maxF,
+        started: false,
+        sar: null,
+        ep: null,
+        trend: 1,
+        af: startF,
+      };
+      this.sarSites.set(site, st);
+    }
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    if (!st.started) {
+      if (h === null || l === null) return null;
+      st.started = true;
+      st.sar = l;
+      st.ep = h;
+      st.trend = 1;
+      st.af = startF;
+      return l;
+    }
+    const previous = st.sar;
+    const ep = st.ep;
+    if (previous === null || h === null || l === null || ep === null) return previous;
+    let trend = st.trend;
+    let af = st.af;
+    let epF = ep;
+    let sarV: number;
+    if (trend === 1) {
+      sarV = previous + af * (epF - previous);
+      if (h > epF) {
+        epF = h;
+        af = Math.min(af + incF, maxF);
+      }
+      if (sarV > l) {
+        trend = -1;
+        sarV = epF;
+        epF = l;
+        af = startF;
+      }
+    } else {
+      sarV = previous - af * (previous - epF);
+      if (l < epF) {
+        epF = l;
+        af = Math.min(af + incF, maxF);
+      }
+      if (sarV < h) {
+        trend = 1;
+        sarV = epF;
+        epF = h;
+        af = startF;
+      }
+    }
+    st.sar = sarV;
+    st.ep = epF;
+    st.trend = trend;
+    st.af = af;
+    return Number.isFinite(sarV) ? sarV : null;
+  }
+
+  /**
+   * ADX (nan-first DM). Early bars and unseeded ATR/DX → 0 (`_adx_inc_update`).
+   */
+  adx(site: string, high: Cell, low: Cell, close: Cell, length: number): Cell {
+    const n = pinePeriod(length);
+    if (n === null) return 0;
+    let st = this.adxSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, prevH: null, prevL: null, prevC: null, n: 0 };
+      this.adxSites.set(site, st);
+    }
+    let tr: Cell;
+    let plusDm: Cell;
+    let minusDm: Cell;
+    if (st.prevH === null || st.prevL === null || st.prevC === null) {
+      tr = null;
+      plusDm = null;
+      minusDm = null;
+    } else {
+      const hf = high !== null && Number.isFinite(high) ? high : Number.NaN;
+      const lf = low !== null && Number.isFinite(low) ? low : Number.NaN;
+      const trRaw = Math.max(
+        hf - lf,
+        Math.abs(hf - st.prevC),
+        Math.abs(lf - st.prevC),
+      );
+      tr = Number.isFinite(trRaw) ? trRaw : null;
+      const highDiff = hf - st.prevH;
+      const lowDiff = st.prevL - lf;
+      plusDm = highDiff > lowDiff && highDiff > 0 ? highDiff : 0;
+      minusDm = lowDiff > highDiff && lowDiff > 0 ? lowDiff : 0;
+    }
+    st.prevH = finiteCell(high);
+    st.prevL = finiteCell(low);
+    st.prevC = finiteCell(close);
+    st.n += 1;
+
+    const atr = this.rma(`${site}:tr`, tr, n);
+    const pd = this.rma(`${site}:pdm`, plusDm, n);
+    const md = this.rma(`${site}:mdm`, minusDm, n);
+    if (st.n < n) return 0;
+    if (atr === null) return 0;
+
+    let dxIn: Cell;
+    if (pd === null || md === null) {
+      dxIn = null;
+    } else {
+      const plusDi = atr !== 0 ? 100 * pd / atr : 0;
+      const minusDi = atr !== 0 ? 100 * md / atr : 0;
+      const denom = plusDi + minusDi;
+      dxIn = denom !== 0 ? 100 * Math.abs(plusDi - minusDi) / denom : 0;
+    }
+    const adxV = this.rma(`${site}:dx`, dxIn, n);
+    return adxV === null ? 0 : adxV;
+  }
+
+  /**
+   * DMI: 0-first +DI/−DI (RMA diLength) + nan-first ADX via `${site}:adx`.
+   */
+  dmi(
+    site: string,
+    high: Cell,
+    low: Cell,
+    close: Cell,
+    diLength: number,
+    adxSmoothing: number,
+  ): { plus: Cell; minus: Cell; adx: Cell } {
+    const diN = pinePeriod(diLength);
+    if (diN === null) return { plus: null, minus: null, adx: null };
+    let st = this.dmiSites.get(site);
+    if (st === undefined || st.diLen !== diN) {
+      st = { diLen: diN, prevH: null, prevL: null, prevC: null };
+      this.dmiSites.set(site, st);
+    }
+    let tr: Cell;
+    let plusDm: number;
+    let minusDm: number;
+    if (st.prevH === null || st.prevL === null || st.prevC === null) {
+      tr = null;
+      plusDm = 0;
+      minusDm = 0;
+    } else {
+      const hf = finiteCell(high) ?? 0;
+      const lf = finiteCell(low) ?? 0;
+      const ph = st.prevH;
+      const pl = st.prevL;
+      const pc = st.prevC;
+      tr = Math.max(hf - lf, Math.abs(hf - pc), Math.abs(lf - pc));
+      const highDiff = hf - ph;
+      const lowDiff = pl - lf;
+      plusDm = highDiff > lowDiff && highDiff > 0 ? highDiff : 0;
+      minusDm = lowDiff > highDiff && lowDiff > 0 ? lowDiff : 0;
+    }
+    st.prevH = finiteCell(high);
+    st.prevL = finiteCell(low);
+    st.prevC = finiteCell(close);
+
+    const atr = this.rma(`${site}:tr`, tr, diN);
+    const pd = this.rma(`${site}:pdm`, plusDm, diN);
+    const md = this.rma(`${site}:mdm`, minusDm, diN);
+    let plus: Cell;
+    let minus: Cell;
+    if (atr === null) {
+      plus = null;
+      minus = null;
+    } else if (atr === 0) {
+      plus = 0;
+      minus = 0;
+    } else {
+      plus = 100 * (pd ?? 0) / atr;
+      minus = 100 * (md ?? 0) / atr;
+    }
+    const adx = this.adx(`${site}:adx`, high, low, close, adxSmoothing);
+    return { plus, minus, adx };
+  }
+
+  /**
+   * Pearson correlation over `length` samples (na pairs skipped).
+   * `length<2`, short window, <2 pairs, or zero variance → na.
+   */
+  correlation(site: string, a: Cell, b: Cell, length: number): Cell {
+    const n = pinePeriod(length);
+    if (n === null || n < 2) return null;
+    let st = this.correlationSites.get(site);
+    if (st === undefined || st.length !== n) {
+      st = { length: n, a: [], b: [] };
+      this.correlationSites.set(site, st);
+    }
+    if (st.a.length === n) {
+      st.a.shift();
+      st.b.shift();
+    }
+    st.a.push(finiteCell(a));
+    st.b.push(finiteCell(b));
+    if (st.a.length < n) return null;
+
+    const xs: number[] = [];
+    const ys: number[] = [];
+    for (let i = 0; i < n; i++) {
+      const x = st.a[i]!;
+      const y = st.b[i]!;
+      if (x !== null && y !== null) {
+        xs.push(x);
+        ys.push(y);
+      }
+    }
+    if (xs.length < 2) return null;
+    const m = xs.length;
+    let mx = 0;
+    let my = 0;
+    for (let i = 0; i < m; i++) {
+      mx += xs[i]!;
+      my += ys[i]!;
+    }
+    mx /= m;
+    my /= m;
+    let num = 0;
+    let denx = 0;
+    let deny = 0;
+    for (let i = 0; i < m; i++) {
+      const dx = xs[i]! - mx;
+      const dy = ys[i]! - my;
+      num += dx * dy;
+      denx += dx * dx;
+      deny += dy * dy;
+    }
+    const sx = Math.sqrt(denx);
+    const sy = Math.sqrt(deny);
+    if (sx === 0 || sy === 0) return null;
+    return num / (sx * sy);
+  }
+
+  /**
+   * Cumulative A/D: CLV * volume. H/L/C na keeps previous ad; vol na → 0;
+   * zero range → CLV 0 (`_accdist_inc_update`).
+   */
+  accdist(site: string, high: Cell, low: Cell, close: Cell, volume: Cell): Cell {
+    let st = this.accdistSites.get(site);
+    if (st === undefined) {
+      st = { ad: 0 };
+      this.accdistSites.set(site, st);
+    }
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (h === null || l === null || c === null) return st.ad;
+    const vv = finiteCell(volume) ?? 0;
+    const rng = h - l;
+    const clv = rng === 0 ? 0 : ((c - l) - (h - c)) / rng;
+    st.ad += clv * vv;
+    return st.ad;
+  }
+
+  /**
+   * Price-Volume Trend. Adds vol*(c-prev)/prev when prev is finite and != 0.
+   * First bar is 0; na close or vol skips the add.
+   */
+  pvt(site: string, close: Cell, volume: Cell): Cell {
+    let st = this.pvtSites.get(site);
+    if (st === undefined) {
+      st = { pvt: 0, prev: null };
+      this.pvtSites.set(site, st);
+    }
+    const c = finiteCell(close);
+    const prev = st.prev;
+    if (prev !== null && prev !== 0 && c !== null) {
+      const vv = finiteCell(volume) ?? 0;
+      st.pvt += (vv * (c - prev)) / prev;
+    }
+    if (c !== null) st.prev = c;
+    return st.pvt;
+  }
+
+  /**
+   * Williams AD. First bar 0; close>prev → +(close-low); close<prev →
+   * -(high-close). H/L/C na keeps previous (`_wad`).
+   */
+  wad(site: string, high: Cell, low: Cell, close: Cell): Cell {
+    let st = this.wadSites.get(site);
+    if (st === undefined) {
+      st = { wad: 0, prev: null, started: false };
+      this.wadSites.set(site, st);
+    }
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (h === null || l === null || c === null) return st.wad;
+    if (!st.started) {
+      st.started = true;
+      st.prev = c;
+      return st.wad;
+    }
+    const prev = st.prev;
+    if (prev !== null) {
+      if (c > prev) st.wad += c - l;
+      else if (c < prev) st.wad -= h - c;
+    }
+    st.prev = c;
+    return st.wad;
+  }
+
+  /**
+   * Negative Volume Index. Starts at 1000; updates when volume < prev volume.
+   */
+  nvi(site: string, close: Cell, volume: Cell): Cell {
+    return this.volIndexStep(this.nviSites, site, close, volume, (vol, prevVol) => vol < prevVol);
+  }
+
+  /**
+   * Positive Volume Index. Starts at 1000; updates when volume > prev volume.
+   */
+  pvi(site: string, close: Cell, volume: Cell): Cell {
+    return this.volIndexStep(this.pviSites, site, close, volume, (vol, prevVol) => vol > prevVol);
+  }
+
+  private volIndexStep(
+    sites: Map<string, VolIndexState>,
+    site: string,
+    close: Cell,
+    volume: Cell,
+    trigger: (vol: number, prevVol: number) => boolean,
+  ): Cell {
+    let st = sites.get(site);
+    if (st === undefined) {
+      st = { value: 1000, prevClose: null, prevVol: null, started: false };
+      sites.set(site, st);
+    }
+    const c = finiteCell(close);
+    const vol = finiteCell(volume) ?? 0;
+    if (!st.started) {
+      st.started = true;
+      if (c !== null) st.prevClose = c;
+      st.prevVol = vol;
+      return st.value;
+    }
+    if (c !== null && st.prevClose !== null && trigger(vol, st.prevVol ?? 0)) {
+      const change = st.prevClose !== 0 ? (c - st.prevClose) / st.prevClose : 0;
+      const next = st.value * (1 + change);
+      if (Number.isFinite(next)) st.value = next;
+    }
+    if (c !== null) st.prevClose = c;
+    st.prevVol = vol;
+    return st.value;
+  }
+
+  /**
+   * Intraday Intensity: ((2c-h-l)/(h-l))*volume. Zero range → 0; H/L/C na → na;
+   * vol na → 0 (`_builtin_ta_iii` * volume).
+   */
+  iii(site: string, high: Cell, low: Cell, close: Cell, volume: Cell): Cell {
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (h === null || l === null || c === null) return null;
+    const rng = h - l;
+    if (rng === 0) return 0;
+    const vv = finiteCell(volume) ?? 0;
+    return ((2 * c - h - l) / rng) * vv;
+  }
+
+  /**
+   * Williams Variable AD: cumulative ((c-o)/(h-l))*volume. O/H/L/C na keeps
+   * previous; vol na → 0; zero range adds 0.
+   */
+  wvad(site: string, open: Cell, high: Cell, low: Cell, close: Cell, volume: Cell): Cell {
+    let st = this.wvadSites.get(site);
+    if (st === undefined) {
+      st = { value: 0 };
+      this.wvadSites.set(site, st);
+    }
+    const o = finiteCell(open);
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (o === null || h === null || l === null || c === null) return st.value;
+    const rng = h - l;
+    const vv = finiteCell(volume) ?? 0;
+    if (rng !== 0) st.value += ((c - o) / rng) * vv;
+    return st.value;
+  }
+
+  /**
+   * Classic floor pivots. na high/low/close → all na.
+   * Optional `type` is accepted; classic levels are always returned.
+   */
+  pivotPoints(site: string, high: Cell, low: Cell, close: Cell, type?: string): PivotPoints {
+    const h = finiteCell(high);
+    const l = finiteCell(low);
+    const c = finiteCell(close);
+    if (h === null || l === null || c === null) {
+      return { pp: null, r1: null, s1: null, r2: null, s2: null };
+    }
+    const pp = (h + l + c) / 3;
+    const rng = h - l;
+    return {
+      pp,
+      r1: 2 * pp - l,
+      s1: 2 * pp - h,
+      r2: pp + rng,
+      s2: pp - rng,
+    };
+  }
+
+  /**
+   * Symmetric WMA. Omitted/NaN period → fixed 4-sample weights 1/2/2/1.
+   * Else `_builtin_ta_swma` 2-arg weights. Any na in window → na.
+   */
+  swma(site: string, source: Cell, period?: number): Cell {
+    const useFixed = period === undefined || Number.isNaN(period);
+    const n = useFixed ? 4 : pinePeriod(period);
+    if (n === null) return null;
+    let st = this.swmaSites.get(site);
+    if (st === undefined || st.period !== n) {
+      const weights: number[] = [];
+      let wsum = 0;
+      for (let i = 0; i < n; i++) {
+        const w = i < (n >> 1) ? i + 1 : i > ((n - 1) >> 1) ? n - i : (n >> 1) + 1;
+        weights.push(w);
+        wsum += w;
+      }
+      st = { period: n, window: [], weights, wsum };
+      this.swmaSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n || st.wsum === 0) return null;
+    let acc = 0;
+    for (let i = 0; i < n; i++) {
+      const v = st.window[i];
+      if (v == null) return null;
+      acc += v * st.weights[i]!;
+    }
+    return acc / st.wsum;
+  }
+
+  /** Center of Gravity: `-sum((i+1)*x_rev) / sum(x)` over `period`. den=0 → na. */
+  cog(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.cogSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.cogSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    let num = 0;
+    let den = 0;
+    for (let i = 0; i < n; i++) {
+      const v = st.window[n - 1 - i];
+      if (v === null) continue;
+      num += (i + 1) * v;
+      den += v;
+    }
+    if (den === 0) return null;
+    return -num / den;
+  }
+
+  /** TSI: 100 * EMA(EMA(mom, long), short) / EMA(EMA(|mom|, long), short). */
+  tsi(site: string, source: Cell, longPeriod: number, shortPeriod: number): Cell {
+    const longN = pinePeriod(longPeriod);
+    const shortN = pinePeriod(shortPeriod);
+    if (longN === null || shortN === null) return null;
+    let st = this.tsiSites.get(site);
+    if (st === undefined || st.longPeriod !== longN || st.shortPeriod !== shortN) {
+      st = { longPeriod: longN, shortPeriod: shortN, prev: null, nBars: 0, value: null };
+      this.tsiSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    st.nBars += 1;
+    const prev = st.prev;
+    st.prev = x;
+    if (prev === null || x === null) {
+      if (st.nBars < longN + shortN) {
+        st.value = null;
+        return null;
+      }
+      return st.value;
+    }
+    const mom = x - prev;
+    const tag = `${site}:${longN}:${shortN}`;
+    const e1 = this.ema(`${tag}:mom`, mom, longN);
+    const e2 = this.ema(`${tag}:mom2`, e1, shortN);
+    const a1 = this.ema(`${tag}:abs`, Math.abs(mom), longN);
+    const a2 = this.ema(`${tag}:abs2`, a1, shortN);
+    if (st.nBars < longN + shortN) {
+      st.value = null;
+      return null;
+    }
+    if (a2 === null || a2 === 0) {
+      st.value = a2 === 0 ? 0 : null;
+      return st.value;
+    }
+    if (e2 === null) {
+      st.value = null;
+      return null;
+    }
+    st.value = 100 * (e2 / a2);
+    return st.value;
+  }
+
+  /** `(up - lo) / mid` from `kc`. na if mid is 0/null. */
+  kcw(
+    site: string,
+    high: Cell,
+    low: Cell,
+    close: Cell,
+    length: number,
+    mult: number,
+  ): Cell {
+    const r = this.kc(site, high, low, close, length, mult);
+    if (r.mid === null || r.up === null || r.lo === null || r.mid === 0) return null;
+    return (r.up - r.lo) / r.mid;
+  }
+
+  /** Mean absolute deviation. Full window; any na → na. */
+  dev(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.devSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], sum: 0, count: 0 };
+      this.devSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (st.window.length === n) {
+      const old = st.window.shift()!;
+      if (old !== null) {
+        st.sum -= old;
+        st.count -= 1;
+      }
+    }
+    st.window.push(x);
+    if (x !== null) {
+      st.sum += x;
+      st.count += 1;
+    }
+    if (st.window.length < n || st.count !== n) return null;
+    const mean = st.sum / n;
+    let acc = 0;
+    for (const v of st.window) {
+      if (v === null) return null;
+      acc += Math.abs(v - mean);
+    }
+    return acc / n;
+  }
+
+  /** Sample variance (ddof=1). Any na in window → na; period<=1 → na. */
+  variance(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null || n <= 1) return null;
+    let st = this.varianceSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [], sum: 0, sumsq: 0, count: 0 };
+      this.varianceSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (st.window.length === n) {
+      const old = st.window.shift()!;
+      if (old !== null) {
+        st.sum -= old;
+        st.sumsq -= old * old;
+        st.count -= 1;
+      }
+    }
+    st.window.push(x);
+    if (x !== null) {
+      st.sum += x;
+      st.sumsq += x * x;
+      st.count += 1;
+    }
+    if (st.window.length < n || st.count !== n) return null;
+    let v = (st.sumsq - (st.sum * st.sum) / n) / (n - 1);
+    if (v < 0) v = 0;
+    return v;
+  }
+
+  /** Median of finite samples. Needs a full `period` window. */
+  median(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.medianSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.medianSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    const valid: number[] = [];
+    for (const v of st.window) {
+      if (v !== null) valid.push(v);
+    }
+    if (valid.length === 0) return null;
+    valid.sort((a, b) => a - b);
+    const mid = valid.length >> 1;
+    if (valid.length % 2 === 1) return valid[mid]!;
+    return (valid[mid - 1]! + valid[mid]!) / 2;
+  }
+
+  /** Most frequent finite value. Ties keep the first in-window value. */
+  mode(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.modeSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.modeSites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    const counts = new Map<number, number>();
+    let best: number | null = null;
+    let bestC = 0;
+    for (const v of st.window) {
+      if (v === null) continue;
+      const c = (counts.get(v) ?? 0) + 1;
+      counts.set(v, c);
+      if (c > bestC) {
+        bestC = c;
+        best = v;
+      }
+    }
+    return best;
+  }
+
+  /** `100 * count(x < current) / count`. <2 finite samples → 50; current na → na. */
+  percentrank(site: string, source: Cell, period: number): Cell {
+    const n = pinePeriod(period);
+    if (n === null) return null;
+    let st = this.percentrankSites.get(site);
+    if (st === undefined || st.period !== n) {
+      st = { period: n, window: [] };
+      this.percentrankSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    if (st.window.length === n) st.window.shift();
+    st.window.push(x);
+    if (st.window.length < n) return null;
+    const valid: number[] = [];
+    for (const v of st.window) {
+      if (v !== null) valid.push(v);
+    }
+    if (valid.length < 2) return 50;
+    if (x === null) return null;
+    let below = 0;
+    for (const v of valid) {
+      if (v < x) below += 1;
+    }
+    return (below / valid.length) * 100;
+  }
+
+  /** Nearest-rank percentile. Rank = ceil(p/100 * n), 1-indexed. */
+  percentileNearest(site: string, source: Cell, period: number, percentage: number): Cell {
+    return this.percentileStep(this.percentileNearestSites, site, source, period, percentage, false);
+  }
+
+  /** Linear-interpolation percentile at rank (p/100)*(n-1). */
+  percentileLinear(site: string, source: Cell, period: number, percentage: number): Cell {
+    return this.percentileStep(this.percentileLinearSites, site, source, period, percentage, true);
+  }
+
+  private percentileStep(
+    sites: Map<string, PercentileState>,
+    site: string,
+    source: Cell,
+    period: number,
+    percentage: number,
+    linear: boolean,
+  ): Cell {
+    const n = pinePeriod(period);
+    if (n === null || !Number.isFinite(percentage)) return null;
+    let st = sites.get(site);
+    if (st === undefined || st.period !== n || st.percentage !== percentage) {
+      st = { period: n, percentage, window: [] };
+      sites.set(site, st);
+    }
+    if (st.window.length === n) st.window.shift();
+    st.window.push(finiteCell(source));
+    if (st.window.length < n) return null;
+    const sorted: number[] = [];
+    for (const v of st.window) {
+      if (v !== null) sorted.push(v);
+    }
+    if (sorted.length === 0) return null;
+    sorted.sort((a, b) => a - b);
+    const m = sorted.length;
+    if (linear) {
+      if (m === 1) return sorted[0]!;
+      const rank = (percentage / 100) * (m - 1);
+      const lo = Math.trunc(rank);
+      const hi = Math.min(lo + 1, m - 1);
+      const frac = rank - lo;
+      return sorted[lo]! * (1 - frac) + sorted[hi]! * frac;
+    }
+    let rank = Math.trunc((percentage / 100) * m + 0.999999);
+    if (rank < 1) rank = 1;
+    if (rank > m) rank = m;
+    return sorted[rank - 1]!;
+  }
+
+  /** Running sum. na / non-finite contributes 0 (`_cum_inc_update`). */
+  cum(site: string, source: Cell): Cell {
+    let st = this.cumSites.get(site);
+    if (st === undefined) {
+      st = { total: 0 };
+      this.cumSites.set(site, st);
+    }
+    const x = finiteCell(source);
+    st.total += x ?? 0;
+    return st.total;
+  }
+
+  /** Bars since last truthy cond (non-null, !=0). Never true → na. */
+  barssince(site: string, cond: Cell): Cell {
+    let st = this.barssinceSites.get(site);
+    if (st === undefined) {
+      st = { everTrue: false, barsSince: 0 };
+      this.barssinceSites.set(site, st);
+    }
+    const c = finiteCell(cond);
+    if (c !== null && c !== 0) {
+      st.everTrue = true;
+      st.barsSince = 0;
+      return 0;
+    }
+    st.barsSince += 1;
+    return st.everTrue ? st.barsSince : null;
+  }
+
+  /** Source at the `occurrence`-th most recent true cond (0 = latest). */
+  valuewhen(site: string, cond: Cell, source: Cell, occurrence = 0): Cell {
+    if (!Number.isFinite(occurrence) || occurrence < 0) return null;
+    const occ = Math.trunc(occurrence);
+    let st = this.valuewhenSites.get(site);
+    if (st === undefined || st.occurrence !== occ) {
+      st = { occurrence: occ, hits: [] };
+      this.valuewhenSites.set(site, st);
+    }
+    const c = finiteCell(cond);
+    if (c !== null && c !== 0) {
+      if (st.hits.length === occ + 1) st.hits.shift();
+      st.hits.push(finiteCell(source));
+    }
+    if (st.hits.length <= occ) return null;
+    return st.hits[st.hits.length - 1 - occ]!;
+  }
+
+  /** `highest - lowest` over `period` (nested highest/lowest sites). */
+  range(site: string, source: Cell, period: number): Cell {
+    const hi = this.highest(`${site}:hi`, source, period);
+    const lo = this.lowest(`${site}:lo`, source, period);
+    if (hi === null || lo === null) return null;
+    return hi - lo;
+  }
+
+  /** Alias of `highest`. */
+  max(site: string, source: Cell, period: number): Cell {
+    return this.highest(site, source, period);
+  }
+
+  /** Alias of `lowest`. */
+  min(site: string, source: Cell, period: number): Cell {
+    return this.lowest(site, source, period);
+  }
+}