docs: remove C# Implementation Considerations sections, clean up temp scripts, reorganize test files

- Remove 'C# Implementation Considerations' sections from 34 indicator .md files
- Delete 29 temp PowerShell scripts (_fix_mojibake.ps1, _hex_scan.ps1, etc.)
- Move test files into tests/ subdirectories for consistent project structure
- Add trader-focused bullet points to indicator documentation

lib/channels/maenv/tests/Maenv.Quantower.Tests.cs

@@ -0,0 +1,258 @@
+using TradingPlatform.BusinessLayer;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class MaenvIndicatorTests
+{
+    [Fact]
+    public void Constructor_SetsDefaults()
+    {
+        var ind = new MaenvIndicator();
+
+        Assert.Equal(20, ind.Period);
+        Assert.Equal(1.0, ind.Percentage);
+        Assert.Equal(MaenvType.EMA, ind.MaType);
+        Assert.Equal(PriceType.Close, ind.SourceType);
+        Assert.True(ind.ShowColdValues);
+        Assert.Equal("Maenv - Moving Average Envelope", ind.Name);
+        Assert.False(ind.SeparateWindow);
+        Assert.True(ind.OnBackGround);
+    }
+
+    [Fact]
+    public void MinHistoryDepths_EqualsPeriod()
+    {
+        var ind = new MaenvIndicator { Period = 15 };
+        Assert.Equal(15, ind.MinHistoryDepths);
+    }
+
+    [Fact]
+    public void ShortName_ReflectsParameters()
+    {
+        var ind = new MaenvIndicator { Period = 12, Percentage = 2.5, MaType = MaenvType.SMA };
+        Assert.Contains("12", ind.ShortName, StringComparison.Ordinal);
+        Assert.Contains("2.5", ind.ShortName, StringComparison.Ordinal);
+        Assert.Contains("SMA", ind.ShortName, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Initialize_AddsThreeLineSeries()
+    {
+        var ind = new MaenvIndicator { Period = 14, Percentage = 2.0 };
+        ind.Initialize();
+
+        Assert.Equal(3, ind.LinesSeries.Count);
+        Assert.Equal("Middle", ind.LinesSeries[0].Name);
+        Assert.Equal("Upper", ind.LinesSeries[1].Name);
+        Assert.Equal("Lower", ind.LinesSeries[2].Name);
+    }
+
+    [Fact]
+    public void ProcessUpdate_Historical_ComputesValues()
+    {
+        var ind = new MaenvIndicator { Period = 3, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        Assert.Equal(1, ind.LinesSeries[0].Count);
+        Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(0)));
+        Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(0)));
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewBar_Appends()
+    {
+        var ind = new MaenvIndicator { Period = 3, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 102);
+        ind.HistoricalData.AddBar(now.AddMinutes(1), 102, 112, 92, 104);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void ProcessUpdate_NewTick_DoesNotThrow()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 105, 95, 102);
+
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.NewTick));
+
+        Assert.Equal(2, ind.LinesSeries[0].Count);
+    }
+
+    [Fact]
+    public void MultipleUpdates_ProducesFiniteSeries()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 102 + i);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        Assert.Equal(20, ind.LinesSeries[0].Count);
+        Assert.Equal(20, ind.LinesSeries[1].Count);
+        Assert.Equal(20, ind.LinesSeries[2].Count);
+
+        for (int i = 0; i < 20; i++)
+        {
+            Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(i)));
+            Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(i)));
+        }
+    }
+
+    [Fact]
+    public void Bands_Order_Correct()
+    {
+        var ind = new MaenvIndicator { Period = 5, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100, 1000);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        Assert.True(upper > middle, $"Upper ({upper}) should be > Middle ({middle})");
+        Assert.True(lower < middle, $"Lower ({lower}) should be < Middle ({middle})");
+    }
+
+    [Fact]
+    public void FirstBar_BandsAtPercentage()
+    {
+        var ind = new MaenvIndicator { Period = 10, Percentage = 2.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        ind.HistoricalData.AddBar(now, 100, 110, 90, 100);
+        ind.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        // First bar: middle = close, bands at ±2%
+        Assert.Equal(100.0, middle, 1e-10);
+        Assert.Equal(102.0, upper, 1e-10);
+        Assert.Equal(98.0, lower, 1e-10);
+    }
+
+    [Fact]
+    public void Percentage_AffectsBandWidth()
+    {
+        var ind1 = new MaenvIndicator { Period = 10, Percentage = 1.0 };
+        var ind2 = new MaenvIndicator { Period = 10, Percentage = 2.0 };
+        ind1.Initialize();
+        ind2.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind1.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100);
+            ind2.HistoricalData.AddBar(now.AddMinutes(i), 100, 110, 90, 100);
+            ind1.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            ind2.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double width1 = ind1.LinesSeries[1].GetValue(0) - ind1.LinesSeries[2].GetValue(0);
+        double width2 = ind2.LinesSeries[1].GetValue(0) - ind2.LinesSeries[2].GetValue(0);
+
+        Assert.Equal(width2, width1 * 2, 1e-9);
+    }
+
+    [Fact]
+    public void Bands_Symmetric_AroundMiddle()
+    {
+        var ind = new MaenvIndicator { Period = 10, Percentage = 3.0 };
+        ind.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 20; i++)
+        {
+            ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 100 + i);
+            ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        double middle = ind.LinesSeries[0].GetValue(0);
+        double upper = ind.LinesSeries[1].GetValue(0);
+        double lower = ind.LinesSeries[2].GetValue(0);
+
+        double upperDist = upper - middle;
+        double lowerDist = middle - lower;
+
+        Assert.Equal(upperDist, lowerDist, 1e-10);
+    }
+
+    [Fact]
+    public void AllmaTypes_ProduceFiniteResults()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new MaenvIndicator { Period = 10, Percentage = 2.0, MaType = maType };
+            ind.Initialize();
+
+            var now = DateTime.UtcNow;
+            for (int i = 0; i < 20; i++)
+            {
+                ind.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 105 + i, 95 + i, 100 + i);
+                ind.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            }
+
+            for (int i = 0; i < 20; i++)
+            {
+                Assert.True(double.IsFinite(ind.LinesSeries[0].GetValue(i)), $"{maType} Middle finite at {i}");
+                Assert.True(double.IsFinite(ind.LinesSeries[1].GetValue(i)), $"{maType} Upper finite at {i}");
+                Assert.True(double.IsFinite(ind.LinesSeries[2].GetValue(i)), $"{maType} Lower finite at {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void DifferentPriceTypes_Work()
+    {
+        var indClose = new MaenvIndicator { Period = 5, Percentage = 1.0, SourceType = PriceType.Close };
+        var indHigh = new MaenvIndicator { Period = 5, Percentage = 1.0, SourceType = PriceType.High };
+        indClose.Initialize();
+        indHigh.Initialize();
+
+        var now = DateTime.UtcNow;
+        for (int i = 0; i < 10; i++)
+        {
+            indClose.HistoricalData.AddBar(now.AddMinutes(i), 100, 120, 80, 100);
+            indHigh.HistoricalData.AddBar(now.AddMinutes(i), 100, 120, 80, 100);
+            indClose.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+            indHigh.ProcessUpdate(new UpdateArgs(i == 0 ? UpdateReason.HistoricalBar : UpdateReason.NewBar));
+        }
+
+        // High should be higher than Close for the same percentage
+        double closeMiddle = indClose.LinesSeries[0].GetValue(0);
+        double highMiddle = indHigh.LinesSeries[0].GetValue(0);
+
+        Assert.True(highMiddle > closeMiddle, "High price type should produce higher middle than Close");
+    }
+}

lib/channels/maenv/tests/Maenv.Tests.cs

@@ -0,0 +1,388 @@
+using System;
+using QuanTAlib;
+using Xunit;
+
+namespace QuanTAlib.Tests;
+
+public class MaenvTests
+{
+    [Fact]
+    public void Maenv_Constructor_ValidatesInput()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(-5));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(10, 0.0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => new Maenv(10, -1.0));
+
+        var m = new Maenv(10, 2.0);
+        Assert.Equal(10, m.WarmupPeriod);
+        Assert.Contains("Maenv", m.Name, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public void Maenv_InitialState_Defaults()
+    {
+        var m = new Maenv(5);
+
+        Assert.Equal(0, m.Last.Value);
+        Assert.Equal(0, m.Upper.Value);
+        Assert.Equal(0, m.Lower.Value);
+        Assert.False(m.IsHot);
+    }
+
+    [Fact]
+    public void Maenv_FirstValue_AllBandsCorrect()
+    {
+        var m = new Maenv(10, 1.0, MaenvType.EMA);
+
+        var result = m.Update(new TValue(DateTime.UtcNow, 100));
+
+        // First value: MA = input, bands at ±1%
+        Assert.Equal(100.0, result.Value, 1e-10);
+        Assert.Equal(101.0, m.Upper.Value, 1e-10);
+        Assert.Equal(99.0, m.Lower.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Maenv_BandWidth_ProportionalToPercentage()
+    {
+        var m1 = new Maenv(10, 1.0);
+        var m2 = new Maenv(10, 2.0);
+        var m3 = new Maenv(10, 5.0);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tv = new TValue(bar.Time, bar.Close);
+            m1.Update(tv);
+            m2.Update(tv);
+            m3.Update(tv);
+        }
+
+        double width1 = m1.Upper.Value - m1.Lower.Value;
+        double width2 = m2.Upper.Value - m2.Lower.Value;
+        double width3 = m3.Upper.Value - m3.Lower.Value;
+
+        // Width should scale with percentage (width = 2 * middle * pct / 100)
+        Assert.Equal(width2, width1 * 2, 1e-9);
+        Assert.Equal(width3, width1 * 5, 1e-9);
+    }
+
+    [Fact]
+    public void Maenv_BandOrder_Correct()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(10, 2.0, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+            for (int i = 0; i < 50; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                m.Update(new TValue(bar.Time, bar.Close));
+
+                // Upper > Middle > Lower (for positive prices)
+                Assert.True(m.Upper.Value > m.Last.Value, $"{maType}: Upper > Middle at bar {i}");
+                Assert.True(m.Lower.Value < m.Last.Value, $"{maType}: Lower < Middle at bar {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Maenv_BandSymmetry_PercentageBased()
+    {
+        var m = new Maenv(10, 3.0, MaenvType.EMA);
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            m.Update(new TValue(bar.Time, bar.Close));
+
+            // Bands should be symmetric around middle
+            double upperDist = m.Upper.Value - m.Last.Value;
+            double lowerDist = m.Last.Value - m.Lower.Value;
+            Assert.Equal(upperDist, lowerDist, 1e-10);
+
+            // Distance should be exactly percentage of middle
+            double expectedDist = m.Last.Value * 3.0 / 100.0;
+            Assert.Equal(expectedDist, upperDist, 1e-10);
+        }
+    }
+
+    [Fact]
+    public void Maenv_SMA_CorrectCalculation()
+    {
+        var m = new Maenv(3, 1.0, MaenvType.SMA);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.Equal(100.0, m.Last.Value, 1e-10); // SMA(100) = 100
+
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        Assert.Equal(105.0, m.Last.Value, 1e-10); // SMA(100,110) = 105
+
+        m.Update(new TValue(DateTime.UtcNow, 120));
+        Assert.Equal(110.0, m.Last.Value, 1e-10); // SMA(100,110,120) = 110
+
+        m.Update(new TValue(DateTime.UtcNow, 130));
+        Assert.Equal(120.0, m.Last.Value, 1e-10); // SMA(110,120,130) = 120
+    }
+
+    [Fact]
+    public void Maenv_EMA_WarmupCompensation()
+    {
+        var m = new Maenv(20, 1.0, MaenvType.EMA);
+
+        // Feed constant values
+        for (int i = 0; i < 100; i++)
+        {
+            m.Update(new TValue(DateTime.UtcNow, 100));
+        }
+
+        // EMA should converge to 100 due to warmup compensation
+        Assert.InRange(m.Last.Value, 99.9, 100.1);
+    }
+
+    [Fact]
+    public void Maenv_WMA_WeightedCorrectly()
+    {
+        var m = new Maenv(3, 1.0, MaenvType.WMA);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        Assert.Equal(100.0, m.Last.Value, 1e-10);
+
+        // Second value: weights (3,2) for values (110,100)
+        // norm = 3*3 + 2*3 = 15, but for partial fill: w=(3-0)*3=9 for newest, w=(3-1)*3=6 for older
+        // Actual: first bar w=9, second bar: newest w=9, oldest w=6; sum=110*9+100*6=990+600=1590; norm=15
+        // WMA = 1590/15 = 106
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        double expected2 = (110 * 9 + 100 * 6) / 15.0;
+        Assert.Equal(expected2, m.Last.Value, 1e-10);
+    }
+
+    [Fact]
+    public void Maenv_IsHot_TurnsTrueAfterWarmup()
+    {
+        var m = new Maenv(5, 1.0);
+
+        for (int i = 0; i < 4; i++)
+        {
+            m.Update(new TValue(DateTime.UtcNow, 100 + i));
+            Assert.False(m.IsHot);
+        }
+
+        m.Update(new TValue(DateTime.UtcNow, 200));
+        Assert.True(m.IsHot);
+    }
+
+    [Fact]
+    public void Maenv_IsNewFalse_RebuildsState()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(10, 2.0, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 7);
+
+            TValue remembered = default;
+            for (int i = 0; i < 30; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                remembered = new TValue(bar.Time, bar.Close);
+                m.Update(remembered, isNew: true);
+            }
+
+            double mid = m.Last.Value;
+            double up = m.Upper.Value;
+            double lo = m.Lower.Value;
+
+            // Apply corrections
+            for (int i = 0; i < 5; i++)
+            {
+                var bar = gbm.Next(isNew: false);
+                m.Update(new TValue(bar.Time, bar.Close), isNew: false);
+            }
+
+            // Restore with remembered value
+            m.Update(remembered, isNew: false);
+
+            Assert.Equal(mid, m.Last.Value, 1e-6);
+            Assert.Equal(up, m.Upper.Value, 1e-6);
+            Assert.Equal(lo, m.Lower.Value, 1e-6);
+        }
+    }
+
+    [Fact]
+    public void Maenv_NaN_UsesLastValid()
+    {
+        var m = new Maenv(10, 2.0);
+
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        m.Update(new TValue(DateTime.UtcNow, 105));
+
+        var result = m.Update(new TValue(DateTime.UtcNow, double.NaN));
+        Assert.True(double.IsFinite(result.Value));
+        Assert.True(double.IsFinite(m.Upper.Value));
+        Assert.True(double.IsFinite(m.Lower.Value));
+
+        var result2 = m.Update(new TValue(DateTime.UtcNow, double.PositiveInfinity));
+        Assert.True(double.IsFinite(result2.Value));
+    }
+
+    [Fact]
+    public void Maenv_Reset_Clears()
+    {
+        var m = new Maenv(10, 2.0);
+        m.Update(new TValue(DateTime.UtcNow, 100));
+        m.Update(new TValue(DateTime.UtcNow, 110));
+        m.Update(new TValue(DateTime.UtcNow, 120));
+
+        m.Reset();
+
+        Assert.Equal(0, m.Last.Value);
+        Assert.Equal(0, m.Upper.Value);
+        Assert.Equal(0, m.Lower.Value);
+        Assert.False(m.IsHot);
+
+        m.Update(new TValue(DateTime.UtcNow, 50));
+        Assert.NotEqual(0, m.Last.Value);
+    }
+
+    [Fact]
+    public void Maenv_BatchVsStreaming_Match()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var mStream = new Maenv(20, 1.5, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.15, seed: 42);
+            var series = new TSeries();
+
+            for (int i = 0; i < 200; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                series.Add(new TValue(bar.Time, bar.Close));
+                mStream.Update(series.Last, isNew: true);
+            }
+
+            double expectedMid = mStream.Last.Value;
+            double expectedUp = mStream.Upper.Value;
+            double expectedLo = mStream.Lower.Value;
+
+            var (midBatch, upBatch, loBatch) = Maenv.Batch(series, 20, 1.5, maType);
+
+            Assert.Equal(expectedMid, midBatch.Last.Value, 1e-9);
+            Assert.Equal(expectedUp, upBatch.Last.Value, 1e-9);
+            Assert.Equal(expectedLo, loBatch.Last.Value, 1e-9);
+        }
+    }
+
+    [Fact]
+    public void Maenv_SpanBatch_Validates()
+    {
+        double[] source = [100, 105, 110];
+        double[] middle = new double[3];
+        double[] upper = new double[3];
+        double[] lower = new double[3];
+        double[] smallOut = new double[1];
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 10, 0.0));
+        Assert.Throws<ArgumentException>(() => Maenv.Batch(source.AsSpan(), smallOut.AsSpan(), upper.AsSpan(), lower.AsSpan(), 2));
+    }
+
+    [Fact]
+    public void Maenv_SpanBatch_ComputesCorrectly()
+    {
+        double[] source = [100, 105, 110, 107, 115];
+        double[] middle = new double[5];
+        double[] upper = new double[5];
+        double[] lower = new double[5];
+
+        Maenv.Batch(source.AsSpan(), middle.AsSpan(), upper.AsSpan(), lower.AsSpan(), 3, 2.0, MaenvType.EMA);
+
+        // First value: MA = 100, bands at ±2%
+        Assert.Equal(100.0, middle[0], 1e-10);
+        Assert.Equal(102.0, upper[0], 1e-10);
+        Assert.Equal(98.0, lower[0], 1e-10);
+
+        // All bars: upper > middle > lower
+        for (int i = 0; i < 5; i++)
+        {
+            Assert.True(upper[i] > middle[i], $"Upper > Middle at {i}");
+            Assert.True(lower[i] < middle[i], $"Lower < Middle at {i}");
+        }
+    }
+
+    [Fact]
+    public void Maenv_Calculate_ReturnsIndicatorAndResults()
+    {
+        var series = new TSeries();
+        series.Add(new TValue(DateTime.UtcNow, 100));
+        series.Add(new TValue(DateTime.UtcNow, 105));
+        series.Add(new TValue(DateTime.UtcNow, 102));
+
+        var ((mid, up, lo), ind) = Maenv.Calculate(series, 2);
+
+        Assert.True(double.IsFinite(mid.Last.Value));
+        Assert.True(double.IsFinite(up.Last.Value));
+        Assert.True(double.IsFinite(lo.Last.Value));
+
+        // Continue streaming
+        ind.Update(new TValue(DateTime.UtcNow, 108));
+        Assert.True(double.IsFinite(ind.Last.Value));
+    }
+
+    [Fact]
+    public void Maenv_Event_Publishes()
+    {
+        var src = new TSeries();
+        var m = new Maenv(src, 2);
+        bool fired = false;
+        m.Pub += (object? sender, in TValueEventArgs args) => fired = true;
+
+        src.Add(new TValue(DateTime.UtcNow, 100));
+        Assert.True(fired);
+    }
+
+    [Fact]
+    public void Maenv_AllmaTypes_ProduceFiniteResults()
+    {
+        var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var m = new Maenv(20, 2.5, maType);
+
+            for (int i = 0; i < 200; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                m.Update(new TValue(bar.Time, bar.Close));
+
+                Assert.True(double.IsFinite(m.Last.Value), $"{maType} Middle finite at {i}");
+                Assert.True(double.IsFinite(m.Upper.Value), $"{maType} Upper finite at {i}");
+                Assert.True(double.IsFinite(m.Lower.Value), $"{maType} Lower finite at {i}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Maenv_LongSeriesStability()
+    {
+        var m = new Maenv(20, 2.0);
+        var gbm = new GBM(startPrice: 100, mu: 0.001, sigma: 0.02, seed: 123);
+
+        for (int i = 0; i < 10000; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            m.Update(new TValue(bar.Time, bar.Close));
+
+            Assert.True(double.IsFinite(m.Last.Value), $"Middle finite at {i}");
+            Assert.True(double.IsFinite(m.Upper.Value), $"Upper finite at {i}");
+            Assert.True(double.IsFinite(m.Lower.Value), $"Lower finite at {i}");
+            Assert.True(m.Upper.Value > m.Last.Value, $"Upper > Middle at {i}");
+            Assert.True(m.Lower.Value < m.Last.Value, $"Lower < Middle at {i}");
+        }
+    }
+}

lib/channels/maenv/tests/Maenv.Validation.Tests.cs

@@ -0,0 +1,598 @@
+using Skender.Stock.Indicators;
+using Xunit.Abstractions;
+
+using OoplesFinance.StockIndicators;
+using OoplesFinance.StockIndicators.Models;
+
+namespace QuanTAlib.Tests;
+
+public sealed class MaenvValidationTests : IDisposable
+{
+    private readonly ValidationTestData _testData;
+    private readonly ITestOutputHelper _output;
+    private bool _disposed;
+
+    public MaenvValidationTests(ITestOutputHelper output)
+    {
+        _output = output;
+        _testData = new ValidationTestData();
+    }
+
+    public void Dispose() => Dispose(true);
+
+    private void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+
+        if (disposing)
+        {
+            _testData?.Dispose();
+        }
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_SMA()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // Simple values for manual verification
+        series.Add(new TValue(t0, 100));
+        series.Add(new TValue(t0.AddMinutes(1), 110));
+        series.Add(new TValue(t0.AddMinutes(2), 120));
+        series.Add(new TValue(t0.AddMinutes(3), 130));
+
+        var ind = new Maenv(3, 2.0, MaenvType.SMA);
+
+        // Bar 0: SMA(100) = 100, bands ±2%
+        ind.Update(series[0]);
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+        Assert.Equal(102.0, ind.Upper.Value, 1e-10);
+        Assert.Equal(98.0, ind.Lower.Value, 1e-10);
+
+        // Bar 1: SMA(100,110) = 105, bands ±2%
+        ind.Update(series[1]);
+        Assert.Equal(105.0, ind.Last.Value, 1e-10);
+        Assert.Equal(107.1, ind.Upper.Value, 1e-10);
+        Assert.Equal(102.9, ind.Lower.Value, 1e-10);
+
+        // Bar 2: SMA(100,110,120) = 110, bands ±2%
+        ind.Update(series[2]);
+        Assert.Equal(110.0, ind.Last.Value, 1e-10);
+        Assert.Equal(112.2, ind.Upper.Value, 1e-10);
+        Assert.Equal(107.8, ind.Lower.Value, 1e-10);
+
+        // Bar 3: SMA(110,120,130) = 120, bands ±2%
+        ind.Update(series[3]);
+        Assert.Equal(120.0, ind.Last.Value, 1e-10);
+        Assert.Equal(122.4, ind.Upper.Value, 1e-10);
+        Assert.Equal(117.6, ind.Lower.Value, 1e-10);
+
+        _output.WriteLine("Maenv SMA manual calculation validated");
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_EMA_Convergence()
+    {
+        // Constant values should converge to that value due to warmup compensation
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        for (int i = 0; i < 100; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100.0));
+        }
+
+        var ind = new Maenv(20, 1.0, MaenvType.EMA);
+
+        foreach (var tv in series)
+        {
+            ind.Update(tv);
+        }
+
+        // EMA should converge to 100 due to warmup compensation
+        Assert.InRange(ind.Last.Value, 99.99, 100.01);
+        Assert.InRange(ind.Upper.Value, 100.99, 101.01);
+        Assert.InRange(ind.Lower.Value, 98.99, 99.01);
+
+        _output.WriteLine("Maenv EMA convergence validated");
+    }
+
+    [Fact]
+    public void Validate_ManualCalculation_WMA()
+    {
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        // WMA(3) weights: newest=9, middle=6, oldest=3 (total=18)
+        series.Add(new TValue(t0, 100)); // First bar: WMA = 100
+        series.Add(new TValue(t0.AddMinutes(1), 110)); // WMA = (110*9 + 100*6) / 15 = 1590/15 = 106
+        series.Add(new TValue(t0.AddMinutes(2), 120)); // WMA = (120*9 + 110*6 + 100*3) / 18 = 1980/18 = 110
+
+        var ind = new Maenv(3, 1.0, MaenvType.WMA);
+
+        ind.Update(series[0]);
+        Assert.Equal(100.0, ind.Last.Value, 1e-10);
+
+        ind.Update(series[1]);
+        double expected2 = (110.0 * 9 + 100.0 * 6) / 15.0;
+        Assert.Equal(expected2, ind.Last.Value, 1e-10);
+
+        ind.Update(series[2]);
+        double expected3 = (120.0 * 9 + 110.0 * 6 + 100.0 * 3) / 18.0;
+        Assert.Equal(expected3, ind.Last.Value, 1e-10);
+
+        _output.WriteLine("Maenv WMA manual calculation validated");
+    }
+
+    [Fact]
+    public void Validate_AllModes_Consistency()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] percentages = { 0.5, 1.0, 2.0, 5.0 };
+
+        foreach (int period in periods)
+        {
+            foreach (double percentage in percentages)
+            {
+                foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+                {
+                    // Batch (instance)
+                    var inst = new Maenv(period, percentage, maType);
+                    var (bMid, bUp, bLo) = inst.Update(_testData.Data);
+
+                    // Static batch
+                    var (sMid, sUp, sLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+                    ValidationHelper.VerifySeriesEqual(bMid, sMid);
+                    ValidationHelper.VerifySeriesEqual(bUp, sUp);
+                    ValidationHelper.VerifySeriesEqual(bLo, sLo);
+
+                    // Streaming
+                    var streaming = new Maenv(period, percentage, maType);
+                    var sMidStream = new TSeries();
+                    var sUpStream = new TSeries();
+                    var sLoStream = new TSeries();
+                    foreach (var tv in _testData.Data)
+                    {
+                        streaming.Update(tv);
+                        sMidStream.Add(streaming.Last);
+                        sUpStream.Add(streaming.Upper);
+                        sLoStream.Add(streaming.Lower);
+                    }
+
+                    ValidationHelper.VerifySeriesEqual(sMid, sMidStream);
+                    ValidationHelper.VerifySeriesEqual(sUp, sUpStream);
+                    ValidationHelper.VerifySeriesEqual(sLo, sLoStream);
+
+                    // Span
+                    double[] source = _testData.ClosePrices.ToArray();
+                    double[] spanMid = new double[source.Length];
+                    double[] spanUp = new double[source.Length];
+                    double[] spanLo = new double[source.Length];
+                    Maenv.Batch(source.AsSpan(), spanMid.AsSpan(), spanUp.AsSpan(), spanLo.AsSpan(), period, percentage, maType);
+
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        Assert.Equal(sMid[i].Value, spanMid[i], 9);
+                        Assert.Equal(sUp[i].Value, spanUp[i], 9);
+                        Assert.Equal(sLo[i].Value, spanLo[i], 9);
+                    }
+                }
+            }
+        }
+
+        _output.WriteLine("Maenv mode consistency validated (batch/stream/span) for all MA types");
+    }
+
+    [Fact]
+    public void Validate_EventingMode_MatchesBatch()
+    {
+        const int period = 20;
+        const double percentage = 2.0;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var pub = new TSeries();
+            var evtInd = new Maenv(pub, period, percentage, maType);
+            var evtMid = new TSeries();
+            var evtUp = new TSeries();
+            var evtLo = new TSeries();
+
+            foreach (var tv in _testData.Data)
+            {
+                pub.Add(tv);
+                evtMid.Add(evtInd.Last);
+                evtUp.Add(evtInd.Upper);
+                evtLo.Add(evtInd.Lower);
+            }
+
+            var (bMid, bUp, bLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+            ValidationHelper.VerifySeriesEqual(bMid, evtMid);
+            ValidationHelper.VerifySeriesEqual(bUp, evtUp);
+            ValidationHelper.VerifySeriesEqual(bLo, evtLo);
+        }
+
+        _output.WriteLine("Maenv eventing mode validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_Calculate_ReturnsHotIndicator()
+    {
+        const int period = 15;
+        const double percentage = 2.5;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ((mid, up, lo), ind) = Maenv.Calculate(_testData.Data, period, percentage, maType);
+
+            Assert.True(ind.IsHot);
+            Assert.Equal(period, ind.WarmupPeriod);
+            Assert.Equal(mid.Last.Value, ind.Last.Value, 1e-10);
+            Assert.Equal(up.Last.Value, ind.Upper.Value, 1e-10);
+            Assert.Equal(lo.Last.Value, ind.Lower.Value, 1e-10);
+
+            // Continue streaming
+            var next = new TValue(DateTime.UtcNow, 100);
+            ind.Update(next);
+            Assert.True(ind.IsHot);
+        }
+
+        _output.WriteLine("Maenv Calculate validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_Prime_MatchesBatch()
+    {
+        const int period = 25;
+        const double percentage = 1.5;
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var (bMid, bUp, bLo) = Maenv.Batch(_testData.Data, period, percentage, maType);
+
+            var primed = new Maenv(period, percentage, maType);
+            var subset = new TSeries();
+            for (int i = 0; i < 200; i++)
+            {
+                subset.Add(_testData.Data[i]);
+            }
+
+            primed.Prime(subset);
+
+            for (int i = 200; i < _testData.Data.Count; i++)
+            {
+                primed.Update(_testData.Data[i]);
+            }
+
+            Assert.Equal(bMid.Last.Value, primed.Last.Value, 1e-9);
+            Assert.Equal(bUp.Last.Value, primed.Upper.Value, 1e-9);
+            Assert.Equal(bLo.Last.Value, primed.Lower.Value, 1e-9);
+        }
+
+        _output.WriteLine("Maenv Prime validated against batch for all MA types");
+    }
+
+    [Fact]
+    public void Validate_LargeDataset_FiniteOutputs()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var (mid, up, lo) = Maenv.Batch(_testData.Data, 50, 2.0, maType);
+
+            ValidationHelper.VerifyAllFinite(mid, startIndex: 0);
+            ValidationHelper.VerifyAllFinite(up, startIndex: 0);
+            ValidationHelper.VerifyAllFinite(lo, startIndex: 0);
+
+            // Upper > Lower for all bars (positive prices)
+            for (int i = 0; i < mid.Count; i++)
+            {
+                Assert.True(up[i].Value > lo[i].Value, $"Upper > Lower at {i} for {maType}");
+            }
+        }
+
+        _output.WriteLine("Maenv large dataset validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_BandSymmetry_AllBars()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(20, 2.0, maType);
+            var (mid, up, lo) = ind.Update(_testData.Data);
+
+            for (int i = 0; i < mid.Count; i++)
+            {
+                double upperWidth = up[i].Value - mid[i].Value;
+                double lowerWidth = mid[i].Value - lo[i].Value;
+                Assert.Equal(upperWidth, lowerWidth, 1e-10);
+            }
+        }
+
+        _output.WriteLine("Maenv band symmetry validated for all bars and MA types");
+    }
+
+    [Fact]
+    public void Validate_PercentageScaling()
+    {
+        double[] percentages = { 1.0, 2.0, 3.0, 4.0 };
+        double[] widths = new double[percentages.Length];
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            for (int i = 0; i < percentages.Length; i++)
+            {
+                var ind = new Maenv(20, percentages[i], maType);
+                foreach (var tv in _testData.Data)
+                {
+                    ind.Update(tv);
+                }
+                widths[i] = ind.Upper.Value - ind.Lower.Value;
+            }
+
+            // Widths should scale linearly with percentage
+            double baseWidth = widths[0];
+            for (int i = 1; i < percentages.Length; i++)
+            {
+                double expected = baseWidth * percentages[i];
+                Assert.Equal(expected, widths[i], 1e-9);
+            }
+        }
+
+        _output.WriteLine("Maenv percentage scaling validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_PeriodEffect_Smoothing()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double[] middles = new double[periods.Length];
+
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            for (int i = 0; i < periods.Length; i++)
+            {
+                var ind = new Maenv(periods[i], 2.0, maType);
+                foreach (var tv in _testData.Data)
+                {
+                    ind.Update(tv);
+                }
+                middles[i] = ind.Last.Value;
+            }
+
+            // All should produce finite values
+            foreach (var m in middles)
+            {
+                Assert.True(double.IsFinite(m));
+            }
+        }
+
+        _output.WriteLine("Maenv period effect validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_StateRestoration_Iterative()
+    {
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(15, 2.5, maType);
+            var gbm = new GBM(startPrice: 100, mu: 0.01, sigma: 0.1, seed: 42);
+
+            // Build up state
+            for (int i = 0; i < 50; i++)
+            {
+                var bar = gbm.Next(isNew: true);
+                ind.Update(new TValue(bar.Time, bar.Close), isNew: true);
+            }
+
+            // Multiple corrections
+            var rememberedBar = gbm.Next(isNew: true);
+            var remembered = new TValue(rememberedBar.Time, rememberedBar.Close);
+            ind.Update(remembered, isNew: true);
+
+            double midBefore = ind.Last.Value;
+            double upBefore = ind.Upper.Value;
+            double loBefore = ind.Lower.Value;
+
+            for (int i = 0; i < 10; i++)
+            {
+                var corrected = gbm.Next(isNew: false);
+                ind.Update(new TValue(corrected.Time, corrected.Close), isNew: false);
+            }
+
+            // Restore with remembered value
+            ind.Update(remembered, isNew: false);
+
+            Assert.Equal(midBefore, ind.Last.Value, 1e-6);
+            Assert.Equal(upBefore, ind.Upper.Value, 1e-6);
+            Assert.Equal(loBefore, ind.Lower.Value, 1e-6);
+        }
+
+        _output.WriteLine("Maenv state restoration validated for all MA types");
+    }
+
+    [Fact]
+    public void Validate_BandWidthFormula()
+    {
+        // Band width = 2 * middle * percentage / 100
+        foreach (MaenvType maType in Enum.GetValues<MaenvType>())
+        {
+            var ind = new Maenv(20, 3.0, maType);
+
+            foreach (var tv in _testData.Data)
+            {
+                ind.Update(tv);
+
+                double expectedWidth = 2 * ind.Last.Value * 3.0 / 100.0;
+                double actualWidth = ind.Upper.Value - ind.Lower.Value;
+                Assert.Equal(expectedWidth, actualWidth, 1e-10);
+            }
+        }
+
+        _output.WriteLine("Maenv band width formula validated");
+    }
+
+    [Fact]
+    public void Validate_maTypesDifferent()
+    {
+        // Different MA types should produce different results (except for first bar)
+        var indSma = new Maenv(10, 2.0, MaenvType.SMA);
+        var indEma = new Maenv(10, 2.0, MaenvType.EMA);
+        var indWma = new Maenv(10, 2.0, MaenvType.WMA);
+
+        var gbm = new GBM(startPrice: 100, mu: 0.02, sigma: 0.15, seed: 42);
+
+        for (int i = 0; i < 50; i++)
+        {
+            var bar = gbm.Next(isNew: true);
+            var tv = new TValue(bar.Time, bar.Close);
+            indSma.Update(tv);
+            indEma.Update(tv);
+            indWma.Update(tv);
+        }
+
+        // Values should be different (with high probability)
+        bool allSame = Math.Abs(indSma.Last.Value - indEma.Last.Value) < 1e-10 &&
+                       Math.Abs(indEma.Last.Value - indWma.Last.Value) < 1e-10;
+        Assert.False(allSame, "Different MA types should produce different values");
+
+        _output.WriteLine("Maenv MA types produce different results validated");
+    }
+
+    [Fact]
+    public void Validate_WarmupCompensation_EMA()
+    {
+        // EMA should converge quickly due to warmup compensation
+        var series = new TSeries();
+        var t0 = DateTime.UtcNow;
+
+        for (int i = 0; i < 100; i++)
+        {
+            series.Add(new TValue(t0.AddMinutes(i), 100.0));
+        }
+
+        var ind = new Maenv(20, 1.0, MaenvType.EMA);
+        var (mid, _, _) = ind.Update(series);
+
+        // After warmup, middle should be very close to constant price
+        for (int i = 40; i < 100; i++)
+        {
+            Assert.InRange(mid[i].Value, 99.9, 100.1);
+        }
+
+        _output.WriteLine("Maenv EMA warmup compensation validated");
+    }
+
+    [Fact]
+    public void Validate_SMA_RingBuffer_O1()
+    {
+        // SMA should maintain O(1) computation via ring buffer
+        // Test that it produces correct rolling average
+        var ind = new Maenv(5, 1.0, MaenvType.SMA);
+        var values = new double[] { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
+
+        for (int i = 0; i < values.Length; i++)
+        {
+            ind.Update(new TValue(DateTime.UtcNow, values[i]));
+
+            // Calculate expected SMA
+            int start = Math.Max(0, i - 4);
+            double sum = 0;
+            for (int j = start; j <= i; j++)
+            {
+                sum += values[j];
+            }
+            double expected = sum / (i - start + 1);
+
+            Assert.Equal(expected, ind.Last.Value, 1e-10);
+        }
+
+        _output.WriteLine("Maenv SMA ring buffer O(1) validated");
+    }
+
+    [Fact]
+    public void Validate_Skender_SMA_Centerline()
+    {
+        // Skender GetMaEnvelopes(lookbackPeriods, percentOffset, MaType.SMA)
+        // QuanTAlib Maenv(period, percentage, MaenvType.SMA)
+        // Both compute: Middle = SMA(Close), Upper = Middle + Middle*pct/100, Lower = Middle - Middle*pct/100
+        // For SMA type, results should match exactly.
+
+        int[] periods = { 5, 10, 20, 50 };
+        double percentage = 2.5;
+
+        foreach (var period in periods)
+        {
+            var (qMiddle, _, _) = Maenv.Batch(_testData.Data, period, percentage, MaenvType.SMA);
+
+            var sResult = _testData.SkenderQuotes
+                .GetMaEnvelopes(period, percentage, MaType.SMA)
+                .ToList();
+
+            ValidationHelper.VerifyData(qMiddle, sResult, s => s.Centerline);
+        }
+        _output.WriteLine("Maenv SMA centerline validated against Skender for all periods");
+    }
+
+    [Fact]
+    public void Validate_Skender_SMA_UpperEnvelope()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double percentage = 2.5;
+
+        foreach (var period in periods)
+        {
+            var (_, qUpper, _) = Maenv.Batch(_testData.Data, period, percentage, MaenvType.SMA);
+
+            var sResult = _testData.SkenderQuotes
+                .GetMaEnvelopes(period, percentage, MaType.SMA)
+                .ToList();
+
+            ValidationHelper.VerifyData(qUpper, sResult, s => s.UpperEnvelope);
+        }
+        _output.WriteLine("Maenv SMA upper envelope validated against Skender for all periods");
+    }
+
+    [Fact]
+    public void Validate_Skender_SMA_LowerEnvelope()
+    {
+        int[] periods = { 5, 10, 20, 50 };
+        double percentage = 2.5;
+
+        foreach (var period in periods)
+        {
+            var (_, _, qLower) = Maenv.Batch(_testData.Data, period, percentage, MaenvType.SMA);
+
+            var sResult = _testData.SkenderQuotes
+                .GetMaEnvelopes(period, percentage, MaType.SMA)
+                .ToList();
+
+            ValidationHelper.VerifyData(qLower, sResult, s => s.LowerEnvelope);
+        }
+        _output.WriteLine("Maenv SMA lower envelope validated against Skender for all periods");
+    }
+
+    [Fact]
+    public void Maenv_MatchesOoples_Structural()
+    {
+        var gbm = new GBM(startPrice: 100.0, mu: 0.02, sigma: 0.15, seed: 42);
+        var bars = gbm.Fetch(500, DateTime.UtcNow.Ticks, TimeSpan.FromMinutes(1));
+        var ooplesData = bars.Select(b => new TickerData
+        {
+            Date = new DateTime(b.Time, DateTimeKind.Utc),
+            Open = b.Open, High = b.High, Low = b.Low,
+            Close = b.Close, Volume = b.Volume
+        }).ToList();
+        var result = new StockData(ooplesData).CalculateMovingAverageEnvelope();
+        var values = result.OutputValues.Values.First();
+        int finiteCount = values.Count(v => double.IsFinite(v));
+        Assert.True(finiteCount > 100, $"Expected >100 finite values, got {finiteCount}");
+    }
+}