react-native-vroom-chart 0.15.0 → 0.17.0

package/cpp/_core_src/chart.cpp

@@ -9,6 +9,7 @@
 
 #include "chart.h"
 
+#include <algorithm>
 #include <cmath>
 
 #pragma clang diagnostic push
@@ -20,14 +21,20 @@
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include "atr.h"
+#include "atr_pane.h"
 #include "bollinger.h"
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
 #include "drawings.h"
 #include "footprints.h"
+#include "fvg_overlay.h"
+#include "ichimoku.h"
 #include "labels.h"
 #include "liquidity.h"
+#include "loading_line.h"
+#include "loading_wave.h"
 #include "ma.h"
 #include "ma_overlay.h"
 #include "macd.h"
@@ -38,6 +45,7 @@
 #include "rsi_pane.h"
 #include "style_inherit.h"
 #include "tip_anchor.h"
+#include "tip_geometry.h"
 #include "tip_pulse.h"
 #include "volume.h"
 #include "vwap.h"
@@ -59,16 +67,34 @@ vroom::Layout VroomChart::layout() const {
     const float axis_w = axis_width_px > 0.f
         ? axis_width_px
         : width_px * theme.floats[VROOM_FLOAT_Y_AXIS_WIDTH_RATIO];
-    const int pane_count = (rsi.enabled ? 1 : 0) + (macd.enabled ? 1 : 0);
+    const int pane_count =
+        (rsi.enabled ? 1 : 0) + (macd.enabled ? 1 : 0) + (atr.enabled ? 1 : 0);
     const float indicator_h = static_cast<float>(pane_count) * height_px *
                               theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+
+    // The line chart's tip dot is anchored to the newest close and overhangs the
+    // plot's right edge by its own radius, so the gutter has to be at least that
+    // wide or the dot lands under the y-axis strip (see tip_geometry.h). Only
+    // line mode needs it, and interpolating on morph_fade rather than switching
+    // on chart_type lets the few pixels of reflow ride the candles→line
+    // crossfade instead of stepping the instant the mode changes.
+    const float base_pad = theme.floats[VROOM_FLOAT_RIGHT_PADDING_PX];
+    float right_pad = base_pad;
+    if (theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+        const float wanted = std::max(
+            base_pad, vroom::tip_geometry::gutter_px(
+                          theme.floats[VROOM_FLOAT_LINE_WIDTH_PX]));
+        right_pad = base_pad + (wanted - base_pad) *
+                                   std::clamp(morph_fade, 0.f, 1.f);
+    }
+
     return vroom::Layout{
         width_px,
         height_px,
         vroom::axis_extent(axis_w, y_axis_collapse_t),
         vroom::axis_extent(theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
                            x_axis_collapse_t),
-        theme.floats[VROOM_FLOAT_RIGHT_PADDING_PX],
+        right_pad,
         theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO],
         0.05f,
         0.05f,
@@ -99,6 +125,90 @@ void VroomChart::ensure_macd() {
     macd_dirty = false;
 }
 
+void VroomChart::ensure_atr() {
+    if (!atr.enabled || !atr_dirty) return;
+    vroom::atr::compute(candles.data(), candles.size(), atr.period,
+                        atr.smoothing, atr_cache);
+    atr_dirty = false;
+}
+
+int VroomChart::indicator_panes(vroom::IndicatorPane out[vroom::kMaxPanes]) const {
+    int count = 0;
+    if (rsi.enabled) out[count++] = {rsi_order, vroom::PaneKind::Rsi};
+    if (macd.enabled) out[count++] = {macd_order, vroom::PaneKind::Macd};
+    if (atr.enabled) out[count++] = {atr_order, vroom::PaneKind::Atr};
+    // Insertion sort: at most three entries, already nearly ordered.
+    for (int i = 1; i < count; ++i) {
+        const vroom::IndicatorPane key = out[i];
+        int j = i - 1;
+        for (; j >= 0 && out[j].order > key.order; --j) out[j + 1] = out[j];
+        out[j + 1] = key;
+    }
+    return count;
+}
+
+void VroomChart::draw_indicator_panes(SkCanvas* canvas,
+                                      const vroom::Layout& lay,
+                                      const VroomCandle* visible,
+                                      std::size_t n, std::size_t first,
+                                      int64_t window_ms, float candle_right,
+                                      float pane_top, bool use_capture,
+                                      float morph_t) {
+    vroom::IndicatorPane panes[vroom::kMaxPanes];
+    const int count = indicator_panes(panes);
+    const float pane_h =
+        height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+
+    // A cache only lines up with the candles once its ensure_* has run against
+    // the current series; until then there is nothing to plot.
+    const auto visible_slice = [&](const std::vector<double>& cache) -> const double* {
+        return cache.size() == candles.size() ? cache.data() + first : nullptr;
+    };
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+
+    for (int i = 0; i < count; ++i) {
+        const float pane_bottom = pane_top + pane_h;
+        switch (panes[i].kind) {
+            case vroom::PaneKind::Rsi: {
+                ensure_rsi();
+                vroom::rsi_pane::draw(
+                    canvas, *this, lay, visible, n, visible_slice(rsi_cache),
+                    rsi.ma_visible ? visible_slice(rsi_ma_cache) : nullptr,
+                    window_ms, visible_start_ms, candle_duration_ms,
+                    candle_right, pane_top, pane_bottom,
+                    capture({vroom::LineKind::Rsi}),
+                    rsi.ma_visible ? capture({vroom::LineKind::RsiMa}) : nullptr,
+                    morph_t);
+                break;
+            }
+            case vroom::PaneKind::Macd: {
+                ensure_macd();
+                vroom::macd_pane::draw(
+                    canvas, *this, lay, visible, n, visible_slice(macd_cache),
+                    visible_slice(macd_signal_cache),
+                    visible_slice(macd_hist_cache), window_ms, visible_start_ms,
+                    candle_duration_ms, candle_right, pane_top, pane_bottom,
+                    capture({vroom::LineKind::Macd}),
+                    capture({vroom::LineKind::MacdSignal}),
+                    capture({vroom::LineKind::MacdHistogram}), morph_t);
+                break;
+            }
+            case vroom::PaneKind::Atr: {
+                ensure_atr();
+                vroom::atr_pane::draw(canvas, *this, lay, visible, n,
+                                      visible_slice(atr_cache), window_ms,
+                                      visible_start_ms, candle_duration_ms,
+                                      candle_right, pane_top, pane_bottom,
+                                      capture({vroom::LineKind::Atr}), morph_t);
+                break;
+            }
+        }
+        pane_top = pane_bottom;
+    }
+}
+
 void VroomChart::ensure_overlays() {
     if (!overlays_dirty) return;
     overlay_caches.resize(overlays.size());
@@ -126,6 +236,23 @@ void VroomChart::ensure_bollinger() {
     bollinger_dirty = false;
 }
 
+void VroomChart::ensure_ichimoku() {
+    if (!ichimoku.enabled || !ichimoku_dirty) return;
+    vroom::ichimoku::compute(candles.data(), candles.size(),
+                             ichimoku.tenkan_period, ichimoku.kijun_period,
+                             ichimoku.senkou_b_period, ich_tenkan_cache,
+                             ich_kijun_cache, ich_senkou_a_cache,
+                             ich_senkou_b_cache, ich_chikou_cache);
+    ichimoku_dirty = false;
+}
+
+void VroomChart::ensure_fvg() {
+    if (!fvg.enabled || !fvg_dirty) return;
+    vroom::fvg::compute(candles.data(), candles.size(), fvg.max_bars_back,
+                        fvg.wait_for_close != 0, fvg.fill_type, fvg_cache);
+    fvg_dirty = false;
+}
+
 void VroomChart::ensure_footprint_buckets() {
     if (!footprint_buckets_dirty) return;
     footprint_buckets = vroom::footprints::build_buckets(
@@ -134,6 +261,301 @@ void VroomChart::ensure_footprint_buckets() {
     footprint_buckets_dirty = false;
 }
 
+vroom::IndexRange VroomChart::ichimoku_source_range(int64_t shift_ms) const {
+    return vroom::ichimoku::shifted_source_range(
+        candles.data(), candles.size(), visible_start_ms - candle_duration_ms,
+        visible_end_ms + candle_duration_ms, shift_ms);
+}
+
+void VroomChart::draw_overlay_fills(SkCanvas* canvas, const vroom::Layout& lay,
+                                    const vroom::PriceBounds& bounds,
+                                    const VroomCandle* visible, std::size_t n,
+                                    std::size_t first, int64_t window_ms,
+                                    float candle_right, float candle_area_h,
+                                    bool use_capture, float morph_t) {
+    const std::size_t sz = candles.size();
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        if (bollinger.fill_enabled && bb_upper_cache.size() == sz &&
+            bb_lower_cache.size() == sz) {
+            vroom::ma_overlay::fill_between(
+                canvas, lay, bounds, visible, n, bb_upper_cache.data() + first,
+                bb_lower_cache.data() + first, window_ms, visible_start_ms,
+                candle_duration_ms, candle_right, candle_area_h,
+                bollinger.upper_color, bollinger.fill_opacity,
+                capture({vroom::LineKind::BollingerUpper}),
+                capture({vroom::LineKind::BollingerLower}), morph_t);
+        }
+    }
+
+    if (ichimoku.enabled && ichimoku.cloud_enabled) {
+        ensure_ichimoku();
+        if (ich_senkou_a_cache.size() == sz && ich_senkou_b_cache.size() == sz) {
+            const int64_t shift_ms =
+                static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+            const auto r = ichimoku_source_range(shift_ms);
+            // A fade's outgoing half has no new data to slice, but its capture
+            // still has to paint.
+            const bool has_new = n > 0 && r.end > r.start;
+            vroom::ma_overlay::fill_cloud(
+                canvas, lay, bounds,
+                has_new ? candles.data() + r.start : candles.data(),
+                has_new ? r.end - r.start : 0,
+                has_new ? ich_senkou_a_cache.data() + r.start : nullptr,
+                has_new ? ich_senkou_b_cache.data() + r.start : nullptr,
+                window_ms, visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, ichimoku.bullish_cloud_color,
+                ichimoku.bearish_cloud_color, ichimoku.cloud_opacity, shift_ms,
+                capture({vroom::LineKind::IchimokuSenkouA}),
+                capture({vroom::LineKind::IchimokuSenkouB}), morph_t);
+        }
+    }
+}
+
+void VroomChart::draw_overlay_lines(SkCanvas* canvas, const vroom::Layout& lay,
+                                    const vroom::PriceBounds& bounds,
+                                    const VroomCandle* visible, std::size_t n,
+                                    std::size_t first, int64_t window_ms,
+                                    float candle_right, float candle_area_h,
+                                    bool use_capture, float morph_t) {
+    const std::size_t sz = candles.size();
+    const auto capture = [&](vroom::LineKey key) -> const vroom::LineMorph* {
+        return use_capture ? vroom::find_line_morph(morph_lines, key) : nullptr;
+    };
+    // One price-pane line against the visible slice. `n == 0` (a fade's
+    // outgoing half) leaves only the capture to draw.
+    const auto stroke = [&](vroom::LineKey key, const std::vector<double>& cache,
+                            uint32_t color, float width,
+                            const unsigned char* breaks) {
+        if (cache.size() != sz) return;
+        vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
+                                cache.data() + first, window_ms,
+                                visible_start_ms, candle_duration_ms,
+                                candle_right, candle_area_h, color, width,
+                                breaks, 1.f, 0, capture(key), morph_t);
+    };
+
+    if (!overlays.empty()) {
+        ensure_overlays();
+        for (std::size_t k = 0; k < overlays.size(); ++k) {
+            stroke(vroom::overlay_line_key(overlays[k], k), overlay_caches[k],
+                   overlays[k].color, overlays[k].width, nullptr);
+        }
+    }
+
+    if (vwap.enabled) {
+        ensure_vwap();
+        stroke({vroom::LineKind::Vwap}, vwap_cache,
+               vroom::style::color_or(vwap.color, kVwapLine),
+               vroom::style::width_or(vwap.width, 1.5f),
+               vwap_breaks.size() == sz ? vwap_breaks.data() + first : nullptr);
+    }
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        stroke({vroom::LineKind::BollingerUpper}, bb_upper_cache,
+               bollinger.upper_color, bollinger.upper_width, nullptr);
+        stroke({vroom::LineKind::BollingerLower}, bb_lower_cache,
+               bollinger.lower_color, bollinger.lower_width, nullptr);
+        stroke({vroom::LineKind::BollingerMiddle}, bb_middle_cache,
+               bollinger.middle_color, bollinger.middle_width, nullptr);
+    }
+
+    if (ichimoku.enabled) {
+        ensure_ichimoku();
+        const int64_t shift_ms =
+            static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+        // The displaced spans read from their own source slice, so they can't
+        // go through `stroke`: the query window shifts back by however far the
+        // drawing shifts forward.
+        const auto span = [&](vroom::LineKey key,
+                              const std::vector<double>& cache, uint32_t color,
+                              float width, int64_t line_shift_ms) {
+            if (cache.size() != sz) return;
+            const auto r = ichimoku_source_range(line_shift_ms);
+            const bool has_new = n > 0 && r.end > r.start;
+            vroom::ma_overlay::draw(
+                canvas, lay, bounds,
+                has_new ? candles.data() + r.start : candles.data(),
+                has_new ? r.end - r.start : 0,
+                has_new ? cache.data() + r.start : nullptr, window_ms,
+                visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, color, width, nullptr, 1.f, line_shift_ms,
+                capture(key), morph_t);
+        };
+        // Span B under span A where the two edges touch, then the unshifted
+        // signal lines, then chikou on top of everything.
+        if (ichimoku.senkou_b_enabled) {
+            span({vroom::LineKind::IchimokuSenkouB}, ich_senkou_b_cache,
+                 ichimoku.senkou_b_color, ichimoku.senkou_b_width, shift_ms);
+        }
+        if (ichimoku.senkou_a_enabled) {
+            span({vroom::LineKind::IchimokuSenkouA}, ich_senkou_a_cache,
+                 ichimoku.senkou_a_color, ichimoku.senkou_a_width, shift_ms);
+        }
+        if (ichimoku.kijun_enabled) {
+            span({vroom::LineKind::IchimokuKijun}, ich_kijun_cache,
+                 ichimoku.kijun_color, ichimoku.kijun_width, 0);
+        }
+        if (ichimoku.tenkan_enabled) {
+            span({vroom::LineKind::IchimokuTenkan}, ich_tenkan_cache,
+                 ichimoku.tenkan_color, ichimoku.tenkan_width, 0);
+        }
+        if (ichimoku.chikou_enabled) {
+            span({vroom::LineKind::IchimokuChikou}, ich_chikou_cache,
+                 ichimoku.chikou_color, ichimoku.chikou_width, -shift_ms);
+        }
+    }
+}
+
+void VroomChart::capture_morph_lines(const vroom::Layout& lay,
+                                     const vroom::PriceBounds& bounds,
+                                     vroom::IndexRange range,
+                                     int64_t window_ms) {
+    morph_lines.clear();
+    const float area_w = vroom::candle_area_width(lay);
+    const std::size_t n = range.end - range.start;
+    if (area_w <= 0.f || window_ms <= 0 || n == 0) return;
+    const ::VroomCandle* visible = candles.data() + range.start;
+    const std::size_t sz = candles.size();
+
+    // Captures one series newest-first, matching the slot indexing every morph
+    // draw pairs on. `src` is the slice the values were drawn against — the
+    // visible one for everything except Ichimoku's displaced spans, which plot
+    // at `time_ms + shift_ms` from a window of their own. `frac` maps a value
+    // into its band; it's the only part that differs between the price pane and
+    // an indicator pane.
+    const auto capture = [&](vroom::LineKey key, const ::VroomCandle* src,
+                             std::size_t src_n, const double* values,
+                             int64_t shift_ms, double scale, auto&& frac) {
+        if (!values || src_n == 0) return;
+        vroom::LineMorph line;
+        line.key = key;
+        line.scale = scale;
+        line.pts.resize(src_n);
+        for (std::size_t k = 0; k < src_n; ++k) {
+            const std::size_t i = src_n - 1 - k;
+            const double v = values[i];
+            const bool defined = std::isfinite(v);
+            line.pts[k] = vroom::LineSnapshot{
+                vroom::candle_center_x(lay, src[i].time_ms + shift_ms,
+                                       candle_duration_ms, visible_start_ms,
+                                       window_ms) /
+                    area_w,
+                defined ? static_cast<float>(frac(v)) : 0.f,
+                defined,
+            };
+        }
+        morph_lines.push_back(std::move(line));
+    };
+
+    // Price-pane series share the band the candle capture was taken against, so
+    // they keep their position relative to the candles through the switch.
+    const auto price_frac = [&](double v) {
+        return vroom::price_fraction(bounds, v);
+    };
+    const auto price_series = [&](vroom::LineKey key,
+                                  const std::vector<double>& cache) {
+        if (cache.size() != sz) return;
+        capture(key, visible, n, cache.data() + range.start, 0, 0.0, price_frac);
+    };
+
+    if (!overlays.empty()) {
+        ensure_overlays();
+        for (std::size_t k = 0; k < overlays.size(); ++k) {
+            price_series(vroom::overlay_line_key(overlays[k], k),
+                         overlay_caches[k]);
+        }
+    }
+
+    if (vwap.enabled) {
+        ensure_vwap();
+        price_series({vroom::LineKind::Vwap}, vwap_cache);
+    }
+
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        price_series({vroom::LineKind::BollingerUpper}, bb_upper_cache);
+        price_series({vroom::LineKind::BollingerMiddle}, bb_middle_cache);
+        price_series({vroom::LineKind::BollingerLower}, bb_lower_cache);
+    }
+
+    if (ichimoku.enabled) {
+        ensure_ichimoku();
+        const int64_t shift_ms =
+            static_cast<int64_t>(ichimoku.displacement) * candle_duration_ms;
+        // Same source windows draw_chart uses, so slot 0 is the same rightmost
+        // vertex on both sides of the switch even for a span running past the
+        // newest candle into empty time.
+        const auto span = [&](vroom::LineKey key,
+                              const std::vector<double>& cache,
+                              int64_t line_shift_ms) {
+            if (cache.size() != sz) return;
+            const auto r = ichimoku_source_range(line_shift_ms);
+            if (r.end <= r.start) return;
+            capture(key, candles.data() + r.start, r.end - r.start,
+                    cache.data() + r.start, line_shift_ms, 0.0, price_frac);
+        };
+        span({vroom::LineKind::IchimokuTenkan}, ich_tenkan_cache, 0);
+        span({vroom::LineKind::IchimokuKijun}, ich_kijun_cache, 0);
+        span({vroom::LineKind::IchimokuSenkouA}, ich_senkou_a_cache, shift_ms);
+        span({vroom::LineKind::IchimokuSenkouB}, ich_senkou_b_cache, shift_ms);
+        span({vroom::LineKind::IchimokuChikou}, ich_chikou_cache, -shift_ms);
+    }
+
+    // Pane series normalize against their pane's own band rather than the price
+    // one, so each pane's auto-fit is free to change across the switch without
+    // the capture moving.
+    const auto pane_slice = [&](const std::vector<double>& cache) -> const double* {
+        return cache.size() == sz ? cache.data() + range.start : nullptr;
+    };
+
+    if (rsi.enabled) {
+        ensure_rsi();
+        const auto frac = [&](double v) {
+            return vroom::rsi::band_fraction(v, rsi_y_scale);
+        };
+        capture({vroom::LineKind::Rsi}, visible, n, pane_slice(rsi_cache), 0, 0.0,
+                frac);
+        if (rsi.ma_visible) {
+            capture({vroom::LineKind::RsiMa}, visible, n,
+                    pane_slice(rsi_ma_cache), 0, 0.0, frac);
+        }
+    }
+
+    if (macd.enabled) {
+        ensure_macd();
+        const double* line = pane_slice(macd_cache);
+        const double* signal = pane_slice(macd_signal_cache);
+        const double* hist = pane_slice(macd_hist_cache);
+        const double scale = vroom::macd::autoscale(
+            macd.line_visible ? line : nullptr,
+            macd.signal_visible ? signal : nullptr,
+            macd.hist_visible ? hist : nullptr, n);
+        const auto frac = [&](double v) {
+            return vroom::macd::band_fraction(v, scale, macd_y_scale);
+        };
+        capture({vroom::LineKind::Macd}, visible, n, line, 0, scale, frac);
+        capture({vroom::LineKind::MacdSignal}, visible, n, signal, 0, scale, frac);
+        capture({vroom::LineKind::MacdHistogram}, visible, n, hist, 0, scale,
+                frac);
+    }
+
+    if (atr.enabled) {
+        ensure_atr();
+        const double* line = pane_slice(atr_cache);
+        const double scale = vroom::atr::autoscale(line, n);
+        capture({vroom::LineKind::Atr}, visible, n, line, 0, scale,
+                [&](double v) {
+                    return vroom::atr::band_fraction(v, scale, atr_y_scale);
+                });
+    }
+}
+
 void VroomChart::draw_chart(SkCanvas* canvas) {
     begin_frame();
     const auto lay = layout();
@@ -143,6 +565,23 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     bg.setColor(theme.colors[VROOM_COLOR_BACKGROUND]);
     canvas->drawRect(SkRect::MakeWH(width_px, height_px), bg);
 
+    // 1b. Loading line, in place of the scene (stages 1 and 2). Above the
+    //     `candles.empty()` return because `loading` is authoritative: the host
+    //     may still be holding the previous asset's bars while the new one
+    //     loads, and the line has to win over them. Returning here is also what
+    //     suppresses the axis text, price badge, crosshair and indicator panes
+    //     until stage 3 releases the flag.
+    if (loading) {
+        if (loading_fade_in < 1.f) {
+            canvas->saveLayerAlphaf(nullptr, loading_fade_in);
+            vroom::loading_line::draw(canvas, *this, lay);
+            canvas->restore();
+        } else {
+            vroom::loading_line::draw(canvas, *this, lay);
+        }
+        return;
+    }
+
     if (candles.empty()) return;
 
     // 2. Visible slice + bounds + window_ms + geometry
@@ -161,6 +600,10 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     const float candle_area_h = vroom::price_pane_bottom(lay);
     const float candle_right =
         width_px - lay.y_axis_width_px - lay.right_padding_px;
+    // The line tip is the one plot layer allowed past candle_right: its dot
+    // overhangs the newest candle's center, which the pinned-to-latest framing
+    // puts within a few pixels of that edge. It stops at the y-axis strip.
+    const float tip_clip_right = width_px - lay.y_axis_width_px;
 
     // 3. Update label fade state ONCE per frame — both gridlines and labels
     //    share these opacities so their animations stay in lockstep.
@@ -205,13 +648,38 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     const std::size_t morph_n_draw = reshape ? morph_n : 0;
     const float morph_t = reshape ? interval_morph_t : 1.f;
 
+    // Line-mode tip marker, resolved by whichever branch below draws the price
+    // series and painted at step 6.5. It is the only plot layer that has to
+    // outlive the axis backgrounds, so it can't be drawn in place like the rest.
+    float tip_opacity = 0.f;
+    std::size_t tip_slots = 0;
+    const vroom::CandleSnapshot* tip_from = nullptr;
+    std::size_t tip_from_n = 0;
+    float tip_morph_t = 1.f;
+
     if (fade_out) {
-        // First half: only the captured series, at the axis envelope opacity.
-        // Layers with no snapshot (volume, overlays, indicators, drawings)
-        // would already be the new data, so they stay hidden until the incoming
-        // half. morph_t = 0 draws the capture pixel-identically.
+        // First half: only what was captured, at the axis envelope opacity.
+        // Layers with no snapshot (volume, liquidity, FVG, drawings) would
+        // already be the new data, so they stay hidden until the incoming half.
+        // morph_t = 0 draws every capture pixel-identically.
         const float layer = axis_phase.opacity;
+        // Groups the captured indicators into one layer rather than threading
+        // the envelope through as a per-paint alpha, so overlapping strokes
+        // composite once and the panes keep their signatures. The price series
+        // below fades per-paint, as it always has.
+        const auto push_fade_layer = [&]() -> bool {
+            if (layer >= 0.999f) return false;
+            canvas->saveLayerAlpha(nullptr,
+                                   static_cast<U8CPU>(layer * 255.f + 0.5f));
+            return true;
+        };
         if (layer > 0.f) {
+            // Behind the candles, as in the settled z-order.
+            const bool fills_wrapped = push_fade_layer();
+            draw_overlay_fills(canvas, lay, bounds, visible, 0, range.start,
+                               window_ms, candle_right, candle_area_h, true, 0.f);
+            if (fills_wrapped) canvas->restore();
+
             if (fade > 0.f) {
                 vroom::ma_overlay::draw_close_gradient(
                     canvas, lay, bounds, visible, 0, window_ms,
@@ -236,18 +704,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                     theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade * layer,
                     morph_from.data(), morph_n, 0.f,
                     theme.floats[VROOM_FLOAT_LINE_TENSION]);
-                if (theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
-                    vroom::ma_overlay::draw_close_tip(
-                        canvas, lay, bounds, visible, 0, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h, theme.colors[VROOM_COLOR_LINE],
-                        theme.colors[VROOM_COLOR_BACKGROUND],
-                        theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade * layer,
-                        theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
-                        tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
-                        morph_from.data(), morph_n, 0.f);
-                }
+                tip_opacity = fade * layer;
+                tip_slots = 0;
+                tip_from = morph_from.data();
+                tip_from_n = morph_n;
+                tip_morph_t = 0.f;
             }
+
+            // Over the candles, and the panes below them. One layer for both:
+            // they occupy disjoint bands, so nothing overlaps across the two.
+            const bool lines_wrapped = push_fade_layer();
+            draw_overlay_lines(canvas, lay, bounds, visible, 0, range.start,
+                               window_ms, candle_right, candle_area_h, true, 0.f);
+            if (lay.indicator_area_h > 0.f) {
+                draw_indicator_panes(canvas, lay, visible, 0, range.start,
+                                     window_ms, candle_right, candle_area_h,
+                                     true, 0.f);
+            }
+            if (lines_wrapped) canvas->restore();
         }
     } else {
         // Incoming fade: the new scene at envelope opacity, no slot lerp
@@ -273,9 +747,19 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             }
 
             // 4.5. Volume bars — drawn under the candles so candles z-index above.
-            if (volume_collapse_t < 1.f) {
+            //      Through a loading reveal they grow up off the axis on the
+            //      same clock as the candles, borrowing the collapse they
+            //      already have. They carry no morph snapshot of their own, so
+            //      without this they'd snap in at full height while the price
+            //      series is still a thread lying on the line. A render-time
+            //      override, not a state change: the host still owns the
+            //      collapse for the volume toggle.
+            const float vol_t = loading_line_revealing
+                ? std::max(volume_collapse_t, 1.f - interval_morph_t)
+                : volume_collapse_t;
+            if (vol_t < 1.f) {
                 vroom::volume::draw(canvas, visible, n, lay, theme, volume,
-                                    volume_collapse_t, volume_collapse_easing,
+                                    vol_t, volume_collapse_easing,
                                     window_ms, visible_start_ms,
                                     candle_duration_ms);
             }
@@ -284,22 +768,20 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                                    candle_area_h);
 
-            // 4.7. Bollinger Band fill.
-            if (bollinger.enabled) {
-                ensure_bollinger();
-                if (bollinger.fill_enabled &&
-                    bb_upper_cache.size() == candles.size() &&
-                    bb_lower_cache.size() == candles.size()) {
-                    vroom::ma_overlay::fill_between(
-                        canvas, lay, bounds, visible, n,
-                        bb_upper_cache.data() + range.start,
-                        bb_lower_cache.data() + range.start, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h, bollinger.upper_color,
-                        bollinger.fill_opacity);
-                }
+            // 4.65. Fair Value Gap boxes — behind the candles, so the bars that
+            // formed each imbalance still read over their own shading.
+            if (fvg.enabled) {
+                ensure_fvg();
+                vroom::fvg_overlay::draw_boxes(canvas, *this, lay, bounds,
+                                               window_ms, candle_right,
+                                               candle_area_h);
             }
 
+            // 4.7 / 4.75. Bollinger fill and Ichimoku cloud, behind the candles.
+            draw_overlay_fills(canvas, lay, bounds, visible, n, range.start,
+                               window_ms, candle_right, candle_area_h, reshape,
+                               morph_t);
+
             // 5. Price series — candles, a close-price line, or a blend.
             if (fade < 1.f) {
                 vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
@@ -317,146 +799,49 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
                     theme.floats[VROOM_FLOAT_LINE_TENSION]);
             }
 
-            // 5.5. Moving-average overlay lines.
-            if (!overlays.empty()) {
-                ensure_overlays();
-                for (std::size_t k = 0; k < overlays.size(); ++k) {
-                    if (overlay_caches[k].size() != candles.size()) continue;
-                    const double* vis = overlay_caches[k].data() + range.start;
-                    vroom::ma_overlay::draw(
-                        canvas, lay, bounds, visible, n, vis, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h, overlays[k].color, overlays[k].width);
-                }
-            }
-
-            // 5.6. VWAP overlay.
-            if (vwap.enabled) {
-                ensure_vwap();
-                if (vwap_cache.size() == candles.size()) {
-                    const double* vis = vwap_cache.data() + range.start;
-                    const unsigned char* brk =
-                        vwap_breaks.size() == candles.size()
-                            ? vwap_breaks.data() + range.start
-                            : nullptr;
-                    vroom::ma_overlay::draw(
-                        canvas, lay, bounds, visible, n, vis, window_ms,
-                        visible_start_ms, candle_duration_ms, candle_right,
-                        candle_area_h,
-                        vroom::style::color_or(vwap.color, kVwapLine),
-                        vroom::style::width_or(vwap.width, 1.5f), brk);
-                }
-            }
-
-            // 5.65. Bollinger Band lines.
-            if (bollinger.enabled) {
-                ensure_bollinger();
-                const std::size_t sz = candles.size();
-                if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
-                    bb_middle_cache.size() == sz) {
-                    const auto stroke = [&](const std::vector<double>& cache,
-                                              uint32_t color, float width) {
-                        vroom::ma_overlay::draw(
-                            canvas, lay, bounds, visible, n,
-                            cache.data() + range.start, window_ms,
-                            visible_start_ms, candle_duration_ms, candle_right,
-                            candle_area_h, color, width);
-                    };
-                    stroke(bb_upper_cache, bollinger.upper_color,
-                           bollinger.upper_width);
-                    stroke(bb_lower_cache, bollinger.lower_color,
-                           bollinger.lower_width);
-                    stroke(bb_middle_cache, bollinger.middle_color,
-                           bollinger.middle_width);
-                }
-            }
+            // 5.5 - 5.67. Moving averages, VWAP, Bollinger and Ichimoku lines.
+            draw_overlay_lines(canvas, lay, bounds, visible, n, range.start,
+                               window_ms, candle_right, candle_area_h, reshape,
+                               morph_t);
 
             // 5.7. Drawing annotations.
             vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
                                   candle_area_h);
 
