react-native-vroom-chart 0.15.0 → 0.16.0

package/cpp/_core_src/fair_value_gaps.h

@@ -0,0 +1,54 @@
+// Fair Value Gaps over a candle series — pure, no Skia, so it builds into the
+// unit-test target. Drawn as shaded price-pane boxes over three-candle
+// imbalances.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::fvg {
+
+// One detected imbalance, anchored in absolute time and price so the renderer
+// can place it without knowing which bar it came from.
+struct Gap {
+    int64_t time_ms = 0;    // open time of the middle bar
+    double  top = 0.0;      // upper price edge
+    double  bottom = 0.0;   // lower price edge
+    bool    bullish = false;
+    int64_t filled_ms = 0;  // open time of the bar that filled it; 0 = unfilled
+    // Open time of the bar that reclaimed the zone after it inverted; 0 while
+    // the inversion still stands. Only meaningful once filled_ms is set.
+    int64_t invalidated_ms = 0;
+};
+
+// Which price settles that a gap has been traded back through.
+enum FillType : int {
+    kFillClose = 0,  // a candle must close past the far edge
+    kFillWick = 1,   // a high or low reaching through is enough
+};
+
+// Detects the gaps in the last `max_bars_back` bars of [candles, candles+n),
+// oldest first, and resolves each one's fill.
+//
+// A gap sits around the middle bar of a three-candle run whose outer wicks miss
+// each other: bullish when candles[i-1].high < candles[i+1].low (spanning that
+// range), bearish when candles[i-1].low > candles[i+1].high. `wait_for_close`
+// withholds a gap whose third candle is still the newest, live bar.
+//
+// The fill scan walks forward from i+2 and records the first bar to reach the
+// far edge — the bottom of a bullish gap, the top of a bearish one.
+//
+// Closing through a gap inverts it: the band price just rejected becomes a
+// zone of the opposite polarity, resistance overhead where a bullish gap was
+// and support underfoot where a bearish one was. A second scan resumes after
+// the fill and records the bar that reclaims the band the other way, ending
+// the inversion. Both scans always run, so whether a filled or inverted box is
+// drawn at all stays a drawing concern.
+void compute(const ::VroomCandle* candles, std::size_t n, int max_bars_back,
+             bool wait_for_close, int fill_type, std::vector<Gap>& out);
+
+}  // namespace vroom::fvg

package/cpp/_core_src/fvg_overlay.cpp

