feat: add Market Breadth family with CrossSection input (#153)

## What

Adds a new indicator input type and family for **market-breadth** analysis — indicators that aggregate the state of an entire universe of symbols at each tick, rather than a single instrument's price. This is the last open input-type on the expansion roadmap (S10) and unblocks the remaining breadth indicators (McClellan, TRIN, High-Low Index, ...).

## Core

- **`CrossSection` input type** (`crates/wickra-core/src/cross_section.rs`) — one tick carrying the per-symbol state of the whole universe as a `Vec<Member>` + `timestamp`. Each `Member` precomputes a signed `change` (sign classifies advancing / declining / unchanged), a `volume`, and `new_high` / `new_low` extreme flags, so the breadth indicators stay stateless per tick. Both `Member` and `CrossSection` are `#[non_exhaustive]` for additive field growth. `CrossSection::new` validates the universe (non-empty, finite changes, finite non-negative volumes); `new_unchecked` skips validation for hot paths. `advancers()` / `decliners()` count by sign.
- **`Error::InvalidCrossSection`** variant for the validation failures.
- **`AdvanceDecline`** (`advance_decline.rs`) — the Advance/Decline Line: the running cumulative sum of net advancing-minus-declining issues. `Input = CrossSection`, `Output = f64`, ready after the first tick.
- New **"Market Breadth"** `FAMILIES` group; indicator count **314 → 315**, family count nineteen → twenty.

## Bindings

All custom (CrossSection is non-scalar, so no macros apply). The universe crosses each boundary as parallel arrays (`change`, `volume`, `new_high`, `new_low`):
- **Python / Node** expose `update` + `batch` (one array group per tick). Node satisfies the completeness contract (`update`/`batch`/`reset`/`isReady`/`warmupPeriod`).
- **WASM** exposes only `update` (the universe is ragged across ticks, matching the other multi-input wasm indicators) with numeric high/low flags.
- Python `map_err` gains the new error arm; `__init__.py` gets a `# Market Breadth` section in both the import and `__all__` blocks. `index.d.ts` / `index.js` regenerated.

## Tests / Fuzz

- Dedicated **streaming-vs-batch + reference-value + ragged-rejection** tests in Python (`test_new_indicators.py`) and Node (`indicators.test.js`) — kept out of the scalar/candle parametrize lists.
- Rust unit tests cover every reject branch (empty / non-finite change / negative & non-finite volume) and every indicator branch.
- New fuzz target `indicator_update_crosssection` drives `AdvanceDecline` over bounded ragged universes built with `new_unchecked`.

## Verify

- `cargo fmt --all` clean
- `cargo test -p wickra-core --lib` → 2593 passed; `--doc` → 298 passed
- `cargo clippy --workspace --all-targets --all-features -- -D warnings` clean
- `cd bindings/node && npm run build && npm test` → 398 passed
- `maturin develop --release` + `pytest bindings/python/tests` → all passed
- counter check: mod-count 315 == lib-block 315

crates/wickra-core/src/cross_section.rs

@@ -0,0 +1,226 @@
+//! Cross-section value type: a market-breadth snapshot across a whole universe.
+//!
+//! A [`CrossSection`] is a single tick that carries the per-symbol state of
+//! *every* symbol in a universe at one point in time. It is the non-OHLCV input
+//! consumed by the market-breadth indicator family (advance/decline, `McClellan`,
+//! the TRIN / Arms index, the high-low index, ...), each of which aggregates the
+//! whole cross-section into a single breadth reading. This is the same
+//! one-rich-type-per-family pattern as [`DerivativesTick`] and [`OrderBook`].
+//!
+//! Each [`Member`] precomputes the per-symbol signals the breadth indicators
+//! need — a signed price `change` (whose sign classifies the symbol as
+//! advancing, declining or unchanged), the period `volume`, and the
+//! `new_high` / `new_low` extreme flags — so the indicators stay stateless per
+//! tick and never have to track per-symbol history.
+//!
+//! [`DerivativesTick`]: crate::DerivativesTick
+//! [`OrderBook`]: crate::OrderBook
+
+use crate::error::{Error, Result};
+
+/// One symbol's contribution to a [`CrossSection`] tick.
+///
+/// Field invariants enforced by [`CrossSection::new`] when the member is placed
+/// into a tick:
+///
+/// - `change` is finite (its sign classifies the symbol — positive is
+///   advancing, negative is declining, zero is unchanged).
+/// - `volume` is finite and non-negative.
+///
+/// `new_high` / `new_low` are caller-supplied flags marking whether the symbol
+/// printed a new period extreme; they carry no numeric invariant.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Member {
+    /// Price change versus the previous close. Sign classifies the symbol:
+    /// positive is advancing, negative is declining, zero is unchanged.
+    pub change: f64,
+    /// Period volume for the symbol (finite, non-negative).
+    pub volume: f64,
+    /// Whether the symbol printed a new period high.
+    pub new_high: bool,
+    /// Whether the symbol printed a new period low.
+    pub new_low: bool,
+}
+
+impl Member {
+    /// Assemble a cross-section member.
+    ///
+    /// The field invariants documented on [`Member`] are validated centrally by
+    /// [`CrossSection::new`] when the member is placed into a tick; this
+    /// constructor only assembles the value so the `#[non_exhaustive]` struct can
+    /// be built from outside the crate.
+    #[must_use]
+    pub const fn new(change: f64, volume: f64, new_high: bool, new_low: bool) -> Self {
+        Self {
+            change,
+            volume,
+            new_high,
+            new_low,
+        }
+    }
+}
+
+/// A market-breadth cross-section: the per-symbol state of an entire universe at
+/// a single point in time.
+///
+/// Invariants enforced by [`new`](CrossSection::new):
+///
+/// - `members` is non-empty (a breadth reading needs at least one symbol).
+/// - every member's `change` is finite, and `volume` is finite and non-negative.
+///
+/// `timestamp` is a caller-defined epoch / resolution and is not validated.
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct CrossSection {
+    /// Per-symbol members of the universe for this tick.
+    pub members: Vec<Member>,
+    /// Tick timestamp (caller-defined epoch / resolution).
+    pub timestamp: i64,
+}
+
+impl CrossSection {
+    /// Construct a cross-section, validating every member invariant.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Error::InvalidCrossSection`] if `members` is empty, if any
+    /// member has a non-finite `change`, or if any member has a `volume` that is
+    /// not a finite non-negative number.
+    pub fn new(members: Vec<Member>, timestamp: i64) -> Result<Self> {
+        if members.is_empty() {
+            return Err(Error::InvalidCrossSection {
+                message: "cross-section must contain at least one member",
+            });
+        }
+        for member in &members {
+            if !member.change.is_finite() {
+                return Err(Error::InvalidCrossSection {
+                    message: "member change must be finite",
+                });
+            }
+            if !member.volume.is_finite() || member.volume < 0.0 {
+                return Err(Error::InvalidCrossSection {
+                    message: "member volume must be finite and non-negative",
+                });
+            }
+        }
+        Ok(Self { members, timestamp })
+    }
+
+    /// Construct a cross-section without validation. The caller asserts that
+    /// every invariant documented on [`CrossSection`] holds.
+    #[must_use]
+    pub const fn new_unchecked(members: Vec<Member>, timestamp: i64) -> Self {
+        Self { members, timestamp }
+    }
+
+    /// Number of advancing symbols (those with a strictly positive `change`).
+    #[must_use]
+    pub fn advancers(&self) -> usize {
+        self.members.iter().filter(|m| m.change > 0.0).count()
+    }
+
+    /// Number of declining symbols (those with a strictly negative `change`).
+    #[must_use]
+    pub fn decliners(&self) -> usize {
+        self.members.iter().filter(|m| m.change < 0.0).count()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn members() -> Vec<Member> {
+        vec![
+            Member::new(1.5, 100.0, true, false),
+            Member::new(-0.5, 50.0, false, true),
+            Member::new(0.0, 0.0, false, false),
+        ]
+    }
+
+    #[test]
+    fn new_accepts_valid() {
+        let cs = CrossSection::new(members(), 42).unwrap();
+        assert_eq!(cs.members.len(), 3);
+        assert_eq!(cs.timestamp, 42);
+        assert_eq!(cs.members[0].change, 1.5);
+        assert_eq!(cs.members[0].volume, 100.0);
+        assert!(cs.members[0].new_high);
+        assert!(cs.members[1].new_low);
+    }
+
+    #[test]
+    fn member_new_assembles_fields() {
+        let m = Member::new(2.0, 10.0, true, false);
+        assert_eq!(m.change, 2.0);
+        assert_eq!(m.volume, 10.0);
+        assert!(m.new_high);
+        assert!(!m.new_low);
+    }
+
+    #[test]
+    fn new_rejects_empty() {
+        assert!(matches!(
+            CrossSection::new(Vec::new(), 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_change() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(f64::NAN, 10.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(f64::INFINITY, 10.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_negative_volume() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(1.0, -1.0, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_rejects_non_finite_volume() {
+        assert!(matches!(
+            CrossSection::new(vec![Member::new(1.0, f64::NAN, false, false)], 0),
+            Err(Error::InvalidCrossSection { .. })
+        ));
+    }
+
+    #[test]
+    fn new_unchecked_skips_validation() {
+        let cs = CrossSection::new_unchecked(vec![Member::new(f64::NAN, -1.0, false, false)], 7);
+        assert_eq!(cs.members.len(), 1);
+        assert_eq!(cs.timestamp, 7);
+    }
+
+    #[test]
+    fn advancers_and_decliners_count_by_sign() {
+        let cs = CrossSection::new(members(), 0).unwrap();
+        assert_eq!(cs.advancers(), 1);
+        assert_eq!(cs.decliners(), 1);
+    }
+
+    #[test]
+    fn unchanged_members_count_as_neither() {
+        let cs = CrossSection::new(
+            vec![
+                Member::new(0.0, 1.0, false, false),
+                Member::new(0.0, 1.0, false, false),
+            ],
+            0,
+        )
+        .unwrap();
+        assert_eq!(cs.advancers(), 0);
+        assert_eq!(cs.decliners(), 0);
+    }
+}

crates/wickra-core/src/error.rs

@@ -52,6 +52,14 @@ pub enum Error {
     /// own variant.
     #[error("invalid derivatives tick: {message}")]
     InvalidDerivatives { message: &'static str },
+
+    /// A market-breadth cross-section whose members do not satisfy the
+    /// cross-section invariants (an empty universe, a non-finite change, or a
+    /// negative / non-finite volume) was provided. A cross-section is a
+    /// breadth input distinct from candles, ticks, order books and trades, so
+    /// it surfaces as its own variant.
+    #[error("invalid cross-section: {message}")]
+    InvalidCrossSection { message: &'static str },
 }
 
 /// Convenience alias for `Result<T, wickra_core::Error>`.

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

@@ -0,0 +1,168 @@
+//! Advance/Decline Line — cumulative net advancing-minus-declining issues.
+
+use crate::cross_section::CrossSection;
+use crate::traits::Indicator;
+
+/// Advance/Decline Line (A/D Line) — the running cumulative sum of net advancing
+/// issues across a universe.
+///
+/// On each [`CrossSection`] tick the net breadth is `advancers - decliners`:
+/// the number of symbols with a positive price change minus the number with a
+/// negative change (unchanged symbols are ignored). The line accumulates this
+/// net value over time, so a rising line means advancers have persistently
+/// outnumbered decliners — broad participation — while a falling line warns that
+/// a rally is being carried by fewer and fewer names (a breadth divergence when
+/// the index itself is still rising).
+///
+/// `Input = CrossSection`, `Output = f64`. The line is defined from the very
+/// first tick, so `warmup_period == 1` and the indicator is ready after one
+/// update.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{AdvanceDecline, CrossSection, Indicator, Member};
+///
+/// let mut ad = AdvanceDecline::new();
+/// // 3 advancers, 1 decliner -> net +2.
+/// let tick = CrossSection::new(
+///     vec![
+///         Member::new(1.0, 10.0, false, false),
+///         Member::new(0.5, 10.0, false, false),
+///         Member::new(2.0, 10.0, false, false),
+///         Member::new(-1.0, 10.0, false, false),
+///     ],
+///     0,
+/// )
+/// .unwrap();
+/// assert_eq!(ad.update(tick), Some(2.0));
+/// ```
+#[derive(Debug, Clone, Default)]
+pub struct AdvanceDecline {
+    line: f64,
+    has_emitted: bool,
+}
+
+impl AdvanceDecline {
+    /// Construct a new Advance/Decline Line indicator.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            line: 0.0,
+            has_emitted: false,
+        }
+    }
+}
+
+impl Indicator for AdvanceDecline {
+    type Input = CrossSection;
+    type Output = f64;
+
+    fn update(&mut self, section: CrossSection) -> Option<f64> {
+        let net = section.advancers() as f64 - section.decliners() as f64;
+        self.line += net;
+        self.has_emitted = true;
+        Some(self.line)
+    }
+
+    fn reset(&mut self) {
+        self.line = 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 {
+        "AdvanceDecline"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cross_section::Member;
+    use crate::traits::BatchExt;
+
+    /// Build a cross-section with `up` advancers, `down` decliners and `flat`
+    /// unchanged symbols.
+    fn section(up: usize, down: usize, flat: usize) -> CrossSection {
+        let mut members = Vec::new();
+        for _ in 0..up {
+            members.push(Member::new(1.0, 10.0, false, false));
+        }
+        for _ in 0..down {
+            members.push(Member::new(-1.0, 10.0, false, false));
+        }
+        for _ in 0..flat {
+            members.push(Member::new(0.0, 10.0, false, false));
+        }
+        CrossSection::new(members, 0).unwrap()
+    }
+
+    #[test]
+    fn accessors_and_metadata() {
+        let ad = AdvanceDecline::new();
+        assert_eq!(ad.name(), "AdvanceDecline");
+        assert_eq!(ad.warmup_period(), 1);
+        assert!(!ad.is_ready());
+    }
+
+    #[test]
+    fn first_tick_emits_net_breadth() {
+        let mut ad = AdvanceDecline::new();
+        assert_eq!(ad.update(section(3, 1, 0)), Some(2.0));
+        assert!(ad.is_ready());
+    }
+
+    #[test]
+    fn line_accumulates_across_ticks() {
+        let mut ad = AdvanceDecline::new();
+        assert_eq!(ad.update(section(3, 1, 0)), Some(2.0)); // +2 -> 2
+        assert_eq!(ad.update(section(1, 4, 0)), Some(-1.0)); // -3 -> -1
+        assert_eq!(ad.update(section(2, 0, 0)), Some(1.0)); // +2 -> 1
+    }
+
+    #[test]
+    fn unchanged_symbols_are_ignored() {
+        let mut ad = AdvanceDecline::new();
+        // 2 up, 2 down, 5 unchanged -> net 0, line stays flat.
+        assert_eq!(ad.update(section(2, 2, 5)), Some(0.0));
+        assert_eq!(ad.update(section(2, 2, 5)), Some(0.0));
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut ad = AdvanceDecline::new();
+        ad.update(section(5, 0, 0));
+        assert!(ad.is_ready());
+        ad.reset();
+        assert!(!ad.is_ready());
+        // Line restarts from zero, not from the pre-reset value.
+        assert_eq!(ad.update(section(1, 0, 0)), Some(1.0));
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let sections = vec![
+            section(3, 1, 2),
+            section(1, 4, 0),
+            section(2, 2, 1),
+            section(5, 0, 3),
+        ];
+        let mut a = AdvanceDecline::new();
+        let mut b = AdvanceDecline::new();
+        assert_eq!(
+            a.batch(&sections),
+            sections
+                .iter()
+                .map(|s| b.update(s.clone()))
+                .collect::<Vec<_>>()
+        );
+    }
+}

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

@@ -11,6 +11,7 @@ mod ad_oscillator;
 mod adaptive_cycle;
 mod adl;
 mod advance_block;
+mod advance_decline;
 mod adx;
 mod adxr;
 mod alligator;
@@ -325,6 +326,7 @@ pub use ad_oscillator::AdOscillator;
 pub use adaptive_cycle::AdaptiveCycle;
 pub use adl::Adl;
 pub use advance_block::AdvanceBlock;
+pub use advance_decline::AdvanceDecline;
 pub use adx::{Adx, AdxOutput};
 pub use adxr::Adxr;
 pub use alligator::{Alligator, AlligatorOutput};
@@ -1038,6 +1040,7 @@ pub const FAMILIES: &[(&str, &[&str])] = &[
         "Alt-Chart Bars",
         &["RenkoBars", "KagiBars", "PointAndFigureBars"],
     ),
+    ("Market Breadth", &["AdvanceDecline"]),
 ];
 
 #[cfg(test)]
@@ -1066,6 +1069,6 @@ mod family_tests {
         // the actual indicator count is the early-warning signal that an
         // indicator was added without being assigned a family.
         let total: usize = FAMILIES.iter().map(|(_, ns)| ns.len()).sum();
-        assert_eq!(total, 314, "FAMILIES total drifted from indicator count");
+        assert_eq!(total, 315, "FAMILIES total drifted from indicator count");
     }
 }

crates/wickra-core/src/lib.rs

@@ -42,6 +42,7 @@
 // builds — library code is still linted for genuinely large stack arrays.
 #![cfg_attr(test, allow(clippy::large_stack_arrays))]
 
+mod cross_section;
 mod derivatives;
 mod error;
 mod microstructure;
@@ -50,68 +51,69 @@ mod traits;
 
 pub mod indicators;
 
+pub use cross_section::{CrossSection, Member};
 pub use derivatives::DerivativesTick;
 pub use error::{Error, Result};
 pub use indicators::{
     AbandonedBaby, AccelerationBands, AccelerationBandsOutput, AcceleratorOscillator, AdOscillator,
-    AdaptiveCycle, Adl, AdvanceBlock, Adx, AdxOutput, Adxr, Alligator, AlligatorOutput, Alma,
-    Alpha, AnchoredRsi, AnchoredVwap, Apo, Aroon, AroonOscillator, AroonOutput, Atr, AtrBands,
-    AtrBandsOutput, AtrTrailingStop, Autocorrelation, AverageDrawdown, AvgPrice, AwesomeOscillator,
-    AwesomeOscillatorHistogram, BalanceOfPower, BeltHold, Beta, BollingerBands, BollingerBandwidth,
-    BollingerOutput, Breakaway, CalendarSpread, CalmarRatio, Camarilla, CamarillaPivotsOutput, Cci,
-    CenterOfGravity, Cfo, ChaikinMoneyFlow, ChaikinOscillator, ChaikinVolatility, ChandeKrollStop,
-    ChandeKrollStopOutput, ChandelierExit, ChandelierExitOutput, ChoppinessIndex, ClassicPivots,
-    ClassicPivotsOutput, ClosingMarubozu, Cmo, CoefficientOfVariation, Cointegration,
-    CointegrationOutput, ConcealingBabySwallow, ConditionalValueAtRisk, ConnorsRsi, Coppock,
-    Counterattack, CumulativeVolumeDelta, CyberneticCycle, Decycler, DecyclerOscillator, Dema,
-    DemandIndex, DemarkPivots, DemarkPivotsOutput, DepthSlope, DetrendedStdDev, Doji, DojiStar,
-    Donchian, DonchianOutput, DonchianStop, DonchianStopOutput, DoubleBollinger,
-    DoubleBollingerOutput, DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, Dx,
-    EaseOfMovement, EffectiveSpread, EhlersStochastic, ElderImpulse, Ema,
-    EmpiricalModeDecomposition, Engulfing, EveningDojiStar, Evwma, FallingThreeMethods, Fama,
-    FibonacciPivots, FibonacciPivotsOutput, FisherTransform, Footprint, FootprintOutput,
-    ForceIndex, FractalChaosBands, FractalChaosBandsOutput, Frama, FundingBasis, FundingRate,
-    FundingRateMean, FundingRateZScore, GainLossRatio, GapSideBySideWhite, GarmanKlassVolatility,
-    GravestoneDoji, Hammer, HangingMan, Harami, HeikinAshi, HeikinAshiOutput, HiLoActivator,
-    HighWave, Hikkake, HikkakeModified, HilbertDominantCycle, HistoricalVolatility, Hma,
-    HomingPigeon, HtDcPhase, HtPhasor, HtPhasorOutput, HtTrendMode, HurstChannel,
-    HurstChannelOutput, HurstExponent, Ichimoku, IchimokuOutput, IdenticalThreeCrows, InNeck,
-    Inertia, InformationRatio, InitialBalance, InitialBalanceOutput, InstantaneousTrendline,
-    InverseFisherTransform, InvertedHammer, Jma, KagiBars, Kama, KellyCriterion, Keltner,
-    KeltnerOutput, Kicking, KickingByLength, Kst, KstOutput, Kurtosis, Kvo, KylesLambda,
-    LadderBottom, LaguerreRsi, LeadLagCrossCorrelation, LeadLagCrossCorrelationOutput, LinRegAngle,
-    LinRegChannel, LinRegChannelOutput, LinRegIntercept, LinRegSlope, LinearRegression,
-    LiquidationFeatures, LiquidationFeaturesOutput, LongLeggedDoji, LongLine, LongShortRatio,
-    MaEnvelope, MaEnvelopeOutput, MacdExt, MacdFix, MacdIndicator, MacdOutput, Mama, MamaOutput,
-    MarketFacilitationIndex, Marubozu, MassIndex, MatHold, MatchingLow, MaxDrawdown,
-    McGinleyDynamic, MedianAbsoluteDeviation, MedianPrice, Mfi, Microprice, MidPoint, MidPrice,
-    MinusDi, MinusDm, Mom, MorningDojiStar, MorningEveningStar, Natr, Nvi, OIPriceDivergence,
-    OIWeighted, Obv, OmegaRatio, OnNeck, OpenInterestDelta, OpeningMarubozu, OpeningRange,
-    OpeningRangeOutput, OrderBookImbalanceFull, OrderBookImbalanceTop1, OrderBookImbalanceTopN,
-    PainIndex, PairSpreadZScore, PairwiseBeta, ParkinsonVolatility, PearsonCorrelation, PercentB,
-    PercentageTrailingStop, Pgo, PiercingDarkCloud, PlusDi, PlusDm, Pmo, PointAndFigureBars, Ppo,
-    ProfitFactor, Psar, Pvi, QuotedSpread, RSquared, RealizedSpread, RecoveryFactor,
-    RelativeStrengthAB, RelativeStrengthOutput, RenkoBars, RenkoTrailingStop, RickshawMan,
-    RisingThreeMethods, Roc, Rocp, Rocr, Rocr100, RogersSatchellVolatility, RollingVwap,
-    RoofingFilter, Rsi, Rvi, RviVolatility, Rwi, RwiOutput, SarExt, SeparatingLines, SharpeRatio,
-    ShootingStar, ShortLine, SignedVolume, SineWave, Skewness, Sma, Smi, Smma, SortinoRatio,
-    SpearmanCorrelation, SpinningTop, StalledPattern, StandardError, StandardErrorBands,
-    StandardErrorBandsOutput, StarcBands, StarcBandsOutput, Stc, StdDev, StepTrailingStop,
-    StickSandwich, StochRsi, Stochastic, StochasticOutput, SuperSmoother, SuperTrend,
-    SuperTrendOutput, TakerBuySellRatio, Takuri, TasukiGap, TdCombo, TdCountdown, TdDeMarker,
-    TdDifferential, TdLines, TdLinesOutput, TdOpen, TdPressure, TdRangeProjection,
-    TdRangeProjectionOutput, TdRei, TdRiskLevel, TdRiskLevelOutput, TdSequential,
-    TdSequentialOutput, TdSetup, Tema, TermStructureBasis, ThreeInside, ThreeLineStrike,
-    ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting, Tii, TpoProfile,
-    TpoProfileOutput, TradeImbalance, TreynorRatio, Trima, Trix, TrueRange, Tsf, Tsi, Tsv,
-    TtmSqueeze, TtmSqueezeOutput, Tweezer, TwoCrows, TypicalPrice, UlcerIndex, UltimateOscillator,
-    UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea, ValueAreaOutput,
-    ValueAtRisk, Variance, VerticalHorizontalFilter, Vidya, VoltyStop, VolumeOscillator,
-    VolumePriceTrend, VolumeProfile, VolumeProfileOutput, Vortex, VortexOutput, Vwap,
-    VwapStdDevBands, VwapStdDevBandsOutput, Vwma, Vzo, WaveTrend, WaveTrendOutput, WeightedClose,
-    WilliamsFractals, WilliamsFractalsOutput, WilliamsR, Wma, WoodiePivots, WoodiePivotsOutput,
-    YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd, ZeroLagMacdOutput, ZigZag, ZigZagOutput,
-    Zlema, FAMILIES, T3,
+    AdaptiveCycle, Adl, AdvanceBlock, AdvanceDecline, Adx, AdxOutput, Adxr, Alligator,
+    AlligatorOutput, Alma, Alpha, AnchoredRsi, AnchoredVwap, Apo, Aroon, AroonOscillator,
+    AroonOutput, Atr, AtrBands, AtrBandsOutput, AtrTrailingStop, Autocorrelation, AverageDrawdown,
+    AvgPrice, AwesomeOscillator, AwesomeOscillatorHistogram, BalanceOfPower, BeltHold, Beta,
+    BollingerBands, BollingerBandwidth, BollingerOutput, Breakaway, CalendarSpread, CalmarRatio,
+    Camarilla, CamarillaPivotsOutput, Cci, CenterOfGravity, Cfo, ChaikinMoneyFlow,
+    ChaikinOscillator, ChaikinVolatility, ChandeKrollStop, ChandeKrollStopOutput, ChandelierExit,
+    ChandelierExitOutput, ChoppinessIndex, ClassicPivots, ClassicPivotsOutput, ClosingMarubozu,
+    Cmo, CoefficientOfVariation, Cointegration, CointegrationOutput, ConcealingBabySwallow,
+    ConditionalValueAtRisk, ConnorsRsi, Coppock, Counterattack, CumulativeVolumeDelta,
+    CyberneticCycle, Decycler, DecyclerOscillator, Dema, DemandIndex, DemarkPivots,
+    DemarkPivotsOutput, DepthSlope, DetrendedStdDev, Doji, DojiStar, Donchian, DonchianOutput,
+    DonchianStop, DonchianStopOutput, DoubleBollinger, DoubleBollingerOutput,
+    DownsideGapThreeMethods, Dpo, DragonflyDoji, DrawdownDuration, Dx, EaseOfMovement,
+    EffectiveSpread, EhlersStochastic, ElderImpulse, Ema, EmpiricalModeDecomposition, Engulfing,
+    EveningDojiStar, Evwma, FallingThreeMethods, Fama, FibonacciPivots, FibonacciPivotsOutput,
+    FisherTransform, Footprint, FootprintOutput, ForceIndex, FractalChaosBands,
+    FractalChaosBandsOutput, Frama, FundingBasis, FundingRate, FundingRateMean, FundingRateZScore,
+    GainLossRatio, GapSideBySideWhite, GarmanKlassVolatility, GravestoneDoji, Hammer, HangingMan,
+    Harami, HeikinAshi, HeikinAshiOutput, HiLoActivator, HighWave, Hikkake, HikkakeModified,
+    HilbertDominantCycle, HistoricalVolatility, Hma, HomingPigeon, HtDcPhase, HtPhasor,
+    HtPhasorOutput, HtTrendMode, HurstChannel, HurstChannelOutput, HurstExponent, Ichimoku,
+    IchimokuOutput, IdenticalThreeCrows, InNeck, Inertia, InformationRatio, InitialBalance,
+    InitialBalanceOutput, InstantaneousTrendline, InverseFisherTransform, InvertedHammer, Jma,
+    KagiBars, Kama, KellyCriterion, Keltner, KeltnerOutput, Kicking, KickingByLength, Kst,
+    KstOutput, Kurtosis, Kvo, KylesLambda, LadderBottom, LaguerreRsi, LeadLagCrossCorrelation,
+    LeadLagCrossCorrelationOutput, LinRegAngle, LinRegChannel, LinRegChannelOutput,
+    LinRegIntercept, LinRegSlope, LinearRegression, LiquidationFeatures, LiquidationFeaturesOutput,
+    LongLeggedDoji, LongLine, LongShortRatio, MaEnvelope, MaEnvelopeOutput, MacdExt, MacdFix,
+    MacdIndicator, MacdOutput, Mama, MamaOutput, MarketFacilitationIndex, Marubozu, MassIndex,
+    MatHold, MatchingLow, MaxDrawdown, McGinleyDynamic, MedianAbsoluteDeviation, MedianPrice, Mfi,
+    Microprice, MidPoint, MidPrice, MinusDi, MinusDm, Mom, MorningDojiStar, MorningEveningStar,
+    Natr, Nvi, OIPriceDivergence, OIWeighted, Obv, OmegaRatio, OnNeck, OpenInterestDelta,
+    OpeningMarubozu, OpeningRange, OpeningRangeOutput, OrderBookImbalanceFull,
+    OrderBookImbalanceTop1, OrderBookImbalanceTopN, PainIndex, PairSpreadZScore, PairwiseBeta,
+    ParkinsonVolatility, PearsonCorrelation, PercentB, PercentageTrailingStop, Pgo,
+    PiercingDarkCloud, PlusDi, PlusDm, Pmo, PointAndFigureBars, Ppo, ProfitFactor, Psar, Pvi,
+    QuotedSpread, RSquared, RealizedSpread, RecoveryFactor, RelativeStrengthAB,
+    RelativeStrengthOutput, RenkoBars, RenkoTrailingStop, RickshawMan, RisingThreeMethods, Roc,
+    Rocp, Rocr, Rocr100, RogersSatchellVolatility, RollingVwap, RoofingFilter, Rsi, Rvi,
+    RviVolatility, Rwi, RwiOutput, SarExt, SeparatingLines, SharpeRatio, ShootingStar, ShortLine,
+    SignedVolume, SineWave, Skewness, Sma, Smi, Smma, SortinoRatio, SpearmanCorrelation,
+    SpinningTop, StalledPattern, StandardError, StandardErrorBands, StandardErrorBandsOutput,
+    StarcBands, StarcBandsOutput, Stc, StdDev, StepTrailingStop, StickSandwich, StochRsi,
+    Stochastic, StochasticOutput, SuperSmoother, SuperTrend, SuperTrendOutput, TakerBuySellRatio,
+    Takuri, TasukiGap, TdCombo, TdCountdown, TdDeMarker, TdDifferential, TdLines, TdLinesOutput,
+    TdOpen, TdPressure, TdRangeProjection, TdRangeProjectionOutput, TdRei, TdRiskLevel,
+    TdRiskLevelOutput, TdSequential, TdSequentialOutput, TdSetup, Tema, TermStructureBasis,
+    ThreeInside, ThreeLineStrike, ThreeOutside, ThreeSoldiersOrCrows, ThreeStarsInSouth, Thrusting,
+    Tii, TpoProfile, TpoProfileOutput, TradeImbalance, TreynorRatio, Trima, Trix, TrueRange, Tsf,
+    Tsi, Tsv, TtmSqueeze, TtmSqueezeOutput, Tweezer, TwoCrows, TypicalPrice, UlcerIndex,
+    UltimateOscillator, UniqueThreeRiver, UpsideGapThreeMethods, UpsideGapTwoCrows, ValueArea,
+    ValueAreaOutput, ValueAtRisk, Variance, VerticalHorizontalFilter, Vidya, VoltyStop,
+    VolumeOscillator, VolumePriceTrend, VolumeProfile, VolumeProfileOutput, Vortex, VortexOutput,
+    Vwap, VwapStdDevBands, VwapStdDevBandsOutput, Vwma, Vzo, WaveTrend, WaveTrendOutput,
+    WeightedClose, WilliamsFractals, WilliamsFractalsOutput, WilliamsR, Wma, WoodiePivots,
+    WoodiePivotsOutput, YangZhangVolatility, YoyoExit, ZScore, ZeroLagMacd, ZeroLagMacdOutput,
+    ZigZag, ZigZagOutput, Zlema, FAMILIES, T3,
 };
 // `FootprintLevel` is a row element of `FootprintOutput`, re-exported on its own
 // line so the indicator-count tooling (which scans the braced block above and