-            // 5.8. Line-mode tip marker.
-            if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+            // 5.8. Line-mode tip marker. The saveLayer this branch may be
+            //      wrapped in doesn't reach step 6.5, so fold its alpha in.
+            if (fade > 0.f) {
                 const auto anchor = vroom::tip_anchor::at(
                     range.start, range.end, candles.size(), reshape);
-                vroom::ma_overlay::draw_close_tip(
-                    canvas, lay, bounds, visible, anchor.slot_count, window_ms,
-                    visible_start_ms, candle_duration_ms, candle_right,
-                    candle_area_h, theme.colors[VROOM_COLOR_LINE],
-                    theme.colors[VROOM_COLOR_BACKGROUND],
-                    theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade,
-                    theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
-                    tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
-                    anchor.use_morph ? morph_src : nullptr,
-                    anchor.use_morph ? morph_n_draw : 0, morph_t);
+                tip_opacity = fade * (wrap ? axis_phase.opacity : 1.f);
+                tip_slots = anchor.slot_count;
+                tip_from = anchor.use_morph ? morph_src : nullptr;
+                tip_from_n = anchor.use_morph ? morph_n_draw : 0;
+                tip_morph_t = morph_t;
             }
 
             // Incoming fade: indicator panes share the scene opacity (and
             // paint before axis masks so overflow still clips). Transforms
             // keep the settled z-order after the price indicator.
             if (fade_in && lay.indicator_area_h > 0.f) {
-                struct ActivePane {
-                    int order;
-                    int type;
-                };
-                ActivePane panes[2];
-                int count = 0;
-                if (rsi.enabled) panes[count++] = {rsi_order, 0};
-                if (macd.enabled) panes[count++] = {macd_order, 1};
-                if (count == 2 && panes[0].order > panes[1].order) {
-                    const ActivePane tmp = panes[0];
-                    panes[0] = panes[1];
-                    panes[1] = tmp;
-                }
-
-                const float pane_h =
-                    height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
-                float pane_top = candle_area_h;
-                for (int i = 0; i < count; ++i) {
-                    const float pane_bottom = pane_top + pane_h;
-                    if (panes[i].type == 0) {
-                        ensure_rsi();
-                        const double* rsi_vis =
-                            rsi_cache.size() == candles.size()
-                                ? rsi_cache.data() + range.start
-                                : nullptr;
-                        const double* rsi_ma_vis =
-                            (rsi.ma_visible &&
-                             rsi_ma_cache.size() == candles.size())
-                                ? rsi_ma_cache.data() + range.start
-                                : nullptr;
-                        vroom::rsi_pane::draw(
-                            canvas, *this, lay, visible, n, rsi_vis, rsi_ma_vis,
-                            window_ms, visible_start_ms, candle_duration_ms,
-                            candle_right, pane_top, pane_bottom);
-                    } else {
-                        ensure_macd();
-                        const double* macd_vis =
-                            macd_cache.size() == candles.size()
-                                ? macd_cache.data() + range.start
-                                : nullptr;
-                        const double* sig_vis =
-                            macd_signal_cache.size() == candles.size()
-                                ? macd_signal_cache.data() + range.start
-                                : nullptr;
-                        const double* hist_vis =
-                            macd_hist_cache.size() == candles.size()
-                                ? macd_hist_cache.data() + range.start
-                                : nullptr;
-                        vroom::macd_pane::draw(
-                            canvas, *this, lay, visible, n, macd_vis, sig_vis,
-                            hist_vis, window_ms, visible_start_ms,
-                            candle_duration_ms, candle_right, pane_top,
-                            pane_bottom);
-                    }
-                    pane_top = pane_bottom;
-                }
+                draw_indicator_panes(canvas, lay, visible, n, range.start,
+                                     window_ms, candle_right, candle_area_h,
+                                     false, 1.f);
             }
         }
 
         if (wrap) canvas->restore();
     }
 