@@ -0,0 +1,262 @@
+#include "fvg_overlay.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRect.h"
+#include "include/effects/SkDashPathEffect.h"
+#pragma clang diagnostic pop
+
+#include "chart.h"
+#include "fonts.h"
+
+namespace vroom::fvg_overlay {
+
+namespace {
+
+constexpr SkScalar kDotted[2] = {2.f, 2.f};
+constexpr SkScalar kDashed[2] = {6.f, 4.f};
+constexpr float kLabelPadX = 4.f;  // clearance between a label and a box edge
+
+// Dash pattern for a VroomFairValueGaps::border_style. Null = solid.
+sk_sp<SkPathEffect> dash_for(int32_t border_style) {
+    if (border_style == 1) return SkDashPathEffect::Make(kDotted, 0.f);
+    if (border_style == 2) return SkDashPathEffect::Make(kDashed, 0.f);
+    return nullptr;
+}
+
+// A stretch of time one box covers. A gap draws one of these while it is open
+// and, under show_inverse, a second of the opposite polarity once it has been
+// violated.
+struct Span {
+    int64_t start_ms;
+    int64_t end_ms;
+    bool bullish;  // polarity of THIS span, already flipped for an inverse
+    bool inverse;
+    bool open;     // still running at the newest bar rather than cut short
+};
+
+// The spans `g` draws, written to `out` oldest first, returning how many. Zero
+// when the gap is set to disappear on the fill and has no inversion to show.
+std::size_t spans_for(const VroomChart& chart,
+                      const vroom::fvg::Gap& g,
+                      std::array<Span, 2>& out) {
+    const VroomFairValueGaps& cfg = chart.fvg;
+    const int64_t dur = chart.candle_duration_ms;
+    const int64_t newest_end = chart.candles.back().time_ms + dur;
+    const int64_t length = static_cast<int64_t>(cfg.box_length) * dur;
+    std::size_t n = 0;
+
+    // The original. It runs its configured length, or — when extended — to the
+    // end of the newest bar, and stops at the far side of the bar that filled
+    // it, so the shading covers exactly the span the gap was open for.
+    if (g.filled_ms == 0 || !cfg.delete_after_fill) {
+        int64_t end = cfg.extend_boxes ? newest_end : g.time_ms + length;
+        const bool open = g.filled_ms == 0;
+        if (!open) end = std::min(end, g.filled_ms + dur);
+        if (end > g.time_ms) out[n++] = Span{g.time_ms, end, g.bullish, false, open};
+    }
+
+    // The inversion, anchored past the close of the breaking bar so it picks up
+    // exactly where the original stops and the two never overlap. It measures
+    // its own length from there and ends where price reclaimed the band.
+    if (cfg.show_inverse && g.filled_ms != 0) {
+        const int64_t start = g.filled_ms + dur;
+        int64_t end = cfg.extend_boxes ? newest_end : start + length;
+        const bool open = g.invalidated_ms == 0;
+        if (!open) end = std::min(end, g.invalidated_ms + dur);
+        if (end > start) out[n++] = Span{start, end, !g.bullish, true, open};
+    }
+    return n;
+}
+
+// One span resolved to pixels, or false when it lands entirely off to one side.
+bool box_for(const VroomChart& chart,
+             const vroom::Layout& lay,
+             const vroom::PriceBounds& bounds,
+             int64_t window_ms,
+             float candle_right,
+             const vroom::fvg::Gap& g,
+             const Span& s,
+             SkRect* out) {
+    const float left =
+        vroom::x_at_time(lay, chart.visible_start_ms, window_ms, s.start_ms);
+    const float right =
+        vroom::x_at_time(lay, chart.visible_start_ms, window_ms, s.end_ms);
+    if (right < 0.f || left > candle_right) return false;
+
+    *out = SkRect::MakeLTRB(left, vroom::price_to_y(lay, bounds, g.top), right,
+                            vroom::price_to_y(lay, bounds, g.bottom));
+    return true;
+}
+
+// The fill color a span shades with, before opacity.
+SkColor fill_color(const VroomFairValueGaps& cfg, const Span& s) {
+    if (s.inverse) {
+        return s.bullish ? cfg.inverse_bullish_color : cfg.inverse_bearish_color;
+    }
+    return s.bullish ? cfg.bullish_color : cfg.bearish_color;
+}
+
+// The color a span's border and label take. Inverse spans have no paired border
+// color of their own, so they reuse their fill at full alpha — the same
+// relationship bullishBorderColor already has with bullishColor by default.
+SkColor line_color(const VroomFairValueGaps& cfg, const Span& s) {
+    if (s.inverse) return SkColorSetA(fill_color(cfg, s), 0xff);
+    return s.bullish ? cfg.bullish_border_color : cfg.bearish_border_color;
+}
+
+// Whether there is anything at all to draw, and the cache is safe to walk.
+bool active(const VroomChart& chart, SkCanvas* canvas, float candle_right,
+            float candle_area_h) {
+    return canvas && candle_right > 0.f && candle_area_h > 0.f &&
+           chart.fvg.enabled && !chart.candles.empty() &&
+           !chart.fvg_cache.empty();
+}
+
+SkColor with_opacity(SkColor c, float opacity) {
+    return SkColorSetA(c, static_cast<U8CPU>(SkColorGetA(c) * opacity));
+}
+
+}  // namespace
+
+void draw_boxes(SkCanvas* canvas,
+                const VroomChart& chart,
+                const Layout& lay,
+                const PriceBounds& bounds,
+                int64_t window_ms,
+                float candle_right,
+                float candle_area_h) {
+    if (!active(chart, canvas, candle_right, candle_area_h)) return;
+    const VroomFairValueGaps& cfg = chart.fvg;
+
+    SkPaint fill;
+    fill.setAntiAlias(true);
+    fill.setStyle(SkPaint::kFill_Style);
+
+    SkPaint border;
+    border.setAntiAlias(true);
+    border.setStyle(SkPaint::kStroke_Style);
+    border.setStrokeWidth(cfg.border_width > 0.f ? cfg.border_width : 1.f);
+    border.setPathEffect(dash_for(cfg.border_style));
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    std::array<Span, 2> spans;
+    for (const vroom::fvg::Gap& g : chart.fvg_cache) {
+        const std::size_t n = spans_for(chart, g, spans);
+        for (std::size_t i = 0; i < n; ++i) {
+            SkRect rect;
+            if (!box_for(chart, lay, bounds, window_ms, candle_right, g, spans[i],
+                         &rect)) {
+                continue;
+            }
+
+            fill.setColor(with_opacity(fill_color(cfg, spans[i]), cfg.opacity));
+            canvas->drawRect(rect, fill);
+
+            if (cfg.border_enabled) {
+                border.setColor(line_color(cfg, spans[i]));
+                canvas->drawRect(rect, border);
+            }
+        }
+    }
+    canvas->restore();
+}
+
+void draw_labels(SkCanvas* canvas,
+                 const VroomChart& chart,
+                 const Layout& lay,
+                 const PriceBounds& bounds,
+                 int64_t window_ms,
+                 float candle_right,
+                 float candle_area_h) {
+    if (!active(chart, canvas, candle_right, candle_area_h)) return;
+    const VroomFairValueGaps& cfg = chart.fvg;
+    const bool any_inverse = cfg.show_inverse && !chart.fvg_inverse_label.empty();
+    if (!cfg.labels_enabled || (chart.fvg_label.empty() && !any_inverse)) return;
+
+    auto tf = vroom::axis_typeface();
+    if (!tf) return;
+    const float size = cfg.label_font_size > 0.f
+                           ? cfg.label_font_size
+                           : chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX];
+    SkFont font(tf, size);
+    font.setSubpixel(true);
+    font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+
+    // Indexed by Span::inverse, so a span picks its own text and metrics.
+    struct Label {
+        const std::string* text;
+        float width;
+        SkRect bounds;
+    };
+    Label labels[2] = {{&chart.fvg_label, 0.f, {}},
+                       {&chart.fvg_inverse_label, 0.f, {}}};
+    for (Label& l : labels) {
+        l.width = font.measureText(l.text->data(), l.text->size(),
+                                   SkTextEncoding::kUTF8, &l.bounds);
+    }
+
+    // Extended boxes all stop at the newest bar, so their labels go out into the
+    // empty slots past it rather than on top of the shading.
+    const float extend_x =
+        cfg.extend_boxes
+            ? vroom::x_at_time(lay, chart.visible_start_ms, window_ms,
+                               chart.candles.back().time_ms +
+                                   static_cast<int64_t>(cfg.label_distance + 1) *
+                                       chart.candle_duration_ms)
+            : 0.f;
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+    std::array<Span, 2> spans;
+    for (const vroom::fvg::Gap& g : chart.fvg_cache) {
+        const std::size_t n = spans_for(chart, g, spans);
+        for (std::size_t i = 0; i < n; ++i) {
+            const Span& s = spans[i];
+            const Label& l = labels[s.inverse ? 1 : 0];
+            if (l.text->empty()) continue;
+
+            SkRect rect;
+            if (!box_for(chart, lay, bounds, window_ms, candle_right, g, s,
+                         &rect)) {
+                continue;
+            }
+
+            // A box that was cut short stops early even under extend, so it
+            // keeps its label inside; only boxes still running to the newest
+            // bar move theirs out — and only while the pane has the room, since
+            // the newest candle sits flush right until the user pans.
+            const bool outside = cfg.extend_boxes && s.open &&
+                                 extend_x + l.width <= candle_right;
+            // A box whose right end runs past the pane would have its label
+            // sliced mid-glyph by the clip, so hold the text inside the plot.
+            const float x =
+                std::min(outside ? extend_x : rect.right() - kLabelPadX - l.width,
+                         candle_right - kLabelPadX - l.width);
+            if (x + l.width < 0.f) continue;
+
+            paint.setColor(SkColorGetA(cfg.label_color) != 0 ? cfg.label_color
+                                                             : line_color(cfg, s));
+            canvas->drawString(
+                l.text->c_str(), x,
+                rect.centerY() - (l.bounds.fTop + l.bounds.fBottom) * 0.5f, font,
+                paint);
+        }
+    }
+    canvas->restore();
+}
+
+}  // namespace vroom::fvg_overlay

