F9: add Accumulation/Distribution Line and Volume-Price Trend

Completes the F9 family (Cumulative volume) end to end:

- Rust core: adl.rs (Accumulation/Distribution Line — cumulative
  range-weighted volume) and vpt.rs (Volume-Price Trend — cumulative
  volume scaled by percentage price change). Each with a full Indicator
  impl, runnable doctest and reference / cumulative-property / warmup /
  reset / batch==streaming tests.
- Python: PyAdl / PyVolumePriceTrend PyO3 classes + module registration
  + .pyi stubs (no parameters, like OBV/VWAP).
- Node: explicit AdlNode and VolumePriceTrendNode; index.d.ts and
  index.js updated.
- WASM: WasmAdl and WasmVolumePriceTrend.
- Wiki: Indicator-Adl.md and Indicator-VolumePriceTrend.md plus rows in
  Indicators-Overview.md and entries in Home.md.

cargo fmt + clippy (core/wickra/data/wasm/node) clean; 373 core tests,
25 data tests and 53 doctests green.

crates/wickra-core/src/indicators/adl.rs

@@ -0,0 +1,185 @@
+//! Accumulation/Distribution Line.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Accumulation/Distribution Line — Marc Chaikin's cumulative volume-flow
+/// indicator.
+///
+/// Each bar contributes a *money-flow volume*: the bar's volume weighted by
+/// where the close fell within the bar's range.
+///
+/// ```text
+/// MFM_t = ((close − low) − (high − close)) / (high − low)   (the money-flow multiplier, −1..+1)
+/// MFV_t = MFM_t · volume_t
+/// ADL_t = ADL_{t−1} + MFV_t
+/// ```
+///
+/// A close near the high makes the multiplier near `+1` (accumulation), near
+/// the low near `−1` (distribution). The running total is unbounded and drifts
+/// with cumulative volume — what matters is its slope and its divergence from
+/// price. A bar with `high == low` contributes `0`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, Adl};
+///
+/// let mut indicator = Adl::new();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct Adl {
+    total: f64,
+    has_emitted: bool,
+}
+
+impl Adl {
+    /// Construct a new Accumulation/Distribution Line starting at zero.
+    pub const fn new() -> Self {
+        Self {
+            total: 0.0,
+            has_emitted: false,
+        }
+    }
+
+    /// Current cumulative value if at least one candle has been ingested.
+    pub const fn value(&self) -> Option<f64> {
+        if self.has_emitted {
+            Some(self.total)
+        } else {
+            None
+        }
+    }
+}
+
+impl Indicator for Adl {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let range = candle.high - candle.low;
+        let mfv = if range == 0.0 {
+            // A zero-range bar carries no positional information.
+            0.0
+        } else {
+            let mfm = ((candle.close - candle.low) - (candle.high - candle.close)) / range;
+            mfm * candle.volume
+        };
+        self.total += mfv;
+        self.has_emitted = true;
+        Some(self.total)
+    }
+
+    fn reset(&mut self) {
+        self.total = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "ADL"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(open: f64, high: f64, low: f64, close: f64, volume: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, volume, ts).unwrap()
+    }
+
+    #[test]
+    fn reference_values() {
+        // bar 1: close at high -> MFM = +1 -> MFV = +100; ADL = 100.
+        // bar 2: h=12 l=8 c=9  -> MFM = ((9-8)-(12-9))/4 = -0.5 -> MFV = -100;
+        //        ADL = 100 - 100 = 0.
+        let mut adl = Adl::new();
+        let out = adl.batch(&[
+            candle(8.0, 10.0, 8.0, 10.0, 100.0, 0),
+            candle(10.0, 12.0, 8.0, 9.0, 200.0, 1),
+        ]);
+        assert_relative_eq!(out[0].unwrap(), 100.0, epsilon = 1e-12);
+        assert_relative_eq!(out[1].unwrap(), 0.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn emits_from_first_candle() {
+        let mut adl = Adl::new();
+        assert_eq!(adl.warmup_period(), 1);
+        assert!(adl.update(candle(8.0, 10.0, 8.0, 9.0, 50.0, 0)).is_some());
+    }
+
+    #[test]
+    fn close_at_high_accumulates_full_volume() {
+        // Every bar closes at its high: MFM = +1, so ADL grows by `volume`.
+        let mut adl = Adl::new();
+        let mut expected = 0.0;
+        for i in 0..10 {
+            let c = candle(8.0, 10.0, 8.0, 10.0, 25.0, i);
+            expected += 25.0;
+            assert_relative_eq!(adl.update(c).unwrap(), expected, epsilon = 1e-9);
+        }
+    }
+
+    #[test]
+    fn zero_range_bar_contributes_nothing() {
+        let mut adl = Adl::new();
+        adl.update(candle(8.0, 10.0, 8.0, 10.0, 100.0, 0));
+        let before = adl.value().unwrap();
+        // A flat candle (high == low) adds zero.
+        let after = adl.update(candle(9.0, 9.0, 9.0, 9.0, 999.0, 1)).unwrap();
+        assert_relative_eq!(after, before, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut adl = Adl::new();
+        adl.batch(&[
+            candle(8.0, 10.0, 8.0, 9.0, 100.0, 0),
+            candle(9.0, 11.0, 9.0, 10.0, 100.0, 1),
+        ]);
+        assert!(adl.is_ready());
+        adl.reset();
+        assert!(!adl.is_ready());
+        assert_eq!(adl.value(), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..60)
+            .map(|i| {
+                let mid = 100.0 + (i as f64 * 0.3).sin() * 8.0;
+                candle(
+                    mid,
+                    mid + 2.0,
+                    mid - 2.0,
+                    mid + 0.5,
+                    10.0 + (i % 5) as f64,
+                    i,
+                )
+            })
+            .collect();
+        let batch = Adl::new().batch(&candles);
+        let mut b = Adl::new();
+        let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/indicators/mod.rs

@@ -4,6 +4,7 @@
 //! volume) but every public name is also re-exported flat from this module and
 //! from the crate root for convenience.
 
+mod adl;
 mod adx;
 mod aroon;
 mod aroon_oscillator;
@@ -47,12 +48,14 @@ mod tsi;
 mod ulcer_index;
 mod ultimate_oscillator;
 mod vortex;
+mod vpt;
 mod vwap;
 mod vwma;
 mod williams_r;
 mod wma;
 mod zlema;
 
+pub use adl::Adl;
 pub use adx::{Adx, AdxOutput};
 pub use aroon::{Aroon, AroonOutput};
 pub use aroon_oscillator::AroonOscillator;
@@ -96,6 +99,7 @@ pub use tsi::Tsi;
 pub use ulcer_index::UlcerIndex;
 pub use ultimate_oscillator::UltimateOscillator;
 pub use vortex::{Vortex, VortexOutput};
+pub use vpt::VolumePriceTrend;
 pub use vwap::{RollingVwap, Vwap};
 pub use vwma::Vwma;
 pub use williams_r::WilliamsR;

crates/wickra-core/src/indicators/vpt.rs

@@ -0,0 +1,179 @@
+//! Volume-Price Trend.
+
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+/// Volume-Price Trend — a cumulative volume line weighted by percentage price
+/// change.
+///
+/// VPT is a close relative of [`Obv`](crate::Obv), but instead of adding the
+/// full bar volume on every up-close it adds volume scaled by the *size* of
+/// the move:
+///
+/// ```text
+/// VPT_t = VPT_{t−1} + volume_t · (close_t − close_{t−1}) / close_{t−1}
+/// ```
+///
+/// A big move on heavy volume moves the line far; a small move on the same
+/// volume barely nudges it. The running total is unbounded — its slope and its
+/// divergence from price are what carry the signal. The first bar establishes
+/// the baseline at `0`.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, VolumePriceTrend};
+///
+/// let mut indicator = VolumePriceTrend::new();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base + 1.0, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct VolumePriceTrend {
+    prev_close: Option<f64>,
+    total: f64,
+    has_emitted: bool,
+}
+
+impl VolumePriceTrend {
+    /// Construct a new Volume-Price Trend starting at zero.
+    pub const fn new() -> Self {
+        Self {
+            prev_close: None,
+            total: 0.0,
+            has_emitted: false,
+        }
+    }
+
+    /// Current cumulative value if at least one candle has been ingested.
+    pub const fn value(&self) -> Option<f64> {
+        if self.has_emitted {
+            Some(self.total)
+        } else {
+            None
+        }
+    }
+}
+
+impl Indicator for VolumePriceTrend {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        self.has_emitted = true;
+        let Some(prev) = self.prev_close else {
+            // The first candle establishes the baseline at 0.
+            self.prev_close = Some(candle.close);
+            return Some(self.total);
+        };
+        let roc = if prev == 0.0 {
+            // Undefined ratio against a zero previous close.
+            0.0
+        } else {
+            (candle.close - prev) / prev
+        };
+        self.total += candle.volume * roc;
+        self.prev_close = Some(candle.close);
+        Some(self.total)
+    }
+
+    fn reset(&mut self) {
+        self.prev_close = None;
+        self.total = 0.0;
+        self.has_emitted = false;
+    }
+
+    fn warmup_period(&self) -> usize {
+        1
+    }
+
+    fn is_ready(&self) -> bool {
+        self.has_emitted
+    }
+
+    fn name(&self) -> &'static str {
+        "VPT"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(close: f64, volume: f64, ts: i64) -> Candle {
+        Candle::new(close, close, close, close, volume, ts).unwrap()
+    }
+
+    #[test]
+    fn reference_values() {
+        // closes [10, 11, 9], volumes [100, 200, 300]:
+        //   bar 1: baseline 0.
+        //   bar 2: VPT += 200 · (11-10)/10 = 20  -> 20.
+        //   bar 3: VPT += 300 · (9-11)/11 = -600/11 -> 20 - 600/11.
+        let mut vpt = VolumePriceTrend::new();
+        let out = vpt.batch(&[
+            candle(10.0, 100.0, 0),
+            candle(11.0, 200.0, 1),
+            candle(9.0, 300.0, 2),
+        ]);
+        assert_relative_eq!(out[0].unwrap(), 0.0, epsilon = 1e-12);
+        assert_relative_eq!(out[1].unwrap(), 20.0, epsilon = 1e-12);
+        assert_relative_eq!(out[2].unwrap(), 20.0 - 600.0 / 11.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn emits_from_first_candle_at_zero() {
+        let mut vpt = VolumePriceTrend::new();
+        assert_eq!(vpt.warmup_period(), 1);
+        assert_eq!(vpt.update(candle(100.0, 50.0, 0)), Some(0.0));
+    }
+
+    #[test]
+    fn constant_close_keeps_line_flat() {
+        // No price change -> no contribution regardless of volume.
+        let mut vpt = VolumePriceTrend::new();
+        let candles: Vec<Candle> = (0..20).map(|i| candle(100.0, 500.0, i)).collect();
+        for v in vpt.batch(&candles).into_iter().flatten() {
+            assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut vpt = VolumePriceTrend::new();
+        vpt.batch(&[
+            candle(10.0, 100.0, 0),
+            candle(11.0, 100.0, 1),
+            candle(12.0, 100.0, 2),
+        ]);
+        assert!(vpt.is_ready());
+        vpt.reset();
+        assert!(!vpt.is_ready());
+        assert_eq!(vpt.value(), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..60)
+            .map(|i| {
+                candle(
+                    100.0 + (i as f64 * 0.3).sin() * 8.0,
+                    10.0 + (i % 5) as f64,
+                    i,
+                )
+            })
+            .collect();
+        let batch = VolumePriceTrend::new().batch(&candles);
+        let mut b = VolumePriceTrend::new();
+        let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect();
+        assert_eq!(batch, streamed);
+    }
+}

crates/wickra-core/src/lib.rs

@@ -44,12 +44,13 @@ pub mod indicators;
 
 pub use error::{Error, Result};
 pub use indicators::{
-    Adx, AdxOutput, Aroon, AroonOscillator, AroonOutput, Atr, AwesomeOscillator, BollingerBands,
-    BollingerBandwidth, BollingerOutput, Cci, Cmo, Coppock, Dema, Donchian, DonchianOutput, Dpo,
-    Ema, HistoricalVolatility, Hma, Kama, Keltner, KeltnerOutput, MacdIndicator, MacdOutput,
-    MassIndex, Mfi, Mom, Natr, Obv, PercentB, Pmo, Ppo, Psar, Roc, RollingVwap, Rsi, Sma, Smma,
-    StdDev, StochRsi, Stochastic, StochasticOutput, Tema, Trima, Trix, Tsi, UlcerIndex,
-    UltimateOscillator, Vortex, VortexOutput, Vwap, Vwma, WilliamsR, Wma, Zlema, T3,
+    Adl, Adx, AdxOutput, Aroon, AroonOscillator, AroonOutput, Atr, AwesomeOscillator,
+    BollingerBands, BollingerBandwidth, BollingerOutput, Cci, Cmo, Coppock, Dema, Donchian,
+    DonchianOutput, Dpo, Ema, HistoricalVolatility, Hma, Kama, Keltner, KeltnerOutput,
+    MacdIndicator, MacdOutput, MassIndex, Mfi, Mom, Natr, Obv, PercentB, Pmo, Ppo, Psar, Roc,
+    RollingVwap, Rsi, Sma, Smma, StdDev, StochRsi, Stochastic, StochasticOutput, Tema, Trima, Trix,
+    Tsi, UlcerIndex, UltimateOscillator, VolumePriceTrend, Vortex, VortexOutput, Vwap, Vwma,
+    WilliamsR, Wma, Zlema, T3,
 };
 pub use ohlcv::{Candle, Tick};
 pub use traits::{BatchExt, Chain, Indicator};