+    // 5.9. Loading line, stage 3. Over the series it handed off to, on the same
+    //      clock, so it reads as the bars peeling away from the line rather than
+    //      two things dissolving independently. Before the axis masks below,
+    //      since it belongs inside the plot.
+    if (loading_line_revealing) {
+        vroom::loading_line::draw_fading(canvas, *this, lay,
+                                         1.f - interval_morph_t);
+    }
+
     // 6. Axis backgrounds (mask any candle overflow). The x-axis separator
     //    line is intentionally omitted for now. The bottom strip anchors at
     //    x_axis_top (below any indicator pane) so it never paints over it.
@@ -471,6 +856,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         SkRect::MakeXYWH(candle_right, 0, axis_block_w, height_px),
         axis_bg);
 
+    // 6.5. Line-mode tip marker, resolved at 5.8. After the masks because the
+    //      dot sits on the newest close, which a view following the latest bar
+    //      parks within a few pixels of candle_right — closer than the dot's own
+    //      radius — so it paints into the gutter the layout widened for it. The
+    //      clip still stops at the y-axis strip, so nothing here can reach the
+    //      price labels; the pulse ring simply ends there.
+    if (tip_opacity > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+        vroom::ma_overlay::draw_close_tip(
+            canvas, lay, bounds, visible, tip_slots, window_ms,
+            visible_start_ms, candle_duration_ms, candle_right, tip_clip_right,
+            candle_area_h, theme.colors[VROOM_COLOR_LINE],
+            theme.colors[VROOM_COLOR_BACKGROUND],
+            theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], tip_opacity,
+            theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
+            tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds, tip_from,
+            tip_from_n, tip_morph_t);
+    }
+
     // 7. Labels (read from y_fades / x_fades, no state mutation here)
     vroom::labels::draw_y_labels(canvas, *this, lay, axis_bounds);
     vroom::labels::draw_x_labels(canvas, *this, lay, axis_start_ms, axis_end_ms);