package/cpp/_core_src/fvg_overlay.h

@@ -0,0 +1,43 @@
+// Fair Value Gap boxes — the drawing half of the indicator, kept out of the
+// chart orchestrator the way liquidity / drawings are. Detection lives in the
+// Skia-free fair_value_gaps.{h,cpp}; this reads the cache it fills.
+//
+// Each gap becomes an axis-aligned rectangle spanning its untouched price range
+// and running right from the middle bar. Split across two passes because they
+// sit at different depths: the boxes go BEHIND the candles so bodies paint over
+// them, the labels go in FRONT so they stay readable.
+
+#pragma once
+
+#include <cstdint>
+
+#include "viewport.h"
+
+class SkCanvas;
+struct VroomChart;
+
+namespace vroom::fvg_overlay {
+
+// Draws the box fills and their outlines. `candle_right` is the x of the
+// price-axis strip and `candle_area_h` the price-pane bottom; geometry is
+// clipped to that rectangle so a box never bleeds into the axis strips.
+void draw_boxes(SkCanvas* canvas,
+                const VroomChart& chart,
+                const vroom::Layout& lay,
+                const vroom::PriceBounds& bounds,
+                int64_t window_ms,
+                float candle_right,
+                float candle_area_h);
+
+// Draws each box's label: inside its right end normally, or out in the empty
+// slots past the newest candle when the boxes are extended. No-op while no
+// typeface is loaded.
+void draw_labels(SkCanvas* canvas,
+                 const VroomChart& chart,
+                 const vroom::Layout& lay,
+                 const vroom::PriceBounds& bounds,
+                 int64_t window_ms,
+                 float candle_right,
+                 float candle_area_h);
+
+}  // namespace vroom::fvg_overlay

