@insiderfinance/totalfinance 0.1.0

package/modules/technical-analysis/dist/momentum-ext.js

@@ -0,0 +1,1772 @@
+/**
+ * Modern momentum / oscillator coverage (spec §13.3; pandas-ta parity) — part 1.
+ *
+ * bias, CFO, forecast oscillator, Coppock, CTI, efficiency ratio, center of gravity, psychological
+ * line, slope, PVO, Elder Ray, BRAR, KDJ, RVGI, PGO, TRIX histogram, SMI Ergodic, volume-weighted
+ * MACD. Each composes the proven base streams and is a serializable batch+stream facade. (RSI, MACD,
+ * Stochastic and the Phase-4 oscillators live in their own modules; the harder cycle-style oscillators
+ * — QQE, RSX, Schaff, Laguerre, TD Sequential, Squeeze — land in the next slice.)
+ */
+import * as builtinMetadata from './builtin-metadata.js';
+import { withBuiltinMetadata } from './indicator-metadata.js';
+import { ErrorCode, InputError, requireArgumentObject, requireFiniteFields, } from '../../core/dist/index.js';
+import { makeIndicator, snapshotOf, readSnapshot, } from './framework.js';
+import {} from './macd.js';
+import { EmaStream, SmaStream, VwmaStream, WmaStream } from './moving-averages.js';
+import { RocStream, TrixStream, TsiStream } from './oscillators.js';
+import { RsiStream } from './rsi.js';
+import { LinregStream } from './trend.js';
+import { RviStream } from './volatility.js';
+import { dirtyRows, dirtySamples, isDirtySample } from './nan-policy.js';
+import { requireInRange, requirePeriod, requirePositive } from './validate.js';
+import { requireStreamParameters } from './stream-validation.js';
+const nan = () => NaN;
+class BiasStream {
+    sma;
+    value = null;
+    constructor(period) {
+        requirePeriod(period, 'BiasStream');
+        this.sma = new SmaStream(period);
+    }
+    next(value) {
+        const m = this.sma.next(value);
+        this.value = m === null ? null : m === 0 ? NaN : ((value - m) / m) * 100;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('bias', { sma: this.sma.toJSON(), value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'bias');
+        const x = new BiasStream(1);
+        x.sma = SmaStream.fromJSON(state.child('sma'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const bias = withBuiltinMetadata(makeIndicator((p) => new BiasStream(requirePeriod(p.period ?? 26, 'bias')), BiasStream.fromJSON, nan), builtinMetadata.biasMetadata);
+// ───────────────────────── CFO / forecast oscillator ─────────────────────────
+class LinregOscStream {
+    lin;
+    value = null;
+    kind;
+    useForecast;
+    constructor(parameters) {
+        requireStreamParameters('LinregOscStream.constructor#0', 'LinregOscStream', parameters);
+        const { period, kind, useForecast } = parameters;
+        this.kind = kind;
+        this.useForecast = useForecast;
+        this.lin = new LinregStream(period);
+    }
+    next(value) {
+        const r = this.lin.next(value);
+        if (r === null) {
+            this.value = null;
+            return null;
+        }
+        const ref = this.useForecast ? r.forecast : r.value;
+        this.value = value === 0 ? NaN : ((value - ref) / value) * 100;
+        return this.value;
+    }
+    toJSON() {
+        // `useForecast` is NOT serialized: `LinregOscStream.restore(kind, useForecast)` is bound to it,
+        // so a stored copy would be a field nothing reads — change it and the restore ignores you.
+        return snapshotOf(this.kind, {
+            lin: this.lin.toJSON(),
+            value: this.value,
+        });
+    }
+    static restore(kind, useForecast) {
+        return (s) => {
+            const state = readSnapshot(s, kind);
+            const x = new LinregOscStream({ period: 1, kind, useForecast });
+            x.lin = LinregStream.fromJSON(state.child('lin'));
+            x.value = state.cached('value');
+            return x;
+        };
+    }
+}
+/** Chande Forecast Oscillator: % distance of price from its linear-regression value. */
+export const cfo = withBuiltinMetadata(makeIndicator((p) => new LinregOscStream({
+    period: requirePeriod(p.period ?? 14, 'cfo'),
+    kind: 'cfo',
+    useForecast: false,
+}), LinregOscStream.restore('cfo', false), nan), builtinMetadata.cfoMetadata);
+/** Forecast Oscillator: % distance of price from its time-series forecast (one bar ahead). */
+export const forecastOscillator = withBuiltinMetadata(makeIndicator((p) => new LinregOscStream({
+    period: requirePeriod(p.period ?? 14, 'forecastOscillator'),
+    kind: 'forecastOscillator',
+    useForecast: true,
+}), LinregOscStream.restore('forecastOscillator', true), nan), builtinMetadata.forecastOscillatorMetadata);
+class CoppockStream {
+    rocLong;
+    rocShort;
+    wma;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('CoppockStream.constructor#0', 'CoppockStream', parameters);
+        const { longRoc, shortRoc, wmaPeriod } = parameters;
+        this.rocLong = new RocStream({ period: longRoc, mode: 'roc' });
+        this.rocShort = new RocStream({ period: shortRoc, mode: 'roc' });
+        this.wma = new WmaStream(wmaPeriod);
+    }
+    next(value) {
+        const rl = this.rocLong.next(value);
+        const rs = this.rocShort.next(value);
+        if (rl === null || rs === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = this.wma.next(rl + rs);
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('coppock', {
+            rocLong: this.rocLong.toJSON(),
+            rocShort: this.rocShort.toJSON(),
+            wma: this.wma.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'coppock');
+        const x = new CoppockStream({ longRoc: 1, shortRoc: 1, wmaPeriod: 1 });
+        x.rocLong = RocStream.restore('roc')(state.child('rocLong'));
+        x.rocShort = RocStream.restore('roc')(state.child('rocShort'));
+        x.wma = WmaStream.fromJSON(state.child('wma'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const coppock = withBuiltinMetadata(makeIndicator((p) => new CoppockStream({
+    longRoc: requirePeriod(p.longRoc ?? 14, 'coppock', 'longRoc'),
+    shortRoc: requirePeriod(p.shortRoc ?? 11, 'coppock', 'shortRoc'),
+    wmaPeriod: requirePeriod(p.wma ?? 10, 'coppock', 'wma'),
+}), CoppockStream.fromJSON, nan), builtinMetadata.coppockMetadata);
+// ───────────────────────── CTI (correlation trend, Ehlers) ─────────────────────────
+class CtiStream {
+    period;
+    buf = [];
+    sumX;
+    sumX2;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'CtiStream');
+        const n = period;
+        this.sumX = (n * (n - 1)) / 2;
+        this.sumX2 = ((n - 1) * n * (2 * n - 1)) / 6;
+    }
+    next(value) {
+        this.buf.push(value);
+        if (this.buf.length > this.period)
+            this.buf.shift();
+        if (this.buf.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        const n = this.period;
+        let sumY = 0;
+        let sumXY = 0;
+        let sumY2 = 0;
+        for (let i = 0; i < n; i++) {
+            const y = this.buf[i];
+            sumY += y;
+            sumXY += i * y;
+            sumY2 += y * y;
+        }
+        const denom = Math.sqrt((n * this.sumX2 - this.sumX * this.sumX) * (n * sumY2 - sumY * sumY));
+        this.value = denom === 0 ? 0 : (n * sumXY - this.sumX * sumY) / denom;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('cti', { period: this.period, buf: [...this.buf], value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'cti');
+        const x = new CtiStream(state.lookback('period'));
+        x.buf = state.numbers('buf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const cti = withBuiltinMetadata(makeIndicator((p) => new CtiStream(requirePeriod(p.period ?? 12, 'cti')), CtiStream.fromJSON, nan), builtinMetadata.ctiMetadata);
+// ───────────────────────── efficiency ratio (Kaufman) ─────────────────────────
+class EfficiencyRatioStream {
+    period;
+    prices = [];
+    diffs = [];
+    volatilitySum = 0;
+    /** Non-finite samples inside the window — the interior-NaN gate (see `./nan-policy`). */
+    nanCount = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'EfficiencyRatioStream');
+    }
+    next(value) {
+        if (this.prices.length > 0) {
+            const d = Math.abs(value - this.prices[this.prices.length - 1]);
+            this.diffs.push(d);
+            // Interior-NaN policy: only finite deltas enter the running sum.
+            if (isDirtySample(d))
+                this.nanCount++;
+            else
+                this.volatilitySum += d;
+            if (this.diffs.length > this.period) {
+                const gone = this.diffs.shift();
+                if (isDirtySample(gone))
+                    this.nanCount--;
+                else
+                    this.volatilitySum -= gone;
+            }
+        }
+        this.prices.push(value);
+        if (this.prices.length > this.period + 1)
+            this.prices.shift();
+        if (this.diffs.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        if (this.nanCount > 0) {
+            this.value = NaN;
+            return this.value;
+        }
+        const change = Math.abs(value - this.prices[0]);
+        this.value = this.volatilitySum === 0 ? 0 : change / this.volatilitySum;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('efficiencyRatio', {
+            period: this.period,
+            prices: [...this.prices],
+            diffs: [...this.diffs],
+            volatilitySum: this.volatilitySum,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'efficiencyRatio');
+        const x = new EfficiencyRatioStream(state.lookback('period'));
+        Object.assign(x, { volatilitySum: state.number('volatilitySum') });
+        x.prices = state.numbers('prices');
+        x.diffs = state.numbers('diffs');
+        x.nanCount = dirtySamples(x.diffs);
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const efficiencyRatio = withBuiltinMetadata(makeIndicator((p) => new EfficiencyRatioStream(requirePeriod(p.period ?? 10, 'efficiencyRatio')), EfficiencyRatioStream.fromJSON, nan), builtinMetadata.efficiencyRatioMetadata);
+// ───────────────────────── center of gravity (Ehlers) ─────────────────────────
+class CenterOfGravityStream {
+    period;
+    buf = [];
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'CenterOfGravityStream');
+    }
+    next(value) {
+        this.buf.push(value);
+        if (this.buf.length > this.period)
+            this.buf.shift();
+        if (this.buf.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        const n = this.period;
+        let num = 0;
+        let den = 0;
+        for (let i = 0; i < n; i++) {
+            const price = this.buf[n - 1 - i]; // i bars ago (0 = current)
+            num += (1 + i) * price;
+            den += price;
+        }
+        this.value = den === 0 ? 0 : -num / den + (n + 1) / 2;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('centerOfGravity', {
+            period: this.period,
+            buf: [...this.buf],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'centerOfGravity');
+        const x = new CenterOfGravityStream(state.lookback('period'));
+        x.buf = state.numbers('buf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const centerOfGravity = withBuiltinMetadata(makeIndicator((p) => new CenterOfGravityStream(requirePeriod(p.period ?? 10, 'centerOfGravity')), CenterOfGravityStream.fromJSON, nan), builtinMetadata.centerOfGravityMetadata);
+// ───────────────────────── psychological line ─────────────────────────
+class PsychologicalLineStream {
+    period;
+    prev = null;
+    ups = [];
+    sum = 0;
+    /** Non-finite samples inside the window — the interior-NaN gate (see `./nan-policy`). */
+    nanCount = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'PsychologicalLineStream');
+    }
+    next(value) {
+        if (this.prev === null) {
+            this.prev = value;
+            this.value = null;
+            return null;
+        }
+        // A non-finite bar is not an "up" bar under `>`; recording it as 0 would understate the ratio
+        // with no disclosure, so it enters the window as NaN and gates the output instead.
+        const bad = isDirtySample(value) || isDirtySample(this.prev);
+        const up = bad ? NaN : value > this.prev ? 1 : 0;
+        this.prev = value;
+        this.ups.push(up);
+        if (bad)
+            this.nanCount++;
+        else
+            this.sum += up;
+        if (this.ups.length > this.period) {
+            const gone = this.ups.shift();
+            if (isDirtySample(gone))
+                this.nanCount--;
+            else
+                this.sum -= gone;
+        }
+        if (this.ups.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        if (this.nanCount > 0) {
+            this.value = NaN;
+            return this.value;
+        }
+        this.value = (100 * this.sum) / this.period;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('psychologicalLine', {
+            period: this.period,
+            prev: this.prev,
+            ups: [...this.ups],
+            sum: this.sum,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'psychologicalLine');
+        const x = new PsychologicalLineStream(state.lookback('period'));
+        Object.assign(x, { prev: state.numberOrNull('prev'), sum: state.number('sum') });
+        x.ups = state.numbers('ups');
+        x.nanCount = dirtySamples(x.ups);
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const psychologicalLine = withBuiltinMetadata(makeIndicator((p) => new PsychologicalLineStream(requirePeriod(p.period ?? 12, 'psychologicalLine')), PsychologicalLineStream.fromJSON, nan), builtinMetadata.psychologicalLineMetadata);
+// ───────────────────────── slope (rise / run) ─────────────────────────
+class SlopeStream {
+    period;
+    buf = [];
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'SlopeStream');
+    }
+    next(value) {
+        this.buf.push(value);
+        if (this.buf.length > this.period + 1)
+            this.buf.shift();
+        if (this.buf.length < this.period + 1) {
+            this.value = null;
+            return null;
+        }
+        this.value = (value - this.buf[0]) / this.period;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('slope', { period: this.period, buf: [...this.buf], value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'slope');
+        const x = new SlopeStream(state.lookback('period'));
+        x.buf = state.numbers('buf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const slope = withBuiltinMetadata(makeIndicator((p) => new SlopeStream(requirePeriod(p.period ?? 1, 'slope')), SlopeStream.fromJSON, nan), builtinMetadata.slopeMetadata);
+class PvoStream {
+    fast;
+    slow;
+    signalEma;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('PvoStream.constructor#0', 'PvoStream', parameters);
+        const { fast, slow, signal } = parameters;
+        this.fast = new EmaStream(fast);
+        this.slow = new EmaStream(slow);
+        this.signalEma = new EmaStream(signal);
+    }
+    next(bar) {
+        const volume = bar.volume ?? 0;
+        const f = this.fast.next(volume);
+        const s = this.slow.next(volume);
+        if (f === null || s === null || s === 0) {
+            this.value = null;
+            return null;
+        }
+        const pvo = ((f - s) / s) * 100;
+        const sig = this.signalEma.next(pvo);
+        if (sig === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = { pvo, signal: sig, histogram: pvo - sig };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('pvo', {
+            fast: this.fast.toJSON(),
+            slow: this.slow.toJSON(),
+            signal: this.signalEma.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'pvo');
+        const x = new PvoStream({ fast: 1, slow: 1, signal: 1 });
+        x.fast = EmaStream.fromJSON(state.child('fast'));
+        x.slow = EmaStream.fromJSON(state.child('slow'));
+        x.signalEma = EmaStream.fromJSON(state.child('signal'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const pvo = withBuiltinMetadata(makeIndicator((p) => new PvoStream({
+    fast: requirePeriod(p.fast ?? 12, 'pvo', 'fast'),
+    slow: requirePeriod(p.slow ?? 26, 'pvo', 'slow'),
+    signal: requirePeriod(p.signal ?? 9, 'pvo', 'signal'),
+}), PvoStream.fromJSON, () => ({ pvo: NaN, signal: NaN, histogram: NaN })), builtinMetadata.pvoMetadata);
+class ElderRayStream {
+    ema;
+    value = null;
+    constructor(period) {
+        requirePeriod(period, 'ElderRayStream');
+        this.ema = new EmaStream(period);
+    }
+    next(bar) {
+        const e = this.ema.next(bar.close);
+        if (e === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = { bull: bar.high - e, bear: bar.low - e };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('elderRay', { ema: this.ema.toJSON(), value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'elderRay');
+        const x = new ElderRayStream(1);
+        x.ema = EmaStream.fromJSON(state.child('ema'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const elderRay = withBuiltinMetadata(makeIndicator((p) => new ElderRayStream(requirePeriod(p.period ?? 13, 'elderRay')), ElderRayStream.fromJSON, () => ({ bull: NaN, bear: NaN })), builtinMetadata.elderRayMetadata);
+class BrarStream {
+    period;
+    previousClose = null;
+    hoSum = 0; // Σ(high − open)
+    olSum = 0; // Σ(open − low)
+    hcSum = 0; // Σ(high − previousClose)
+    clSum = 0; // Σ(previousClose − low)
+    ho = [];
+    ol = [];
+    hc = [];
+    cl = [];
+    /** Non-finite rows inside each window — the interior-NaN gate (see `./nan-policy`). */
+    nanHoOl = 0;
+    nanHcCl = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'BrarStream', 'period', 1, 'bars');
+    }
+    next(bar) {
+        const open = bar.open ?? bar.close;
+        const ho = bar.high - open;
+        const ol = open - bar.low;
+        this.ho.push(ho);
+        this.ol.push(ol);
+        // Interior-NaN policy: only finite rows enter the running sums.
+        if (isDirtySample(ho) || isDirtySample(ol))
+            this.nanHoOl++;
+        else {
+            this.hoSum += ho;
+            this.olSum += ol;
+        }
+        if (this.previousClose !== null) {
+            // `Math.max(0, NaN)` is NaN, so a bad prior close stays visible rather than clamping to 0.
+            const hc = Math.max(0, bar.high - this.previousClose);
+            const cl = Math.max(0, this.previousClose - bar.low);
+            this.hc.push(hc);
+            this.cl.push(cl);
+            if (isDirtySample(hc) || isDirtySample(cl))
+                this.nanHcCl++;
+            else {
+                this.hcSum += hc;
+                this.clSum += cl;
+            }
+        }
+        this.previousClose = bar.close;
+        if (this.ho.length > this.period) {
+            const goneHo = this.ho.shift();
+            const goneOl = this.ol.shift();
+            if (isDirtySample(goneHo) || isDirtySample(goneOl))
+                this.nanHoOl--;
+            else {
+                this.hoSum -= goneHo;
+                this.olSum -= goneOl;
+            }
+        }
+        if (this.hc.length > this.period) {
+            const goneHc = this.hc.shift();
+            const goneCl = this.cl.shift();
+            if (isDirtySample(goneHc) || isDirtySample(goneCl))
+                this.nanHcCl--;
+            else {
+                this.hcSum -= goneHc;
+                this.clSum -= goneCl;
+            }
+        }
+        if (this.ho.length < this.period || this.hc.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        if (this.nanHoOl > 0 || this.nanHcCl > 0) {
+            this.value = { popularityIndex: NaN, willingnessIndex: NaN };
+            return this.value;
+        }
+        this.value = {
+            popularityIndex: this.olSum === 0 ? 0 : (100 * this.hoSum) / this.olSum,
+            willingnessIndex: this.clSum === 0 ? 0 : (100 * this.hcSum) / this.clSum,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('brar', {
+            period: this.period,
+            previousClose: this.previousClose,
+            hoSum: this.hoSum,
+            olSum: this.olSum,
+            hcSum: this.hcSum,
+            clSum: this.clSum,
+            ho: [...this.ho],
+            ol: [...this.ol],
+            hc: [...this.hc],
+            cl: [...this.cl],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'brar');
+        const x = new BrarStream(state.lookback('period'));
+        Object.assign(x, {
+            previousClose: state.numberOrNull('previousClose'),
+            hoSum: state.number('hoSum'),
+            olSum: state.number('olSum'),
+            hcSum: state.number('hcSum'),
+            clSum: state.number('clSum'),
+        });
+        x.ho = state.numbers('ho');
+        x.ol = state.numbers('ol');
+        x.hc = state.numbers('hc');
+        x.cl = state.numbers('cl');
+        x.nanHoOl = dirtyRows(x.ho, x.ol);
+        x.nanHcCl = dirtyRows(x.hc, x.cl);
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const brar = withBuiltinMetadata(makeIndicator((p) => new BrarStream(requirePeriod(p.period ?? 26, 'brar')), BrarStream.fromJSON, () => ({ popularityIndex: NaN, willingnessIndex: NaN })), builtinMetadata.brarMetadata);
+class KdjStream {
+    highs = [];
+    lows = [];
+    k = null;
+    d = null;
+    alpha;
+    value = null;
+    period;
+    constructor(parameters) {
+        requireStreamParameters('KdjStream.constructor#0', 'KdjStream', parameters);
+        const { period, signal } = parameters;
+        this.period = period;
+        this.alpha = 1 / signal;
+    }
+    next(bar) {
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.period) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        if (this.highs.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        let hh = this.highs[0];
+        let ll = this.lows[0];
+        for (let i = 1; i < this.period; i++) {
+            if (this.highs[i] > hh)
+                hh = this.highs[i];
+            if (this.lows[i] < ll)
+                ll = this.lows[i];
+        }
+        const rsv = hh === ll ? 50 : (100 * (bar.close - ll)) / (hh - ll);
+        this.k = this.k === null ? rsv : this.k + this.alpha * (rsv - this.k);
+        this.d = this.d === null ? this.k : this.d + this.alpha * (this.k - this.d);
+        this.value = { k: this.k, d: this.d, j: 3 * this.k - 2 * this.d };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('kdj', {
+            period: this.period,
+            alpha: this.alpha,
+            highs: [...this.highs],
+            lows: [...this.lows],
+            k: this.k,
+            d: this.d,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'kdj');
+        const x = new KdjStream({ period: state.lookback('period'), signal: 1 });
+        Object.assign(x, {
+            alpha: state.number('alpha'),
+            k: state.numberOrNull('k'),
+            d: state.numberOrNull('d'),
+        });
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const kdj = withBuiltinMetadata(makeIndicator((p) => new KdjStream({
+    period: requirePeriod(p.period ?? 9, 'kdj'),
+    signal: requirePeriod(p.signal ?? 3, 'kdj', 'signal'),
+}), KdjStream.fromJSON, () => ({ k: NaN, d: NaN, j: NaN })), builtinMetadata.kdjMetadata);
+class RvgiStream {
+    co = []; // close − open, last 4
+    hl = []; // high − low, last 4
+    numSma;
+    denSma;
+    rvis = []; // last 4 RVI values for the signal swma
+    value = null;
+    constructor(period) {
+        requirePeriod(period, 'RvgiStream');
+        this.numSma = new SmaStream(period);
+        this.denSma = new SmaStream(period);
+    }
+    static swma4(a) {
+        // most-recent-last; weights 1,2,2,1 over the last four
+        const n = a.length;
+        return (a[n - 1] + 2 * a[n - 2] + 2 * a[n - 3] + a[n - 4]) / 6;
+    }
+    next(bar) {
+        const open = bar.open ?? bar.close;
+        this.co.push(bar.close - open);
+        this.hl.push(bar.high - bar.low);
+        if (this.co.length > 4) {
+            this.co.shift();
+            this.hl.shift();
+        }
+        if (this.co.length < 4) {
+            this.value = null;
+            return null;
+        }
+        const num = RvgiStream.swma4(this.co);
+        const den = RvgiStream.swma4(this.hl);
+        const numS = this.numSma.next(num);
+        const denS = this.denSma.next(den);
+        if (numS === null || denS === null) {
+            this.value = null;
+            return null;
+        }
+        const rvi = denS === 0 ? 0 : numS / denS;
+        this.rvis.push(rvi);
+        if (this.rvis.length > 4)
+            this.rvis.shift();
+        if (this.rvis.length < 4) {
+            this.value = null;
+            return null;
+        }
+        this.value = { rvi, signal: RvgiStream.swma4(this.rvis) };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('rvgi', {
+            co: [...this.co],
+            hl: [...this.hl],
+            numSma: this.numSma.toJSON(),
+            denSma: this.denSma.toJSON(),
+            rvis: [...this.rvis],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'rvgi');
+        const x = new RvgiStream(1);
+        x.numSma = SmaStream.fromJSON(state.child('numSma'));
+        x.denSma = SmaStream.fromJSON(state.child('denSma'));
+        x.co = state.numbers('co');
+        x.hl = state.numbers('hl');
+        x.rvis = state.numbers('rvis');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const relativeVigorIndex = withBuiltinMetadata(makeIndicator((p) => new RvgiStream(requirePeriod(p.period ?? 14, 'relativeVigorIndex')), RvgiStream.fromJSON, () => ({ rvi: NaN, signal: NaN })), builtinMetadata.relativeVigorIndexMetadata);
+// ───────────────────────── PGO (Pretty Good Oscillator) ─────────────────────────
+class PgoStream {
+    previousClose = null;
+    sma;
+    trEma;
+    value = null;
+    constructor(period) {
+        requirePeriod(period, 'PgoStream', 'period', 1, 'bars');
+        this.sma = new SmaStream(period);
+        this.trEma = new EmaStream(period);
+    }
+    next(bar) {
+        const tr = this.previousClose === null
+            ? bar.high - bar.low
+            : Math.max(bar.high - bar.low, Math.abs(bar.high - this.previousClose), Math.abs(bar.low - this.previousClose));
+        this.previousClose = bar.close;
+        const m = this.sma.next(bar.close);
+        const atr = this.trEma.next(tr);
+        if (m === null || atr === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = atr === 0 ? 0 : (bar.close - m) / atr;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('pgo', {
+            previousClose: this.previousClose,
+            sma: this.sma.toJSON(),
+            trEma: this.trEma.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'pgo');
+        const x = new PgoStream(1);
+        Object.assign(x, { previousClose: state.numberOrNull('previousClose') });
+        x.sma = SmaStream.fromJSON(state.child('sma'));
+        x.trEma = EmaStream.fromJSON(state.child('trEma'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const pgo = withBuiltinMetadata(makeIndicator((p) => new PgoStream(requirePeriod(p.period ?? 14, 'pgo')), PgoStream.fromJSON, nan), builtinMetadata.pgoMetadata);
+class TrixHistogramStream {
+    trix;
+    signalEma;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('TrixHistogramStream.constructor#0', 'TrixHistogramStream', parameters);
+        const { period, signal } = parameters;
+        this.trix = new TrixStream(period);
+        this.signalEma = new EmaStream(signal);
+    }
+    next(value) {
+        const t = this.trix.next(value);
+        if (t === null) {
+            this.value = null;
+            return null;
+        }
+        const sig = this.signalEma.next(t);
+        if (sig === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = { trix: t, signal: sig, histogram: t - sig };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('trixHistogram', {
+            trix: this.trix.toJSON(),
+            signal: this.signalEma.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'trixHistogram');
+        const x = new TrixHistogramStream({ period: 1, signal: 1 });
+        x.trix = TrixStream.fromJSON(state.child('trix'));
+        x.signalEma = EmaStream.fromJSON(state.child('signal'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const trixHistogram = withBuiltinMetadata(makeIndicator((p) => new TrixHistogramStream({
+    period: requirePeriod(p.period ?? 15, 'trixHistogram'),
+    signal: requirePeriod(p.signal ?? 9, 'trixHistogram', 'signal'),
+}), TrixHistogramStream.fromJSON, () => ({ trix: NaN, signal: NaN, histogram: NaN })), builtinMetadata.trixHistogramMetadata);
+class SmiErgodicStream {
+    tsi;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('SmiErgodicStream.constructor#0', 'SmiErgodicStream', parameters);
+        const { long, short, signal } = parameters;
+        this.tsi = new TsiStream({ long, short, signal });
+    }
+    next(value) {
+        const t = this.tsi.next(value);
+        if (t === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = { smi: t.tsi, signal: t.signal, oscillator: t.tsi - t.signal };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('smiErgodic', { tsi: this.tsi.toJSON(), value: this.value });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'smiErgodic');
+        const x = new SmiErgodicStream({ long: 1, short: 1, signal: 1 });
+        x.tsi = TsiStream.fromJSON(state.child('tsi'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const smiErgodic = withBuiltinMetadata(makeIndicator((p) => new SmiErgodicStream({
+    long: requirePeriod(p.long ?? 20, 'smiErgodic', 'long'),
+    short: requirePeriod(p.short ?? 5, 'smiErgodic', 'short'),
+    signal: requirePeriod(p.signal ?? 5, 'smiErgodic', 'signal'),
+}), SmiErgodicStream.fromJSON, () => ({ smi: NaN, signal: NaN, oscillator: NaN })), builtinMetadata.smiErgodicMetadata);
+class VolumeWeightedMacdStream {
+    fast;
+    slow;
+    signalEma;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('VolumeWeightedMacdStream.constructor#0', 'VolumeWeightedMacdStream', parameters);
+        const { fast, slow, signal } = parameters;
+        this.fast = new VwmaStream(fast);
+        this.slow = new VwmaStream(slow);
+        this.signalEma = new EmaStream(signal);
+    }
+    next(bar) {
+        const f = this.fast.next(bar);
+        const s = this.slow.next(bar);
+        if (f === null || s === null) {
+            this.value = null;
+            return null;
+        }
+        const macd = f - s;
+        const sig = this.signalEma.next(macd);
+        if (sig === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = { macd, signal: sig, histogram: macd - sig };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('volumeWeightedMacd', {
+            fast: this.fast.toJSON(),
+            slow: this.slow.toJSON(),
+            signal: this.signalEma.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'volumeWeightedMacd');
+        const x = new VolumeWeightedMacdStream({ fast: 1, slow: 1, signal: 1 });
+        x.fast = VwmaStream.fromJSON(state.child('fast'));
+        x.slow = VwmaStream.fromJSON(state.child('slow'));
+        x.signalEma = EmaStream.fromJSON(state.child('signal'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const volumeWeightedMacd = withBuiltinMetadata(makeIndicator((p) => new VolumeWeightedMacdStream({
+    fast: requirePeriod(p.fast ?? 12, 'volumeWeightedMacd', 'fast'),
+    slow: requirePeriod(p.slow ?? 26, 'volumeWeightedMacd', 'slow'),
+    signal: requirePeriod(p.signal ?? 9, 'volumeWeightedMacd', 'signal'),
+}), VolumeWeightedMacdStream.fromJSON, () => ({ macd: NaN, signal: NaN, histogram: NaN })), builtinMetadata.volumeWeightedMacdMetadata);
+class InertiaStream {
+    rvi;
+    lin;
+    value = null;
+    constructor(parameters) {
+        requireStreamParameters('InertiaStream.constructor#0', 'InertiaStream', parameters);
+        const { period, rviPeriod } = parameters;
+        this.rvi = new RviStream({ stdevPeriod: rviPeriod, smoothPeriod: rviPeriod });
+        this.lin = new LinregStream(period);
+    }
+    next(value) {
+        const r = this.rvi.next(value);
+        if (r === null) {
+            this.value = null;
+            return null;
+        }
+        const l = this.lin.next(r);
+        this.value = l === null ? null : l.value;
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('inertia', {
+            rvi: this.rvi.toJSON(),
+            lin: this.lin.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'inertia');
+        const x = new InertiaStream({ period: 1, rviPeriod: 2 });
+        x.rvi = RviStream.fromJSON(state.child('rvi'));
+        x.lin = LinregStream.fromJSON(state.child('lin'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const inertia = withBuiltinMetadata(makeIndicator((p) => new InertiaStream({
+    period: requirePeriod(p.period ?? 20, 'inertia'),
+    rviPeriod: requirePeriod(p.rviPeriod ?? 14, 'inertia', 'rviPeriod', 2),
+}), InertiaStream.fromJSON, nan), builtinMetadata.inertiaMetadata);
+class LaguerreRsiStream {
+    gamma;
+    l0 = null;
+    l1 = 0;
+    l2 = 0;
+    l3 = 0;
+    value = null;
+    constructor(gamma) {
+        this.gamma = gamma;
+    }
+    next(price) {
+        const g = this.gamma;
+        if (this.l0 === null) {
+            this.l0 = price;
+            this.l1 = price;
+            this.l2 = price;
+            this.l3 = price;
+            this.value = 0;
+            return 0;
+        }
+        const l0 = (1 - g) * price + g * this.l0;
+        const l1 = -g * l0 + this.l0 + g * this.l1;
+        const l2 = -g * l1 + this.l1 + g * this.l2;
+        const l3 = -g * l2 + this.l2 + g * this.l3;
+        let cu = 0;
+        let cd = 0;
+        if (l0 >= l1)
+            cu += l0 - l1;
+        else
+            cd += l1 - l0;
+        if (l1 >= l2)
+            cu += l1 - l2;
+        else
+            cd += l2 - l1;
+        if (l2 >= l3)
+            cu += l2 - l3;
+        else
+            cd += l3 - l2;
+        this.l0 = l0;
+        this.l1 = l1;
+        this.l2 = l2;
+        this.l3 = l3;
+        this.value = cu + cd === 0 ? 0 : cu / (cu + cd);
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('laguerreRsi', {
+            gamma: this.gamma,
+            l0: this.l0,
+            l1: this.l1,
+            l2: this.l2,
+            l3: this.l3,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'laguerreRsi');
+        const x = new LaguerreRsiStream(state.number('gamma'));
+        Object.assign(x, {
+            l0: state.numberOrNull('l0'),
+            l1: state.number('l1'),
+            l2: state.number('l2'),
+            l3: state.number('l3'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const laguerreRsi = withBuiltinMetadata(makeIndicator((p) => new LaguerreRsiStream(requireInRange(p.gamma ?? 0.5, 'laguerreRsi', 'gamma', 0, 1)), LaguerreRsiStream.fromJSON, nan), builtinMetadata.laguerreRsiMetadata);
+class QqeStream {
+    rsi;
+    rsiMaEma;
+    atrMa;
+    darEma;
+    prevRsiMa = null;
+    longBand = 0;
+    shortBand = 0;
+    initialized = false;
+    value = null;
+    factor;
+    constructor(parameters) {
+        requireStreamParameters('QqeStream.constructor#0', 'QqeStream', parameters);
+        const { rsiPeriod, smooth, factor } = parameters;
+        this.factor = factor;
+        const wilders = 2 * rsiPeriod - 1;
+        this.rsi = new RsiStream(rsiPeriod);
+        this.rsiMaEma = new EmaStream(smooth);
+        this.atrMa = new EmaStream(wilders);
+        this.darEma = new EmaStream(wilders);
+    }
+    next(value) {
+        const r = this.rsi.next(value);
+        if (r === null) {
+            this.value = null;
+            return null;
+        }
+        const rm = this.rsiMaEma.next(r);
+        if (rm === null) {
+            this.value = null;
+            return null;
+        }
+        if (this.prevRsiMa === null) {
+            this.prevRsiMa = rm;
+            this.value = null;
+            return null;
+        }
+        const atrRsi = Math.abs(rm - this.prevRsiMa);
+        const m1 = this.atrMa.next(atrRsi);
+        if (m1 === null) {
+            this.prevRsiMa = rm;
+            this.value = null;
+            return null;
+        }
+        const d = this.darEma.next(m1);
+        if (d === null) {
+            this.prevRsiMa = rm;
+            this.value = null;
+            return null;
+        }
+        const dar = d * this.factor;
+        const newLong = rm - dar;
+        const newShort = rm + dar;
+        if (!this.initialized) {
+            this.longBand = newLong;
+            this.shortBand = newShort;
+            this.initialized = true;
+        }
+        else {
+            const pl = this.longBand;
+            const ps = this.shortBand;
+            this.longBand = this.prevRsiMa > pl && rm > pl ? Math.max(pl, newLong) : newLong;
+            this.shortBand = this.prevRsiMa < ps && rm < ps ? Math.min(ps, newShort) : newShort;
+        }
+        this.prevRsiMa = rm;
+        this.value = { rsiMovingAverage: rm, longBand: this.longBand, shortBand: this.shortBand };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('qqe', {
+            factor: this.factor,
+            rsi: this.rsi.toJSON(),
+            rsiMaEma: this.rsiMaEma.toJSON(),
+            atrMa: this.atrMa.toJSON(),
+            darEma: this.darEma.toJSON(),
+            prevRsiMa: this.prevRsiMa,
+            longBand: this.longBand,
+            shortBand: this.shortBand,
+            initialized: this.initialized,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'qqe');
+        const x = new QqeStream({ rsiPeriod: 2, smooth: 1, factor: state.number('factor') });
+        x.rsi = RsiStream.fromJSON(state.child('rsi'));
+        x.rsiMaEma = EmaStream.fromJSON(state.child('rsiMaEma'));
+        x.atrMa = EmaStream.fromJSON(state.child('atrMa'));
+        x.darEma = EmaStream.fromJSON(state.child('darEma'));
+        Object.assign(x, {
+            prevRsiMa: state.numberOrNull('prevRsiMa'),
+            longBand: state.number('longBand'),
+            shortBand: state.number('shortBand'),
+            initialized: state.boolean('initialized'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const qqe = withBuiltinMetadata(makeIndicator((p) => new QqeStream({
+    rsiPeriod: requirePeriod(p.rsiPeriod ?? 14, 'qqe', 'rsiPeriod'),
+    smooth: requirePeriod(p.smooth ?? 5, 'qqe', 'smooth'),
+    factor: requirePositive(p.factor ?? 4.236, 'qqe', 'factor'),
+}), QqeStream.fromJSON, () => ({ rsiMovingAverage: NaN, longBand: NaN, shortBand: NaN })), builtinMetadata.qqeMetadata);
+// ───────────────────────── RSX (Jurik) ─────────────────────────
+/**
+ * Jurik RSX — the cascaded double-smoother momentum/|momentum| ratio mapped to [0, 100]. Uses the
+ * canonical Jurik filter cascade; the reference's f88/f90 warmup counter is replaced by the framework
+ * warmup (emits once `period` bars have been seen).
+ */
+class RsxStream {
+    period;
+    count = 0;
+    f10 = null;
+    f18;
+    f20;
+    f28 = 0;
+    f30 = 0;
+    f38 = 0;
+    f40 = 0;
+    f48 = 0;
+    f50 = 0;
+    f58 = 0;
+    f60 = 0;
+    f68 = 0;
+    f70 = 0;
+    f78 = 0;
+    f80 = 0;
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'RsxStream');
+        this.f18 = 3 / (period + 2);
+        this.f20 = 1 - this.f18;
+    }
+    next(price) {
+        this.count++;
+        const f8 = 100 * price;
+        if (this.f10 === null) {
+            this.f10 = f8;
+            this.value = null;
+            return null;
+        }
+        const v8 = f8 - this.f10;
+        this.f10 = f8;
+        const { f18, f20 } = this;
+        this.f28 = f20 * this.f28 + f18 * v8;
+        this.f30 = f18 * this.f28 + f20 * this.f30;
+        const vC = this.f28 * 1.5 - this.f30 * 0.5;
+        this.f38 = f20 * this.f38 + f18 * vC;
+        this.f40 = f18 * this.f38 + f20 * this.f40;
+        const v10 = this.f38 * 1.5 - this.f40 * 0.5;
+        this.f48 = f20 * this.f48 + f18 * v10;
+        this.f50 = f18 * this.f48 + f20 * this.f50;
+        const v14 = this.f48 * 1.5 - this.f50 * 0.5;
+        this.f58 = f20 * this.f58 + f18 * Math.abs(v8);
+        this.f60 = f18 * this.f58 + f20 * this.f60;
+        const v18 = this.f58 * 1.5 - this.f60 * 0.5;
+        this.f68 = f20 * this.f68 + f18 * v18;
+        this.f70 = f18 * this.f68 + f20 * this.f70;
+        const v1C = this.f68 * 1.5 - this.f70 * 0.5;
+        this.f78 = f20 * this.f78 + f18 * v1C;
+        this.f80 = f18 * this.f78 + f20 * this.f80;
+        const v20 = this.f78 * 1.5 - this.f80 * 0.5;
+        if (this.count <= this.period) {
+            this.value = null;
+            return null;
+        }
+        const raw = v20 === 0 ? 50 : (v14 / v20 + 1) * 50;
+        this.value = Math.max(0, Math.min(100, raw));
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('rsx', {
+            period: this.period,
+            count: this.count,
+            f10: this.f10,
+            f28: this.f28,
+            f30: this.f30,
+            f38: this.f38,
+            f40: this.f40,
+            f48: this.f48,
+            f50: this.f50,
+            f58: this.f58,
+            f60: this.f60,
+            f68: this.f68,
+            f70: this.f70,
+            f78: this.f78,
+            f80: this.f80,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'rsx');
+        const x = new RsxStream(state.lookback('period'));
+        Object.assign(x, {
+            count: state.number('count'),
+            f10: state.numberOrNull('f10'),
+            f28: state.number('f28'),
+            f30: state.number('f30'),
+            f38: state.number('f38'),
+            f40: state.number('f40'),
+            f48: state.number('f48'),
+            f50: state.number('f50'),
+            f58: state.number('f58'),
+            f60: state.number('f60'),
+            f68: state.number('f68'),
+            f70: state.number('f70'),
+            f78: state.number('f78'),
+            f80: state.number('f80'),
+        });
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const rsx = withBuiltinMetadata(makeIndicator((p) => new RsxStream(requirePeriod(p.period ?? 14, 'rsx')), RsxStream.fromJSON, nan), builtinMetadata.rsxMetadata);
+class SchaffTrendCycleStream {
+    emaFast;
+    emaSlow;
+    macdBuf = [];
+    d1 = null;
+    d1Buf = [];
+    d2 = null;
+    value = null;
+    cycle;
+    constructor(parameters) {
+        requireStreamParameters('SchaffTrendCycleStream.constructor#0', 'SchaffTrendCycleStream', parameters);
+        const { fast, slow, cycle } = parameters;
+        this.cycle = cycle;
+        this.emaFast = new EmaStream(fast);
+        this.emaSlow = new EmaStream(slow);
+    }
+    static stoch(buf, cur, prevSmoothed) {
+        let lo = buf[0];
+        let hi = buf[0];
+        for (const x of buf) {
+            if (x < lo)
+                lo = x;
+            if (x > hi)
+                hi = x;
+        }
+        return hi === lo ? (prevSmoothed ?? 0) : (100 * (cur - lo)) / (hi - lo);
+    }
+    next(value) {
+        const ef = this.emaFast.next(value);
+        const es = this.emaSlow.next(value);
+        if (ef === null || es === null) {
+            this.value = null;
+            return null;
+        }
+        const macd = ef - es;
+        this.macdBuf.push(macd);
+        if (this.macdBuf.length > this.cycle)
+            this.macdBuf.shift();
+        if (this.macdBuf.length < this.cycle) {
+            this.value = null;
+            return null;
+        }
+        const stoch1 = SchaffTrendCycleStream.stoch(this.macdBuf, macd, this.d1);
+        this.d1 = this.d1 === null ? stoch1 : this.d1 + 0.5 * (stoch1 - this.d1);
+        this.d1Buf.push(this.d1);
+        if (this.d1Buf.length > this.cycle)
+            this.d1Buf.shift();
+        if (this.d1Buf.length < this.cycle) {
+            this.value = null;
+            return null;
+        }
+        const stoch2 = SchaffTrendCycleStream.stoch(this.d1Buf, this.d1, this.d2);
+        this.d2 = this.d2 === null ? stoch2 : this.d2 + 0.5 * (stoch2 - this.d2);
+        this.value = Math.max(0, Math.min(100, this.d2));
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('schaffTrendCycle', {
+            cycle: this.cycle,
+            emaFast: this.emaFast.toJSON(),
+            emaSlow: this.emaSlow.toJSON(),
+            macdBuf: [...this.macdBuf],
+            d1: this.d1,
+            d1Buf: [...this.d1Buf],
+            d2: this.d2,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'schaffTrendCycle');
+        const x = new SchaffTrendCycleStream({ fast: 1, slow: 1, cycle: state.number('cycle') });
+        x.emaFast = EmaStream.fromJSON(state.child('emaFast'));
+        x.emaSlow = EmaStream.fromJSON(state.child('emaSlow'));
+        Object.assign(x, { d1: state.numberOrNull('d1'), d2: state.numberOrNull('d2') });
+        x.macdBuf = state.numbers('macdBuf');
+        x.d1Buf = state.numbers('d1Buf');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const schaffTrendCycle = withBuiltinMetadata(makeIndicator((p) => new SchaffTrendCycleStream({
+    fast: requirePeriod(p.fast ?? 23, 'schaffTrendCycle', 'fast'),
+    slow: requirePeriod(p.slow ?? 50, 'schaffTrendCycle', 'slow'),
+    cycle: requirePeriod(p.cycle ?? 10, 'schaffTrendCycle', 'cycle'),
+}), SchaffTrendCycleStream.fromJSON, nan), builtinMetadata.schaffTrendCycleMetadata);
+// ───────────────────────── TTM Squeeze ─────────────────────────
+function popStdev(buf) {
+    const n = buf.length;
+    let sum = 0;
+    for (const x of buf)
+        sum += x;
+    const mean = sum / n;
+    let acc = 0;
+    for (const x of buf) {
+        const d = x - mean;
+        acc += d * d;
+    }
+    return Math.sqrt(acc / n);
+}
+function maxOf(xs) {
+    let m = xs[0];
+    for (let i = 1; i < xs.length; i++)
+        if (xs[i] > m)
+            m = xs[i];
+    return m;
+}
+function minOf(xs) {
+    let m = xs[0];
+    for (let i = 1; i < xs.length; i++)
+        if (xs[i] < m)
+            m = xs[i];
+    return m;
+}
+/** Shared Bollinger-inside-Keltner squeeze machinery + the LazyBear momentum histogram. */
+class SqueezeCore {
+    previousClose = null;
+    smaKc;
+    trSma;
+    smaBb;
+    bbBuf = [];
+    highs = [];
+    lows = [];
+    lin;
+    bollingerBandPeriod;
+    bollingerStandardDeviations;
+    keltnerChannelPeriod;
+    constructor(parameters) {
+        requireStreamParameters('SqueezeCore.constructor#0', 'SqueezeCore', parameters);
+        const { bollingerBandPeriod, bollingerStandardDeviations, keltnerChannelPeriod } = parameters;
+        this.bollingerBandPeriod = bollingerBandPeriod;
+        this.bollingerStandardDeviations = bollingerStandardDeviations;
+        this.keltnerChannelPeriod = keltnerChannelPeriod;
+        this.smaKc = new SmaStream(keltnerChannelPeriod);
+        this.trSma = new SmaStream(keltnerChannelPeriod);
+        this.smaBb = new SmaStream(bollingerBandPeriod);
+        this.lin = new LinregStream(keltnerChannelPeriod);
+    }
+    /** Returns null until both bands and the momentum regression are warm. */
+    update(bar) {
+        // Public per-tick entry: a malformed bar used to fold NaN into every band and poison the
+        // window state for all later ticks (first-touch law). Three typeof checks per tick is noise
+        // next to the window arithmetic that follows.
+        requireArgumentObject('SqueezeCore.update', 'bar', bar);
+        requireFiniteFields('SqueezeCore.update', bar, ['high', 'low', 'close'], {
+            exampleCall: 'SqueezeCore.update({ high: 11, low: 9, close: 10.5 })',
+        });
+        const tr = this.previousClose === null
+            ? bar.high - bar.low
+            : Math.max(bar.high - bar.low, Math.abs(bar.high - this.previousClose), Math.abs(bar.low - this.previousClose));
+        this.previousClose = bar.close;
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.keltnerChannelPeriod) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        this.bbBuf.push(bar.close);
+        if (this.bbBuf.length > this.bollingerBandPeriod)
+            this.bbBuf.shift();
+        const keltnerChannelMiddle = this.smaKc.next(bar.close);
+        const keltnerChannelRange = this.trSma.next(tr);
+        const bbMid = this.smaBb.next(bar.close);
+        if (keltnerChannelMiddle === null || keltnerChannelRange === null || bbMid === null)
+            return null;
+        if (this.highs.length < this.keltnerChannelPeriod ||
+            this.bbBuf.length < this.bollingerBandPeriod)
+            return null;
+        const hh = maxOf(this.highs);
+        const ll = minOf(this.lows);
+        const mm = ((hh + ll) / 2 + keltnerChannelMiddle) / 2;
+        const lr = this.lin.next(bar.close - mm);
+        if (lr === null)
+            return null;
+        const dev = this.bollingerStandardDeviations * popStdev(this.bbBuf);
+        return {
+            upperBollingerBand: bbMid + dev,
+            lowerBollingerBand: bbMid - dev,
+            keltnerChannelMiddle,
+            keltnerChannelRange,
+            momentum: lr.value,
+        };
+    }
+    toJSON() {
+        return snapshotOf('squeezeCore', {
+            bollingerBandPeriod: this.bollingerBandPeriod,
+            bollingerStandardDeviations: this.bollingerStandardDeviations,
+            keltnerChannelPeriod: this.keltnerChannelPeriod,
+            previousClose: this.previousClose,
+            smaKc: this.smaKc.toJSON(),
+            trSma: this.trSma.toJSON(),
+            smaBb: this.smaBb.toJSON(),
+            bbBuf: [...this.bbBuf],
+            highs: [...this.highs],
+            lows: [...this.lows],
+            lin: this.lin.toJSON(),
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'squeezeCore');
+        const x = new SqueezeCore({
+            bollingerBandPeriod: state.number('bollingerBandPeriod'),
+            bollingerStandardDeviations: state.number('bollingerStandardDeviations'),
+            keltnerChannelPeriod: state.number('keltnerChannelPeriod'),
+        });
+        Object.assign(x, { previousClose: state.numberOrNull('previousClose') });
+        x.smaKc = SmaStream.fromJSON(state.child('smaKc'));
+        x.trSma = SmaStream.fromJSON(state.child('trSma'));
+        x.smaBb = SmaStream.fromJSON(state.child('smaBb'));
+        x.lin = LinregStream.fromJSON(state.child('lin'));
+        x.bbBuf = state.numbers('bbBuf');
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        return x;
+    }
+}
+class SqueezeStream {
+    core;
+    value = null;
+    keltnerChannelMultiplier;
+    constructor(parameters) {
+        requireStreamParameters('SqueezeStream.constructor#0', 'SqueezeStream', parameters);
+        const { bollingerBandPeriod, bollingerStandardDeviations, keltnerChannelPeriod, keltnerChannelMultiplier, } = parameters;
+        this.keltnerChannelMultiplier = keltnerChannelMultiplier;
+        this.core = new SqueezeCore({
+            bollingerBandPeriod,
+            bollingerStandardDeviations,
+            keltnerChannelPeriod,
+        });
+    }
+    next(bar) {
+        const o = this.core.update(bar);
+        if (o === null) {
+            this.value = null;
+            return null;
+        }
+        const upperKC = o.keltnerChannelMiddle + this.keltnerChannelMultiplier * o.keltnerChannelRange;
+        const lowerKC = o.keltnerChannelMiddle - this.keltnerChannelMultiplier * o.keltnerChannelRange;
+        const on = o.lowerBollingerBand > lowerKC && o.upperBollingerBand < upperKC ? 1 : 0;
+        this.value = { on, momentum: o.momentum };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('squeeze', {
+            keltnerChannelMultiplier: this.keltnerChannelMultiplier,
+            core: this.core.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'squeeze');
+        const x = new SqueezeStream({
+            bollingerBandPeriod: 1,
+            bollingerStandardDeviations: 1,
+            keltnerChannelPeriod: 1,
+            keltnerChannelMultiplier: state.number('keltnerChannelMultiplier'),
+        });
+        x.core = SqueezeCore.fromJSON(state.child('core'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const squeeze = withBuiltinMetadata(makeIndicator((p) => new SqueezeStream({
+    bollingerBandPeriod: requirePeriod(p.bollingerBandPeriod ?? 20, 'squeeze', 'bollingerBandPeriod'),
+    bollingerStandardDeviations: requirePositive(p.bollingerStandardDeviations ?? 2, 'squeeze', 'bollingerStandardDeviations'),
+    keltnerChannelPeriod: requirePeriod(p.keltnerChannelPeriod ?? 20, 'squeeze', 'keltnerChannelPeriod'),
+    keltnerChannelMultiplier: requirePositive(p.keltnerChannelMultiplier ?? 1.5, 'squeeze', 'keltnerChannelMultiplier'),
+}), SqueezeStream.fromJSON, () => ({ on: NaN, momentum: NaN })), builtinMetadata.squeezeMetadata);
+class SqueezeProStream {
+    core;
+    value = null;
+    wideKeltnerChannelMultiplier;
+    normalKeltnerChannelMultiplier;
+    narrowKeltnerChannelMultiplier;
+    constructor(parameters) {
+        requireStreamParameters('SqueezeProStream.constructor#0', 'SqueezeProStream', parameters);
+        const { bollingerBandPeriod, bollingerStandardDeviations, keltnerChannelPeriod, wideKeltnerChannelMultiplier, normalKeltnerChannelMultiplier, narrowKeltnerChannelMultiplier, } = parameters;
+        this.wideKeltnerChannelMultiplier = wideKeltnerChannelMultiplier;
+        this.normalKeltnerChannelMultiplier = normalKeltnerChannelMultiplier;
+        this.narrowKeltnerChannelMultiplier = narrowKeltnerChannelMultiplier;
+        this.core = new SqueezeCore({
+            bollingerBandPeriod,
+            bollingerStandardDeviations,
+            keltnerChannelPeriod,
+        });
+    }
+    inside(o, mult) {
+        return o.lowerBollingerBand > o.keltnerChannelMiddle - mult * o.keltnerChannelRange &&
+            o.upperBollingerBand < o.keltnerChannelMiddle + mult * o.keltnerChannelRange
+            ? 1
+            : 0;
+    }
+    next(bar) {
+        const o = this.core.update(bar);
+        if (o === null) {
+            this.value = null;
+            return null;
+        }
+        this.value = {
+            lowCompression: this.inside(o, this.wideKeltnerChannelMultiplier),
+            normalCompression: this.inside(o, this.normalKeltnerChannelMultiplier),
+            highCompression: this.inside(o, this.narrowKeltnerChannelMultiplier),
+            momentum: o.momentum,
+        };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('squeezePro', {
+            wideKeltnerChannelMultiplier: this.wideKeltnerChannelMultiplier,
+            normalKeltnerChannelMultiplier: this.normalKeltnerChannelMultiplier,
+            narrowKeltnerChannelMultiplier: this.narrowKeltnerChannelMultiplier,
+            core: this.core.toJSON(),
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'squeezePro');
+        const x = new SqueezeProStream({
+            bollingerBandPeriod: 1,
+            bollingerStandardDeviations: 1,
+            keltnerChannelPeriod: 1,
+            wideKeltnerChannelMultiplier: state.number('wideKeltnerChannelMultiplier'),
+            normalKeltnerChannelMultiplier: state.number('normalKeltnerChannelMultiplier'),
+            narrowKeltnerChannelMultiplier: state.number('narrowKeltnerChannelMultiplier'),
+        });
+        x.core = SqueezeCore.fromJSON(state.child('core'));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+/**
+ * The three Keltner multipliers, each validated as a NUMBER before their ORDERING is judged.
+ *
+ * RV10 — order of validation is part of the contract. This checked `wide > normal > narrow` first
+ * and left positivity to three separate `requirePositive` calls spread in after it, so
+ * `wideKeltnerChannelMultiplier: NaN` reported `input.out_of_range` with the message "must satisfy
+ * wideKeltnerChannelMultiplier > normalKeltnerChannelMultiplier > …". `NaN > 1.5` is false, so a
+ * TYPE failure was reported as a RELATION failure, and the caller was told to reorder three numbers
+ * when one of them was not a number. `Infinity` happened to read correctly only because
+ * `Infinity > 1.5` is true and it fell through to the finiteness check — the taxonomy was right by
+ * luck on one input class and wrong on the other.
+ *
+ * Ordering is a relation between three already-valid numbers, so it cannot be judged until they are
+ * known to be numbers. Validating and returning them here also removes the duplicate
+ * `requirePositive` calls at the call site, where the object-literal evaluation order was the only
+ * thing sequencing the two checks.
+ */
+function requireOrderedMultipliers(p) {
+    const wide = requirePositive(p.wideKeltnerChannelMultiplier ?? 2.0, 'squeezePro', 'wideKeltnerChannelMultiplier');
+    const normal = requirePositive(p.normalKeltnerChannelMultiplier ?? 1.5, 'squeezePro', 'normalKeltnerChannelMultiplier');
+    const narrow = requirePositive(p.narrowKeltnerChannelMultiplier ?? 1.0, 'squeezePro', 'narrowKeltnerChannelMultiplier');
+    if (!(wide > normal && normal > narrow)) {
+        throw new InputError('squeezePro: the Keltner multipliers must satisfy ' +
+            'wideKeltnerChannelMultiplier > normalKeltnerChannelMultiplier > ' +
+            `narrowKeltnerChannelMultiplier; got wideKeltnerChannelMultiplier=${wide}, ` +
+            `normalKeltnerChannelMultiplier=${normal}, narrowKeltnerChannelMultiplier=${narrow}.` +
+            '\n  e.g. squeezePro(bars, { wideKeltnerChannelMultiplier: 2, ' +
+            'normalKeltnerChannelMultiplier: 1.5, narrowKeltnerChannelMultiplier: 1 })', {
+            code: ErrorCode.InputOutOfRange,
+            context: {
+                function: 'squeezePro',
+                wideKeltnerChannelMultiplier: wide,
+                normalKeltnerChannelMultiplier: normal,
+                narrowKeltnerChannelMultiplier: narrow,
+            },
+        });
+    }
+    return {
+        wideKeltnerChannelMultiplier: wide,
+        normalKeltnerChannelMultiplier: normal,
+        narrowKeltnerChannelMultiplier: narrow,
+    };
+}
+export const squeezePro = withBuiltinMetadata(makeIndicator((p) => new SqueezeProStream({
+    bollingerBandPeriod: requirePeriod(p.bollingerBandPeriod ?? 20, 'squeezePro', 'bollingerBandPeriod'),
+    bollingerStandardDeviations: requirePositive(p.bollingerStandardDeviations ?? 2, 'squeezePro', 'bollingerStandardDeviations'),
+    keltnerChannelPeriod: requirePeriod(p.keltnerChannelPeriod ?? 20, 'squeezePro', 'keltnerChannelPeriod'),
+    ...requireOrderedMultipliers(p),
+}), SqueezeProStream.fromJSON, () => ({ lowCompression: NaN, normalCompression: NaN, highCompression: NaN, momentum: NaN })), builtinMetadata.squeezeProMetadata);
+class ProjectionOscillatorStream {
+    period;
+    lin;
+    highs = [];
+    lows = [];
+    value = null;
+    constructor(period) {
+        this.period = period;
+        requirePeriod(period, 'ProjectionOscillatorStream');
+        this.lin = new LinregStream(period);
+    }
+    next(bar) {
+        const lr = this.lin.next(bar.close);
+        this.highs.push(bar.high);
+        this.lows.push(bar.low);
+        if (this.highs.length > this.period) {
+            this.highs.shift();
+            this.lows.shift();
+        }
+        if (lr === null || this.highs.length < this.period) {
+            this.value = null;
+            return null;
+        }
+        const slope = lr.slope;
+        const n = this.period;
+        let pu = -Infinity;
+        let pl = Infinity;
+        for (let i = 0; i < n; i++) {
+            // i bars ago, projected forward to now along the regression slope
+            const hi = this.highs[n - 1 - i] + slope * i;
+            const lo = this.lows[n - 1 - i] + slope * i;
+            if (hi > pu)
+                pu = hi;
+            if (lo < pl)
+                pl = lo;
+        }
+        const po = pu === pl ? 50 : (100 * (bar.close - pl)) / (pu - pl);
+        this.value = { po, upper: pu, lower: pl };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('projectionOscillator', {
+            period: this.period,
+            lin: this.lin.toJSON(),
+            highs: [...this.highs],
+            lows: [...this.lows],
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'projectionOscillator');
+        const x = new ProjectionOscillatorStream(state.lookback('period'));
+        x.lin = LinregStream.fromJSON(state.child('lin'));
+        x.highs = state.numbers('highs');
+        x.lows = state.numbers('lows');
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const projectionOscillator = withBuiltinMetadata(makeIndicator((p) => new ProjectionOscillatorStream(requirePeriod(p.period ?? 14, 'projectionOscillator')), ProjectionOscillatorStream.fromJSON, () => ({ po: NaN, upper: NaN, lower: NaN })), builtinMetadata.projectionOscillatorMetadata);
+/**
+ * Core TD Sequential: the price-flip setup (1–9) and a basic countdown (1–13). This implements the
+ * essential setup/countdown signal, not the full DeMark ruleset (no perfection / cancellation /
+ * deferral qualifiers).
+ */
+class TdSequentialStream {
+    lookback;
+    closes = []; // last lookback+1 closes
+    bars = []; // last 3 bars (for low[2]/high[2])
+    buySetup = 0;
+    sellSetup = 0;
+    armed = 0; // +1 sell countdown, −1 buy countdown, 0 none
+    countdown = 0;
+    value = null;
+    constructor(lookback) {
+        this.lookback = lookback;
+        requirePeriod(lookback, 'TdSequentialStream', 'lookback', 1, 'bars');
+    }
+    next(bar) {
+        this.closes.push(bar.close);
+        if (this.closes.length > this.lookback + 1)
+            this.closes.shift();
+        this.bars.push(bar);
+        if (this.bars.length > 3)
+            this.bars.shift();
+        if (this.closes.length < this.lookback + 1) {
+            this.value = null;
+            return null;
+        }
+        const refClose = this.closes[0]; // `lookback` bars ago
+        let setup = 0;
+        let direction = 0;
+        if (bar.close < refClose) {
+            const was = this.buySetup;
+            this.buySetup = Math.min(this.buySetup + 1, 9);
+            this.sellSetup = 0;
+            if (was === 8 && this.buySetup === 9) {
+                this.armed = -1;
+                this.countdown = 0;
+            }
+            setup = this.buySetup;
+            direction = -1;
+        }
+        else if (bar.close > refClose) {
+            const was = this.sellSetup;
+            this.sellSetup = Math.min(this.sellSetup + 1, 9);
+            this.buySetup = 0;
+            if (was === 8 && this.sellSetup === 9) {
+                this.armed = 1;
+                this.countdown = 0;
+            }
+            setup = this.sellSetup;
+            direction = 1;
+        }
+        else {
+            this.buySetup = 0;
+            this.sellSetup = 0;
+        }
+        if (this.armed !== 0 && this.bars.length === 3) {
+            const ago2 = this.bars[0]; // 2 bars ago
+            if (this.armed === -1 && bar.close <= ago2.low && this.countdown < 13)
+                this.countdown++;
+            else if (this.armed === 1 && bar.close >= ago2.high && this.countdown < 13)
+                this.countdown++;
+            if (this.countdown >= 13)
+                this.armed = 0; // countdown complete
+        }
+        this.value = { setup, countdown: this.countdown, direction };
+        return this.value;
+    }
+    toJSON() {
+        return snapshotOf('tdSequential', {
+            lookback: this.lookback,
+            closes: [...this.closes],
+            bars: this.bars.map((x) => ({ ...x })),
+            buySetup: this.buySetup,
+            sellSetup: this.sellSetup,
+            armed: this.armed,
+            countdown: this.countdown,
+            value: this.value,
+        });
+    }
+    static fromJSON(snapshot) {
+        const state = readSnapshot(snapshot, 'tdSequential');
+        const x = new TdSequentialStream(state.lookback('lookback'));
+        Object.assign(x, {
+            buySetup: state.number('buySetup'),
+            sellSetup: state.number('sellSetup'),
+            armed: state.number('armed'),
+            countdown: state.number('countdown'),
+        });
+        x.closes = state.numbers('closes');
+        x.bars = state.records('bars').map((y) => ({ ...y }));
+        x.value = state.cached('value');
+        return x;
+    }
+}
+export const tdSequential = withBuiltinMetadata(makeIndicator((p) => new TdSequentialStream(requirePeriod(p.lookback ?? 4, 'tdSequential', 'lookback')), TdSequentialStream.fromJSON, () => ({ setup: NaN, countdown: NaN, direction: NaN })), builtinMetadata.tdSequentialMetadata);
+export { BiasStream, LinregOscStream, CoppockStream, CtiStream, EfficiencyRatioStream, CenterOfGravityStream, PsychologicalLineStream, SlopeStream, PvoStream, ElderRayStream, BrarStream, KdjStream, RvgiStream, PgoStream, TrixHistogramStream, SmiErgodicStream, VolumeWeightedMacdStream, InertiaStream, LaguerreRsiStream, QqeStream, RsxStream, SchaffTrendCycleStream, SqueezeCore, SqueezeStream, SqueezeProStream, ProjectionOscillatorStream, TdSequentialStream, };
+//# sourceMappingURL=momentum-ext.js.map