@@ -480,8 +883,24 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     //      Hidden during a fade's outgoing half: the close is already the new
     //      series and there is no snapshot to fade.
     if (!fade_out) {
-        vroom::price_indicator::draw(canvas, *this, lay, bounds,
-                                     candle_right, candle_area_h);
+        // Eased off the same capture the candles reshape through, so the badge
+        // rides the bar's close edge instead of landing on the new price a
+        // whole animation early. The pairing rule is the tip marker's: the
+        // capture only stands for the newest candle while that candle is the
+        // one at the right edge.
+        const auto price_anchor = vroom::tip_anchor::at(
+            range.start, range.end, candles.size(), reshape);
+        const vroom::CandleSnapshot* price_from =
+            (price_anchor.use_morph && morph_src && morph_n_draw > 0)
+                ? morph_src
+                : nullptr;
+        vroom::price_indicator::draw(canvas, *this, lay, bounds, candle_right,
+                                     candle_area_h, price_from, morph_t);
+
+        // 7.54. Fair Value Gap labels — the boxes themselves are back behind
+        //       the candles, but their text has to clear the bars it sits over.
+        vroom::fvg_overlay::draw_labels(canvas, *this, lay, bounds, window_ms,
+                                        candle_right, candle_area_h);
 
         // 7.55. Consumer-supplied price status lines — same tier as the
         //       current-price indicator (their badges must cover the labels
@@ -503,50 +922,9 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     //      INDICATOR_HEIGHT_FRAC of the height; the candle pane already shrank
     //      to fit them (see layout()). A fade already drew them with the scene.
     if (!fade_swap && lay.indicator_area_h > 0.f) {
-        struct ActivePane { int order; int type; };  // type: 0 = RSI, 1 = MACD
-        ActivePane panes[2];
-        int count = 0;
-        if (rsi.enabled) panes[count++] = {rsi_order, 0};
-        if (macd.enabled) panes[count++] = {macd_order, 1};
-        if (count == 2 && panes[0].order > panes[1].order) {
-            const ActivePane tmp = panes[0];
-            panes[0] = panes[1];
-            panes[1] = tmp;
-        }
-
-        const float pane_h =
-            height_px * theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
-        float pane_top = candle_area_h;  // == price_pane_bottom(lay)
-        for (int i = 0; i < count; ++i) {
-            const float pane_bottom = pane_top + pane_h;
-            if (panes[i].type == 0) {
-                ensure_rsi();
-                const double* rsi_vis = rsi_cache.size() == candles.size()
-                    ? rsi_cache.data() + range.start : nullptr;
-                const double* rsi_ma_vis =
-                    (rsi.ma_visible && rsi_ma_cache.size() == candles.size())
-                        ? rsi_ma_cache.data() + range.start : nullptr;
-                vroom::rsi_pane::draw(canvas, *this, lay, visible, n, rsi_vis,
-                                      rsi_ma_vis, window_ms, visible_start_ms,
-                                      candle_duration_ms, candle_right, pane_top,
-                                      pane_bottom);
-            } else {
-                ensure_macd();
-                const double* macd_vis = macd_cache.size() == candles.size()
-                    ? macd_cache.data() + range.start : nullptr;
-                const double* sig_vis =
-                    macd_signal_cache.size() == candles.size()
-                        ? macd_signal_cache.data() + range.start : nullptr;
-                const double* hist_vis =
-                    macd_hist_cache.size() == candles.size()
-                        ? macd_hist_cache.data() + range.start : nullptr;
-                vroom::macd_pane::draw(canvas, *this, lay, visible, n, macd_vis,
-                                       sig_vis, hist_vis, window_ms,
-                                       visible_start_ms, candle_duration_ms,
-                                       candle_right, pane_top, pane_bottom);
-            }
-            pane_top = pane_bottom;
-        }
+        // candle_area_h == price_pane_bottom(lay), the top of the band.
+        draw_indicator_panes(canvas, lay, visible, n, range.start, window_ms,
+                             candle_right, candle_area_h, reshape, morph_t);
     }
 
     // 7.7. Crosshair — drawn last so it sits on top of everything, including the
@@ -593,6 +971,182 @@ void VroomChart::begin_frame() {
     // and a chart left open for hours would otherwise lose float precision on it.
     tip_pulse_elapsed_s =
         std::fmod(tip_pulse_elapsed_s + dt, vroom::tip_pulse::kPeriodSeconds);
+
+    if (loading) {
+        // Frozen once a capture exists: stage 2 morphs away from the phase the
+        // sine held when the data landed, and advancing it underneath would
+        // drag the morph's own start point around.
+        if (loading_animate && loading_line.empty()) {
+            loading_elapsed_s = std::fmod(loading_elapsed_s + dt,
+                                          vroom::loading_wave::kPeriodSeconds);
+        }
+        // Ramps regardless of `loading_animate`: reduced motion suppresses the
+        // wave's movement, not the appearance of the line itself, which would
+        // otherwise pop in at full strength.
+        constexpr float kFadeInSeconds = 0.3f;
+        loading_fade_in = std::min(1.f, loading_fade_in + dt / kFadeInSeconds);
+    }
+}
+
+void VroomChart::set_loading(bool on, bool animate) {
+    loading_animate = animate;
+    if (on == loading) return;  // a re-push of the same state isn't a restart
+    loading = on;
+
+    // Either direction abandons any hand-off in flight. Going false without
+    // passing through the two stages is the cancel path (fetch failed, asset
+    // switched again mid-load), and it should leave nothing behind.
+    loading_line.clear();
+    loading_line_t = 1.f;
+    loading_line_revealing = false;
+    if (!on) {
+        mark_dirty();
+        return;
+    }
+
+    loading_elapsed_s = 0.f;
+    loading_fade_in = 0.f;
+    mark_dirty();
+}
+
+// Visible slice + price bounds the two hand-off stages both need. Mirrors what
+// draw_chart computes in step 2; `n == 0` means there is nothing to hand off to.
+VroomChart::LoadingTarget VroomChart::loading_target() const {
+    LoadingTarget t{};
+    if (candles.empty()) return t;
+    const auto range = vroom::visible_indices(candles.data(), candles.size(),
+                                              visible_start_ms, visible_end_ms);
+    const std::size_t n = range.end - range.start;
+    if (n == 0) return t;
+    t.visible = candles.data() + range.start;
+    t.n = n;
+    t.bounds = price_bounds_manual
+        ? price_bounds
+        : vroom::auto_price_bounds(t.visible, n);
+    return t;
+}
+
+void VroomChart::begin_loading_morph() {
+    if (!loading) return;
+
+    const auto lay = layout();
+    const float area_w = vroom::candle_area_width(lay);
+    const auto target = loading_target();
+    if (target.n == 0 || area_w <= 0.f) return;
+
+    const int64_t window_ms = visible_end_ms - visible_start_ms;
+    const float elapsed = loading_animate ? loading_elapsed_s : 0.f;
+
+    const auto push = [&](float xf, float to_y) {
+        vroom::LinePoint p{};
+        p.x = xf;
+        // Sampling the sine at this vertex's own x is what makes the freeze
+        // invisible: the curve the user was watching passes through this point
+        // already, so stage 2 starts on the pixels stage 1 ended on.
+        p.from_y = vroom::loading_wave::y_frac(elapsed,
+                                               std::clamp(xf, 0.f, 1.f));
+        p.to_y = to_y;
+        loading_line.push_back(p);
+    };
+    // Mid-range, not mid-body: the bars grow outward symmetrically from this
+    // line, so anchoring on the body would leave one wick reaching further
+    // than the other.
+    const auto center_frac = [&](const ::VroomCandle& c) {
+        return static_cast<float>(
+            vroom::price_fraction(target.bounds, (c.high + c.low) * 0.5));
+    };
+    const auto center_x_frac = [&](const ::VroomCandle& c) {
+        return vroom::candle_center_x(lay, c.time_ms, candle_duration_ms,
+                                      visible_start_ms, window_ms) / area_w;
+    };
+
+    // Left to right, the order a polyline wants. (The reveal below indexes from
+    // the right instead, because that's what the morph machinery expects.)
+    loading_line.clear();
+    loading_line.reserve(target.n + 2);
+
+    // Spans the data doesn't reach — a short series in a wider window — are
+    // sampled at the idle curve's own resolution and flattened to the nearest
+    // candle's level. So the line still begins as the curve across the *whole*
+    // plot and eases into a level run leading into the series; leaving those
+    // spans out instead would snap the line's length on the first frame.
+    const int across = vroom::loading_wave::sample_count(area_w);
+    const float step = 1.f / static_cast<float>(across);
+    const float first_xf = center_x_frac(target.visible[0]);
+    const float last_xf = center_x_frac(target.visible[target.n - 1]);
+
+    for (int i = 0; static_cast<float>(i) * step < first_xf; ++i) {
+        push(static_cast<float>(i) * step, center_frac(target.visible[0]));
+    }
+    for (std::size_t i = 0; i < target.n; ++i) {
+        push(center_x_frac(target.visible[i]), center_frac(target.visible[i]));
+    }
+    for (int i = static_cast<int>(std::ceil(last_xf / step)); i <= across; ++i) {
+        push(static_cast<float>(i) * step,
+             center_frac(target.visible[target.n - 1]));
+    }
+
+    loading_line_t = 0.f;
+    // `loading` stays set: the axes, price badge and panes have no business
+    // appearing until the candles themselves do, in stage 3.
+    mark_dirty();
+}
+
+void VroomChart::begin_loading_reveal() {
+    if (!loading) return;
+    loading = false;
+
+    const auto lay = layout();
+    const float area_w = vroom::candle_area_width(lay);
+    const auto target = loading_target();
+    if (target.n == 0 || area_w <= 0.f) {
+        loading_line.clear();
+        mark_dirty();
+        return;
+    }
+
+    const int64_t window_ms = visible_end_ms - visible_start_ms;
+
+    // Right-to-left, matching how the morph machinery indexes slots (slot 0 =
+    // newest bar at the right edge).
+    morph_from.clear();
+    morph_from.reserve(target.n);
+    for (std::size_t slot = 0; slot < target.n; ++slot) {
+        const ::VroomCandle& c = target.visible[target.n - 1 - slot];
+        const float center = static_cast<float>(
+            vroom::price_fraction(target.bounds, (c.high + c.low) * 0.5));
+
+        vroom::CandleSnapshot s{};
+        s.x = vroom::candle_center_x(lay, c.time_ms, candle_duration_ms,
+                                     visible_start_ms, window_ms) / area_w;
+        // Every price collapsed onto the centre, so the slot starts as a
+        // zero-height sliver sitting on the line and the existing lerp is what
+        // grows it out to full open/high/low/close.
+        s.open = s.high = s.low = s.close = center;
+        s.bull = c.close >= c.open;
+        // Starts the colour blend from fully transparent rather than from the
+        // skeleton grey: the bar emerges from the line, so a grey body would
+        // just smear the line thicker on the first frames.
+        s.skeleton = true;
+        s.skeleton_alpha = 0.f;
+        morph_from.push_back(s);
+    }
+
+    morph_from_bounds = target.bounds;
+    interval_morph_t = 0.f;
+    // Slot-lerp, not crossfade: each bar has a counterpart to grow out of, so
+    // pairing column to column is what makes the line *become* the data instead
+    // of one scene dissolving into another.
+    interval_morph_fade = false;
+    // Keeps the axes out of the interval envelope (see labels::interval_phase),
+    // which is what the flag actually selects. A timeframe switch runs the
+    // outgoing ticks out and the new ones in; here there are no outgoing ticks
+    // — stages 1 and 2 draw no axis at all — so that envelope would hold the
+    // real labels back for the first half of the reveal. Per-label fades bring
+    // them up from nothing instead, in step with the bars.
+    morph_is_stream = true;
+    loading_line_revealing = true;
+    mark_dirty();
 }
 
 bool VroomChart::tip_pulse_active() const {
@@ -613,6 +1167,10 @@ bool VroomChart::is_animating_now() const {
     // The pulse never finishes on its own, so this is what keeps the host loops
     // requeueing frames for it.
     if (tip_pulse_active()) return true;
+    // Same deal for the loading line's wave, except a still line (reduced
+    // motion, once faded in) has nothing left to redraw and may go idle. The
+    // two hand-off stages are host-driven, so they need nothing here.
+    if (loading && (loading_animate || loading_fade_in < 1.f)) return true;
     for (const auto& f : y_fades) {
         if (f.opacity != f.target) return true;
     }