package/cpp/_core_src/ichimoku.cpp

@@ -0,0 +1,65 @@
+#include "ichimoku.h"
+
+#include <algorithm>  // std::max, std::min
+#include <cmath>      // std::nan
+
+namespace vroom::ichimoku {
+namespace {
+
+// Midpoint of the high/low range over each trailing `period`-bar window — the
+// shape all three of Ichimoku's averaged lines share. NaN over the warmup.
+void midpoint_series(const ::VroomCandle* candles, std::size_t n, int period,
+                     std::vector<double>& out) {
+    out.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    for (std::size_t i = P - 1; i < n; ++i) {
+        const std::size_t s = i + 1 - P;
+        double hi = candles[s].high;
+        double lo = candles[s].low;
+        for (std::size_t j = s + 1; j <= i; ++j) {
+            hi = std::max(hi, candles[j].high);
+            lo = std::min(lo, candles[j].low);
+        }
+        out[i] = (hi + lo) * 0.5;
+    }
+}
+
+}  // namespace
+
+void compute(const ::VroomCandle* candles, std::size_t n, int tenkan_period,
+             int kijun_period, int senkou_b_period,
+             std::vector<double>& tenkan, std::vector<double>& kijun,
+             std::vector<double>& senkou_a, std::vector<double>& senkou_b,
+             std::vector<double>& chikou) {
+    midpoint_series(candles, n, tenkan_period, tenkan);
+    midpoint_series(candles, n, kijun_period, kijun);
+    midpoint_series(candles, n, senkou_b_period, senkou_b);
+
+    // NaN propagates through the average, so span A is only defined once both
+    // of its inputs are — no separate warmup bound to track.
+    senkou_a.assign(n, std::nan(""));
+    for (std::size_t i = 0; i < n; ++i) {
+        senkou_a[i] = (tenkan[i] + kijun[i]) * 0.5;
+    }
+
+    chikou.assign(n, std::nan(""));
+    if (!candles) return;
+    for (std::size_t i = 0; i < n; ++i) chikou[i] = candles[i].close;
+}
+
+IndexRange shifted_source_range(const ::VroomCandle* candles, std::size_t n,
+                                int64_t start_ms, int64_t end_ms,
+                                int64_t shift_ms) {
+    // 0/0 is visible_indices' "everything" sentinel (an unframed viewport).
+    // Shifting it would turn that into an empty range, so pass it through.
+    if (start_ms == 0 && end_ms == 0) {
+        return vroom::visible_indices(candles, n, 0, 0);
+    }
+    return vroom::visible_indices(candles, n, start_ms - shift_ms,
+                                  end_ms - shift_ms);
+}
+
+}  // namespace vroom::ichimoku

package/cpp/_core_src/ichimoku.h

@@ -0,0 +1,45 @@
+// Ichimoku Kinko Hyo over a candle series — pure, no Skia, so it builds into
+// the unit-test target. Drawn as five price-pane overlay lines plus the cloud
+// shaded between the two leading spans.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "viewport.h"           // vroom::IndexRange
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::ichimoku {
+
+// Computes the five Ichimoku series over [candles, candles+n). Each period is
+// clamped to >= 1.
+//
+//   tenkan   = midpoint of the high/low range over the trailing tenkan window
+//   kijun    = same over the trailing kijun window
+//   senkou_a = (tenkan + kijun) / 2
+//   senkou_b = midpoint of the high/low range over the trailing senkou_b window
+//   chikou   = close
+//
+// Every output is resized to n and indexed by the bar it was computed from —
+// displacement is a drawing concern, so senkou_a/senkou_b/chikou are *not*
+// shifted here. Values are NaN over each series' warmup and when n is shorter
+// than the window a series needs.
+void compute(const ::VroomCandle* candles, std::size_t n, int tenkan_period,
+             int kijun_period, int senkou_b_period,
+             std::vector<double>& tenkan, std::vector<double>& kijun,
+             std::vector<double>& senkou_a, std::vector<double>& senkou_b,
+             std::vector<double>& chikou);
+
+// Source indices whose *shifted* plot time lands in [start_ms, end_ms], for a
+// series drawn at `candles[i].time_ms + shift_ms`.
+//
+// Shifting the query window back by the same amount is what lets the leading
+// spans run past the newest candle: the range is found among bars that exist,
+// while the x each one draws at does not have to.
+IndexRange shifted_source_range(const ::VroomCandle* candles, std::size_t n,
+                                int64_t start_ms, int64_t end_ms,
+                                int64_t shift_ms);
+
+}  // namespace vroom::ichimoku

package/cpp/_core_src/labels.cpp

@@ -74,6 +74,9 @@ void apply_envelope(std::vector<Fade>& fades, float opacity) {
 
 IntervalPhase interval_phase(const VroomChart& chart) {
     if (chart.morph_from.empty() || chart.interval_morph_t >= 1.f) return {};
+    // A live update keeps the same interval, so its ticks are still the right
+    // ones — they stay put and keep their own per-label fades.
+    if (chart.morph_is_stream) return {};
     const float t = chart.interval_morph_t;
     constexpr float kMid = 0.5f;
     if (t < kMid) return {true, true, 1.f - t / kMid};

package/cpp/_core_src/line_morph.h

@@ -0,0 +1,159 @@
+// Interval-morph capture for indicator series — the line-shaped counterpart to
+// viewport.h's CandleSnapshot. Pure geometry, no Skia, so it builds into the
+// unit-test target.
+//
+// A timeframe switch replaces every indicator cache at once (see
+// vroom_chart_set_candles), so an outgoing shape has to be captured before the
+// swap if it is going to reshape into the new one. Captures normalize the same
+// way the candle one does — x as a fraction of the candle-area width, y as a
+// fraction of the band the series was drawn in — which keeps them correct
+// across a mid-morph resize, across the y-axis rescale the switch brings, and,
+// for the indicator panes, across a change in the pane's own auto-fit.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomOverlay
+
+namespace vroom {
+
+// Which series a capture belongs to. Pairing is by identity rather than
+// position so an indicator toggled in the same commit as the timeframe can't
+// reshape one line out of another's geometry.
+enum class LineKind : uint8_t {
+    Overlay,
+    Vwap,
+    BollingerUpper,
+    BollingerMiddle,
+    BollingerLower,
+    IchimokuTenkan,
+    IchimokuKijun,
+    IchimokuSenkouA,
+    IchimokuSenkouB,
+    IchimokuChikou,
+    Rsi,
+    RsiMa,
+    Macd,
+    MacdSignal,
+    MacdHistogram,
+    Atr,
+};
+
+// Identifies one captured series. The moving-average overlays are a
+// user-ordered vector rather than a fixed slot, so `index` alone would pair two
+// different MAs if one were added or removed during the switch; `tag` carries
+// the overlay's kind, period and source, so a mismatch finds no capture and the
+// line simply snaps. Both are 0 for every other series.
+struct LineKey {
+    LineKind kind;
+    int32_t  index = 0;
+    int32_t  tag = 0;
+};
+
+inline bool operator==(const LineKey& a, const LineKey& b) {
+    return a.kind == b.kind && a.index == b.index && a.tag == b.tag;
+}
+
+// The key for the moving-average overlay at `index`, packing its kind, source
+// and period into the tag. Periods above 65535 alias, which no usable lookback
+// reaches.
+inline LineKey overlay_line_key(const ::VroomOverlay& ov, std::size_t index) {
+    const int32_t tag =
+        (ov.kind << 24) ^ (ov.source << 16) ^ (ov.period & 0xffff);
+    return LineKey{LineKind::Overlay, static_cast<int32_t>(index), tag};
+}
+
+// One captured vertex. `x` is a fraction of the candle-area width and `y` a
+// fraction of the band the series was drawn in (0 = bottom edge, 1 = top).
+// `valid` is false where the source value was NaN, which is how a warmup gap
+// survives the capture.
+struct LineSnapshot {
+    float x = 0.f;
+    float y = 0.f;
+    bool  valid = false;
+};
+
+// One captured series. Slot 0 is the newest vertex, matching the right-edge
+// indexing candles::draw pairs on. `scale` is the auto-fit its pane band was
+// sized to at capture time, which the pane's axis label reads back mid-morph;
+// 0 for series on the price scale, whose band is the price bounds.
+struct LineMorph {
+    LineKey key{LineKind::Overlay};
+    double  scale = 0.0;
+    std::vector<LineSnapshot> pts;
+};
+
+// The capture for `key`, or null when nothing matching was captured — which is
+// what an indicator enabled mid-morph gets, so it draws its new shape directly
+// instead of reshaping out of geometry that was never on screen.
+inline const LineMorph* find_line_morph(const std::vector<LineMorph>& lines,
+                                        const LineKey& key) {
+    for (const LineMorph& line : lines) {
+        if (line.key == key) return &line;
+    }
+    return nullptr;
+}
+
+// How many captured slots still contribute to a frame, mirroring
+// morph_from_count: 0 once the morph lands, which collapses the draw path back
+// to the new series alone. Drawing routines take max(n, this) as their slot
+// count, pairing the new vertex at slot k with the captured one at pts[k].
+inline std::size_t morph_line_count(const LineMorph* from, float morph_t) {
+    return (from && morph_t < 1.f) ? from->pts.size() : 0;
+}
+
+// One slot resolved to screen pixels. `valid` false means neither side defined
+// the slot, and the polyline lifts its pen there.
+struct MorphVertex {
+    float x = 0.f;
+    float y = 0.f;
+    bool  valid = false;
+};
+
+// Blends a slot's captured position toward its new one. Both sides arrive in
+// pixels: the caller converts the capture's fractions through whichever band
+// the series lives in, which is the only part that differs between a price-pane
+// overlay and an indicator pane.
+//
+// A slot only one side defines holds that side's position rather than lifting
+// the pen. The warmup gap at a line's left end spans a different amount of time
+// at each resolution, and sliding that end reads far better than blinking it.
+inline MorphVertex morph_vertex(const MorphVertex& to, const MorphVertex& from,
+                                float morph_t) {
+    if (!to.valid) return from;
+    if (!from.valid) return to;
+    return MorphVertex{from.x + (to.x - from.x) * morph_t,
+                       from.y + (to.y - from.y) * morph_t, true};
+}
+
+// The line counterpart to viewport.h's blend_candle_snapshots: rewrites a fresh
+// capture to start from the shape on screen, so a live tick restarting the
+// morph doesn't snap the indicators back off the candles they sit on.
+//
+// Series are matched by key, so one enabled or removed between two ticks simply
+// finds no counterpart and keeps its fresh capture. A slot only one side
+// defines keeps that side, mirroring morph_vertex — the warmup gap can move by
+// a slot as bars arrive, and sliding that end reads better than blinking it.
+inline void blend_line_morphs(std::vector<LineMorph>& dst,
+                              const std::vector<LineMorph>& interrupted,
+                              float morph_t) {
+    for (LineMorph& to : dst) {
+        const LineMorph* from = find_line_morph(interrupted, to.key);
+        if (!from) continue;
+        to.scale = from->scale + (to.scale - from->scale) * morph_t;
+        const std::size_t n =
+            to.pts.size() < from->pts.size() ? to.pts.size() : from->pts.size();
+        for (std::size_t k = 0; k < n; ++k) {
+            const LineSnapshot& a = from->pts[k];
+            LineSnapshot& b = to.pts[k];
+            if (!a.valid || !b.valid) continue;
+            b.x = a.x + (b.x - a.x) * morph_t;
+            b.y = a.y + (b.y - a.y) * morph_t;
+        }
+    }
+}
+
+}  // namespace vroom