react-native-vroom-chart 0.8.0 → 0.9.0

package/cpp/_core_include/vroom/vroom_chart.h

@@ -294,6 +294,9 @@ typedef enum {
     VROOM_FLOAT_VOLUME_RADIUS_PX,        // volume bar top-corner radius px (0 = square)
     VROOM_FLOAT_LINE_WIDTH_PX,           // line-chart-mode polyline stroke width px
     VROOM_FLOAT_LINE_GRADIENT_OPACITY,   // fill under the line at its strongest (0 disables)
+    VROOM_FLOAT_LINE_TENSION,            // 0..1 line-chart corner smoothing (0 = straight)
+    VROOM_FLOAT_LINE_TIP_DOT,            // 0/1: dot at the line's newest end (default on)
+    VROOM_FLOAT_LINE_TIP_PULSE,          // 0/1: expanding ring around that dot
     VROOM_FLOAT_COUNT_
 } VroomFloatKey;
 

package/cpp/_core_src/chart.cpp

@@ -9,6 +9,8 @@
 
 #include "chart.h"
 
+#include <cmath>
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 #include "include/core/SkCanvas.h"
@@ -34,6 +36,7 @@
 #include "rsi.h"
 #include "rsi_pane.h"
 #include "style_inherit.h"
+#include "tip_pulse.h"
 #include "volume.h"
 #include "vwap.h"
 #include "theme.h"
@@ -191,7 +194,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE],
             theme.floats[VROOM_FLOAT_LINE_GRADIENT_OPACITY],
-            fade, morph_src, morph_n, morph_t);
+            fade, morph_src, morph_n, morph_t,
+            theme.floats[VROOM_FLOAT_LINE_TENSION]);
     }
 
     // 4.5. Volume bars — drawn under the candles so candles z-index above.
@@ -239,7 +243,8 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
             canvas, lay, bounds, visible, n, window_ms,
             visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE], theme.floats[VROOM_FLOAT_LINE_WIDTH_PX],
-            fade, morph_src, morph_n, morph_t);
+            fade, morph_src, morph_n, morph_t,
+            theme.floats[VROOM_FLOAT_LINE_TENSION]);
     }
 
     // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
@@ -303,6 +308,21 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
                           candle_area_h);
 
+    // 5.8. Line-mode tip marker — the dot (and optional pulse) at the newest
+    //      close. Above the overlays so it stays the eye's anchor, but before the
+    //      axis masks, which trim the ring at the price scale.
+    if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+        vroom::ma_overlay::draw_close_tip(
+            canvas, lay, bounds, visible, n, 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,
+            morph_src, morph_n, 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.
@@ -422,6 +442,17 @@ void VroomChart::begin_frame() {
     last_anim_tick = now;
     anim_started = true;
     last_dt_seconds = dt;
+
+    // Wrapped rather than accumulated: the phase is the only thing anyone reads,
+    // 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);
+}
+
+bool VroomChart::tip_pulse_active() const {
+    return morph_fade > 0.f && !candles.empty() &&
+           theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f &&
+           theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f;
 }
 
 void VroomChart::rebuild_chart_picture() {
@@ -433,6 +464,9 @@ void VroomChart::rebuild_chart_picture() {
 }
 
 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;
     for (const auto& f : y_fades) {
         if (f.opacity != f.target) return true;
     }

package/cpp/_core_src/chart.h

@@ -64,6 +64,12 @@ struct VroomChart {
     float morph_collapse = 0.f;
     float morph_fade = 0.f;
 
+    // Phase of the line-tip pulse, in seconds into its cycle. Unlike every other
+    // animation here this one is core-driven: it loops with no endpoint for the
+    // host to ease toward, so begin_frame advances it from the frame clock and
+    // is_animating_now keeps the host's redraw loop alive (see tip_pulse.h).
+    float tip_pulse_elapsed_s = 0.f;
+
     // Interval morph: the outgoing candle geometry captured when a timeframe
     // switch begins, indexed from the right of the visible slice (slot 0 =
     // newest) — the pairing the preserved slot grid guarantees. Stored as
@@ -307,14 +313,20 @@ struct VroomChart {
     void draw_chart(SkCanvas* canvas);
 
     // Per-frame animation bookkeeping: computes `last_dt_seconds`, which paces
-    // the label fades. Called at the top of draw_chart.
+    // the label fades, and advances `tip_pulse_elapsed_s`. Called at the top of
+    // draw_chart.
     void begin_frame();
 
+    // True when the line tip's pulse ring is on screen and looping. Gated on
+    // line mode and on having data, so a chart that isn't showing the ring can
+    // still go idle.
+    bool tip_pulse_active() const;
+
     // Re-records `chart_picture` by invoking draw_chart on a fresh
     // SkPictureRecorder.
     void rebuild_chart_picture();
 
-    // True if any axis label is mid-fade. Used by the JS-side animation loop
-    // to know when to keep ticking.
+    // True if any axis label is mid-fade, or the tip pulse is running. Used by
+    // the JS-side animation loop to know when to keep ticking.
     bool is_animating_now() const;
 };

package/cpp/_core_src/chart_facade.cpp

@@ -32,6 +32,17 @@ constexpr double kAxisDragSensitivity = 300.0;
 constexpr double kMinCandleBodyPx = 1.5;
 constexpr double kMaxCandleBodyPx = 32.0;
 
+// Trailing gap the default framing leaves between the newest candle and the
+// price axis. The newest bar flush against the axis reads as cramped, and in line
+// mode the tip marker's pulse needs somewhere to expand into — the axis mask
+// (draw_chart step 6) paints over the gutter, so clearance has to come from the
+// time window rather than from right_padding_px.
+//
+// A gap this small is far under the 3/4-window cap, so it neither triggers the
+// pan rubber-band nor gets clamped away; a timeframe switch carries it over in
+// slots (see timeframeWindow in the hosts), which preserves it in pixels.
+constexpr double kRightGapPx = 12.0;
+
 // Hard cap on the future gap (visible_end - last_candle): 3/4 of the window so
 // at least 25% of the chart still shows candles. Never forces an existing larger
 // gap (e.g. from the x-axis drag zoom) to snap back — only limits new growth.
@@ -70,14 +81,29 @@ void apply_default_framing(VroomChart* chart) {
     const int64_t right_edge_ms =
         chart->candles.back().time_ms + chart->candle_duration_ms;
 
+    const auto lay = chart->layout();
+    const double usable =
+        lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
+
+    // Places a window of the given width with kRightGapPx of air past the newest
+    // candle. Shifts the window forward rather than widening it, so the framing
+    // keeps whatever candle width it just computed. Falls back to a flush right
+    // edge when the layout isn't measured yet and px can't be converted to time.
+    const auto frame = [&](int64_t window_ms) {
+        const int64_t gap_ms =
+            usable > 0.0 && window_ms > 0
+                ? static_cast<int64_t>((kRightGapPx * static_cast<double>(window_ms)) /
+                                       usable)
+                : 0;
+        chart->visible_end_ms = right_edge_ms + gap_ms;
+        chart->visible_start_ms = chart->visible_end_ms - window_ms;
+    };
+
     // Px-driven framing. Reuses the inversion from vroom_chart_scale_time_axis:
     // body_w = usable × (dur / window) × ratio  →  window = usable × dur × ratio / body_w.
     // Needs a valid layout (width_px); until size is known it falls through to
     // the candle-count default below.
     if (chart->default_candle_px > 0.f) {
-        const auto lay = chart->layout();
-        const double usable =
-            lay.width_px - lay.y_axis_width_px - lay.right_padding_px;
         const double ratio = chart->theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO];
         const double dur = static_cast<double>(chart->candle_duration_ms);
         const double body = std::clamp(static_cast<double>(chart->default_candle_px),
@@ -88,8 +114,7 @@ void apply_default_framing(VroomChart* chart) {
                 chart->candles.back().time_ms - chart->candles.front().time_ms;
             window_ms = std::clamp<int64_t>(window_ms, chart->candle_duration_ms,
                                             span > 0 ? span : window_ms);
-            chart->visible_end_ms = right_edge_ms;
-            chart->visible_start_ms = chart->visible_end_ms - window_ms;
+            frame(window_ms);
             return;
         }
     }
@@ -98,8 +123,7 @@ void apply_default_framing(VroomChart* chart) {
     const size_t start_idx = chart->candles.size() > kDefaultVisible
         ? chart->candles.size() - kDefaultVisible
         : 0;
-    chart->visible_start_ms = chart->candles[start_idx].time_ms;
-    chart->visible_end_ms = right_edge_ms;
+    frame(right_edge_ms - chart->candles[start_idx].time_ms);
 }
 
 // On the first manual-y gesture, adopt the on-screen auto-fit bounds so the

package/cpp/_core_src/curve.h

@@ -0,0 +1,67 @@
+// Monotone cubic interpolation — the math behind the line chart's optional
+// corner smoothing (VROOM_FLOAT_LINE_TENSION).
+//
+// Deliberately monotone (Fritsch-Carlson) rather than a plain Catmull-Rom or
+// cardinal spline. An unconstrained spline through the closes overshoots on a
+// sharp reversal, and on a price chart that isn't just ugly — the curve dips
+// below the period's low and draws a price that never traded, next to candles
+// that show the real one during the candle-to-line crossfade. Limiting the
+// tangents keeps every local extreme on an actual data point.
+//
+// Skia-free and header-only so the unit tests can cover it (see
+// tests/test_curve.cpp); ma_overlay.cpp owns the walk and the path emission.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::curve {
+
+// The two interior control points of a cubic Bezier segment, in whatever space
+// the endpoints were given in (pixels, at every call site here).
+struct Controls {
+    float c1x, c1y;
+    float c2x, c2y;
+};
+
+// Slope of the straight line between two points. Non-increasing x yields 0,
+// which keeps a degenerate span (duplicate timestamps, or the compressed
+// spacing an interval morph can pass through) from producing infinities.
+inline float secant(float x0, float y0, float x1, float y1) {
+    const float h = x1 - x0;
+    return h > 0.f ? (y1 - y0) / h : 0.f;
+}
+
+// Tangent at a point with neighboring secants `d_prev` and `d_next`.
+inline float monotone_tangent(float d_prev, float d_next) {
+    // Opposite signs (or a flat neighbor) mean this point is a local extreme.
+    // A zero tangent is what pins the curve to it instead of sailing past.
+    if (d_prev * d_next <= 0.f) return 0.f;
+    // Fritsch-Carlson: holding the tangent within three times the smaller
+    // neighboring secant is what makes each segment monotone, and is also why
+    // the control points below can never leave the endpoints' y range.
+    const float limit = 3.f * std::min(std::fabs(d_prev), std::fabs(d_next));
+    return std::clamp((d_prev + d_next) * 0.5f, -limit, limit);
+}
+
+// Control points for the segment p0 -> p1, given the tangents chosen for each
+// endpoint and how far to lean into them.
+//
+// `tension` 0 puts both tangents back on the segment's own secant, which lands
+// the controls exactly on its thirds — the cubic *is* the straight line. So the
+// knob is continuous at zero rather than snapping into a curve, and callers can
+// interpolate it without a visible discontinuity.
+inline Controls segment_controls(float x0, float y0,
+                                 float x1, float y1,
+                                 float m0, float m1,
+                                 float tension) {
+    const float d = secant(x0, y0, x1, y1);
+    const float a = d + (m0 - d) * tension;
+    const float b = d + (m1 - d) * tension;
+    const float third = (x1 - x0) / 3.f;
+    return Controls{x0 + third, y0 + a * third,
+                    x1 - third, y1 - b * third};
+}
+
+}  // namespace vroom::curve

package/cpp/_core_src/ma_overlay.cpp

@@ -14,8 +14,11 @@
 
 #include <algorithm>
 #include <cmath>
+#include <vector>
 
+#include "curve.h"
 #include "gradient.h"
+#include "tip_pulse.h"
 #include "viewport.h"
 
 namespace vroom::ma_overlay {
@@ -48,6 +51,48 @@ void stroke_path(SkCanvas* canvas,
 
 inline float lerp(float a, float b, float t) { return a + (b - a) * t; }
 
+// Width of the background-colored ring that separates the tip dot from the line
+// and from the pulse expanding out behind it.
+constexpr float kTipBorderPx = 2.f;
+
+// One vertex of the close polyline, in screen space. Slot `k` counts back from
+// the right edge (0 = the newest close), the pairing a timeframe switch
+// preserves.
+//
+// Shared by the path builder and the tip marker: the dot has to sit on the exact
+// pixel the line ends at, including mid-interval-morph where both coordinates
+// are interpolated against the outgoing capture.
+SkPoint close_vertex(const Layout& lay,
+                     const PriceBounds& bounds,
+                     const ::VroomCandle* visible,
+                     std::size_t n,
+                     int64_t window_ms,
+                     int64_t visible_start_ms,
+                     int64_t candle_duration_ms,
+                     const CandleSnapshot* from,
+                     std::size_t from_count,
+                     float morph_t,
+                     std::size_t k) {
+    const ::VroomCandle* to = (k < n) ? &visible[n - 1 - k] : nullptr;
+    const CandleSnapshot* frm = (k < from_count) ? &from[k] : nullptr;
+    if (to) {
+        const float tx = vroom::candle_center_x(
+            lay, to->time_ms, candle_duration_ms, visible_start_ms, window_ms);
+        const float ty = vroom::price_to_y(lay, bounds, to->close);
+        if (!frm) return SkPoint{tx, ty};
+        // The capture is in band fractions, so it lands on the same pixels it
+        // occupied pre-switch even though the bounds changed.
+        const float area_w = vroom::candle_area_width(lay);
+        return SkPoint{
+            lerp(frm->x * area_w, tx, morph_t),
+            lerp(vroom::y_at_fraction(lay, frm->close), ty, morph_t)};
+    }
+    // A slot only the outgoing data had. Counts match in practice, so this just
+    // keeps gappy or short-history data from breaking the line.
+    return SkPoint{frm->x * vroom::candle_area_width(lay),
+                   vroom::y_at_fraction(lay, frm->close)};
+}
+
 // The close-price polyline, walked left to right. Shared by the stroke and the
 // gradient fill so both derive from identical geometry, mid-morph included.
 //
@@ -55,6 +100,10 @@ inline float lerp(float a, float b, float t) { return a + (b - a) * t; }
 // timeframe switch preserves — which walks the line left to right, so the vertex
 // order matches draw()'s at morph_t == 1. Every candle has a close, so there are
 // no gaps to break the subpath on.
+//
+// `tension` above 0 rounds the corners (see curve.h). It smooths the *screen*
+// positions rather than the closes, which is what keeps the line glued to the
+// candles mid-interval-morph, where those positions are themselves interpolated.
 SkPath build_close_path(const Layout& lay,
                         const PriceBounds& bounds,
                         const ::VroomCandle* visible,
@@ -64,45 +113,72 @@ SkPath build_close_path(const Layout& lay,
                         int64_t candle_duration_ms,
                         const CandleSnapshot* from,
                         std::size_t from_n,
-                        float morph_t) {
+                        float morph_t,
+                        float tension) {
     const std::size_t from_count = vroom::morph_from_count(from, from_n, morph_t);
     const std::size_t slots = std::max(n, from_count);
     if (slots == 0) return SkPath();
-    const float area_w = vroom::candle_area_width(lay);
 
-    SkPathBuilder path;
-    bool pen_down = false;
-    for (std::size_t k = slots; k-- > 0;) {
-        const ::VroomCandle* to = (k < n) ? &visible[n - 1 - k] : nullptr;
-        const CandleSnapshot* frm = (k < from_count) ? &from[k] : nullptr;
-
-        float x, y;
-        if (to) {
-            const float tx = vroom::candle_center_x(
-                lay, to->time_ms, candle_duration_ms, visible_start_ms, window_ms);
-            const float ty = vroom::price_to_y(lay, bounds, to->close);
-            if (frm) {
-                // The capture is in band fractions, so it lands on the same pixels
-                // it occupied pre-switch even though the bounds changed.
-                x = lerp(frm->x * area_w, tx, morph_t);
-                y = lerp(vroom::y_at_fraction(lay, frm->close), ty, morph_t);
+    // Vertex `i` of the left-to-right walk, so the smoothing pass below can look
+    // ahead without a second copy of the morph interpolation.
+    const auto vertex = [&](std::size_t i) -> SkPoint {
+        return close_vertex(lay, bounds, visible, n, window_ms, visible_start_ms,
+                            candle_duration_ms, from, from_count, morph_t,
+                            slots - 1 - i);
+    };
+
+    // Straight segments by default, and below three points there's no interior
+    // vertex to round. Kept as its own pass so the common case emits exactly the
+    // path it always has.
+    if (!(tension > 0.f) || slots < 3) {
+        SkPathBuilder path;
+        for (std::size_t i = 0; i < slots; ++i) {
+            const SkPoint p = vertex(i);
+            if (i == 0) {
+                path.moveTo(p);
             } else {
-                x = tx;
-                y = ty;
+                path.lineTo(p);
             }
-        } else {
-            // A slot only the outgoing data had. Counts match in practice, so this
-            // just keeps gappy or short-history data from breaking the line.
-            x = frm->x * area_w;
-            y = vroom::y_at_fraction(lay, frm->close);
         }
+        return path.detach();
+    }
 
-        if (pen_down) {
-            path.lineTo(x, y);
-        } else {
-            path.moveTo(x, y);
-            pen_down = true;
+    // A tangent needs a neighbor on both sides, so smoothing can't stay
+    // streaming. Reused across frames — rendering is single-threaded per chart
+    // and the buffer is only live for this call — so it stops allocating after
+    // the first frame at a given zoom.
+    static thread_local std::vector<SkPoint> pts;
+    pts.clear();
+    pts.reserve(slots);
+    for (std::size_t i = 0; i < slots; ++i) pts.push_back(vertex(i));
+
+    const auto secant_at = [&](std::size_t i) {
+        return vroom::curve::secant(pts[i].fX, pts[i].fY,
+                                    pts[i + 1].fX, pts[i + 1].fY);
+    };
+    // Endpoints have only one neighboring secant to lean on; interiors get the
+    // monotone-limited blend of both. Recomputing a secant or two beats carrying
+    // a second buffer.
+    const auto tangent_at = [&](std::size_t i) {
+        if (i == 0) return secant_at(0);
+        if (i + 1 == pts.size()) return secant_at(pts.size() - 2);
+        return vroom::curve::monotone_tangent(secant_at(i - 1), secant_at(i));
+    };
+
+    SkPathBuilder path;
+    path.moveTo(pts[0]);
+    for (std::size_t i = 0; i + 1 < pts.size(); ++i) {
+        // Flat or backwards spacing — duplicate timestamps, or the compressed x
+        // a morph can pass through — has no meaningful tangent, and curving
+        // through it would fold the line back on itself.
+        if (!(pts[i + 1].fX > pts[i].fX)) {
+            path.lineTo(pts[i + 1]);
+            continue;
         }
+        const vroom::curve::Controls c = vroom::curve::segment_controls(
+            pts[i].fX, pts[i].fY, pts[i + 1].fX, pts[i + 1].fY,
+            tangent_at(i), tangent_at(i + 1), tension);
+        path.cubicTo(c.c1x, c.c1y, c.c2x, c.c2y, pts[i + 1].fX, pts[i + 1].fY);
     }
     return path.detach();
 }
@@ -170,15 +246,17 @@ void draw_close_line(SkCanvas* canvas,
                      float opacity,
                      const CandleSnapshot* from,
                      std::size_t from_n,
-                     float morph_t) {
+                     float morph_t,
+                     float tension) {
     if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
     opacity = std::clamp(opacity, 0.f, 1.f);
     if (opacity <= 0.f) return;
     morph_t = std::clamp(morph_t, 0.f, 1.f);
+    tension = std::clamp(tension, 0.f, 1.f);
 
     const SkPath path = build_close_path(lay, bounds, visible, n, window_ms,
                                         visible_start_ms, candle_duration_ms,
-                                        from, from_n, morph_t);
+                                        from, from_n, morph_t, tension);
     if (path.isEmpty()) return;
 
     stroke_path(canvas, path, candle_right, candle_area_h, color, width, opacity);
@@ -199,17 +277,19 @@ void draw_close_gradient(SkCanvas* canvas,
                          float opacity,
                          const CandleSnapshot* from,
                          std::size_t from_n,
-                         float morph_t) {
+                         float morph_t,
+                         float tension) {
     if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
     gradient_opacity = std::clamp(gradient_opacity, 0.f, 1.f);
     opacity = std::clamp(opacity, 0.f, 1.f);
     const float alpha = gradient_opacity * opacity;
     if (alpha <= 0.f) return;
     morph_t = std::clamp(morph_t, 0.f, 1.f);
+    tension = std::clamp(tension, 0.f, 1.f);
 
     const SkPath line = build_close_path(lay, bounds, visible, n, window_ms,
                                         visible_start_ms, candle_duration_ms,
-                                        from, from_n, morph_t);
+                                        from, from_n, morph_t, tension);
     if (line.isEmpty()) return;
 
     // The polyline runs strictly left to right, so its bounds give the first and
@@ -240,6 +320,92 @@ void draw_close_gradient(SkCanvas* canvas,
     canvas->restore();
 }
 
+void draw_close_tip(SkCanvas* canvas,
+                    const Layout& lay,
+                    const PriceBounds& bounds,
+                    const ::VroomCandle* visible,
+                    std::size_t n,
+                    int64_t window_ms,
+                    int64_t visible_start_ms,
+                    int64_t candle_duration_ms,
+                    float candle_right,
+                    float candle_area_h,
+                    uint32_t line_color,
+                    uint32_t bg_color,
+                    float line_width,
+                    float opacity,
+                    bool pulse,
+                    float pulse_phase,
+                    const CandleSnapshot* from,
+                    std::size_t from_n,
+                    float morph_t) {
+    if (!canvas || candle_right <= 0.f || candle_area_h <= 0.f) return;
+    opacity = std::clamp(opacity, 0.f, 1.f);
+    if (opacity <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+
+    const std::size_t from_count = vroom::morph_from_count(from, from_n, morph_t);
+    const std::size_t slots = std::max(n, from_count);
+    if (slots == 0) return;
+
+    const SkPoint tip =
+        close_vertex(lay, bounds, visible, n, window_ms, visible_start_ms,
+                     candle_duration_ms, from, from_count, morph_t, 0);
+    // Panned or scaled out of the pane: the line's end isn't on screen, so
+    // there's nothing to mark. The clip below would hide it anyway, but the ring
+    // is wide enough that a tip just off-pane would still bleed in.
+    if (tip.fY < 0.f || tip.fY > candle_area_h) return;
+    if (tip.fX < 0.f || tip.fX > candle_right) return;
+
+    // Scaling off the stroke keeps the marker proportionate at any line width;
+    // the floor stops a hairline chart from getting an invisible dot.
+    const float w = line_width > 0.f ? line_width : 1.5f;
+    const float dot_r = std::max(2.f, w * 1.5f);
+    const float border_r = dot_r + kTipBorderPx;
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, 0.f, candle_right, candle_area_h));
+
+    // Ring first: the border paints over its inner edge, so it reads as
+    // expanding out from underneath the dot rather than around it.
+    if (pulse) {
+        const vroom::tip_pulse::Frame f = vroom::tip_pulse::at(pulse_phase);
+        const float r = border_r * f.radius_mul;
+        if (f.fill_alpha > 0.f) {
+            SkPaint fill;
+            fill.setAntiAlias(true);
+            fill.setColor(static_cast<SkColor>(line_color));
+            fill.setAlphaf(fill.getAlphaf() * f.fill_alpha * opacity);
+            canvas->drawCircle(tip.fX, tip.fY, r, fill);
+        }
+        if (f.stroke_alpha > 0.f) {
+            SkPaint edge;
+            edge.setAntiAlias(true);
+            edge.setColor(static_cast<SkColor>(line_color));
+            edge.setAlphaf(edge.getAlphaf() * f.stroke_alpha * opacity);
+            edge.setStyle(SkPaint::kStroke_Style);
+            edge.setStrokeWidth(1.f);
+            canvas->drawCircle(tip.fX, tip.fY, r, edge);
+        }
+    }
+
+    // Filled rather than stroked: an annulus stroked around the dot leaves an
+    // antialiased seam where the two meet, which shows up as a dark hairline.
+    SkPaint border;
+    border.setAntiAlias(true);
+    border.setColor(static_cast<SkColor>(bg_color));
+    border.setAlphaf(border.getAlphaf() * opacity);
+    canvas->drawCircle(tip.fX, tip.fY, border_r, border);
+
+    SkPaint dot;
+    dot.setAntiAlias(true);
+    dot.setColor(static_cast<SkColor>(line_color));
+    dot.setAlphaf(dot.getAlphaf() * opacity);
+    canvas->drawCircle(tip.fX, tip.fY, dot_r, dot);
+
+    canvas->restore();
+}
+
 void fill_between(SkCanvas* canvas,
                   const Layout& lay,
                   const PriceBounds& bounds,

package/cpp/_core_src/ma_overlay.h

@@ -48,6 +48,9 @@ void draw(SkCanvas* canvas,
 // had before the timeframe switch to its new one. `morph_t == 1` (the default)
 // draws `visible` alone.
 //
+// `tension` (0..1) rounds the corners, monotone-limited so the curve can't
+// overshoot into a price that never traded (see curve.h). 0 is straight segments.
+//
 // Separate from draw() because the capture holds candle closes — it can't stand
 // in for an indicator's values.
 void draw_close_line(SkCanvas* canvas,
@@ -65,12 +68,14 @@ void draw_close_line(SkCanvas* canvas,
                      float opacity = 1.f,
                      const CandleSnapshot* from = nullptr,
                      std::size_t from_n = 0,
-                     float morph_t = 1.f);
+                     float morph_t = 1.f,
+                     float tension = 0.f);
 
 // The area beneath the close-price polyline, filled with `color` ramping from
 // `gradient_opacity` at the line's peak to fully transparent at the pane bottom.
-// Takes the same geometry and morph arguments as draw_close_line and builds the
-// identical polyline, so the fill tracks the line through a timeframe switch.
+// Takes the same geometry, morph and tension arguments as draw_close_line and
+// builds the identical path, so the fill tracks the line through a timeframe
+// switch and follows the same rounded corners.
 //
 // `opacity` multiplies the ramp, which is what fades the fill in alongside the
 // line during the candle→line morph. Draws nothing when either opacity is 0.
@@ -91,7 +96,39 @@ void draw_close_gradient(SkCanvas* canvas,
                          float opacity = 1.f,
                          const CandleSnapshot* from = nullptr,
                          std::size_t from_n = 0,
-                         float morph_t = 1.f);
+                         float morph_t = 1.f,
+                         float tension = 0.f);
+
+// The marker at the line's newest end: a dot in `line_color` sized off
+// `line_width`, ringed by a 2px disc of `bg_color` that separates it from the
+// line's stroke cap, and optionally a pulse expanding out from behind it.
+//
+// Takes the same geometry and morph arguments as draw_close_line and reads the
+// same vertex, so the dot stays on the line's end pixel through a timeframe
+// switch. `opacity` scales everything, fading the marker in with the line during
+// the candle→line morph.
+//
+// `pulse_phase` is in cycles and wraps, so the caller can hand over elapsed time
+// divided by tip_pulse::kPeriodSeconds. Ignored unless `pulse`.
+void draw_close_tip(SkCanvas* canvas,
+                    const Layout& lay,
+                    const PriceBounds& bounds,
+                    const ::VroomCandle* visible,
+                    std::size_t n,
+                    int64_t window_ms,
+                    int64_t visible_start_ms,
+                    int64_t candle_duration_ms,
+                    float candle_right,
+                    float candle_area_h,
+                    uint32_t line_color,
+                    uint32_t bg_color,
+                    float line_width,
+                    float opacity = 1.f,
+                    bool pulse = false,
+                    float pulse_phase = 0.f,
+                    const CandleSnapshot* from = nullptr,
+                    std::size_t from_n = 0,
+                    float morph_t = 1.f);
 
 // Fills the closed region between two aligned series (NaN where undefined)
 // with `color` at its alpha × `opacity` — used for the Bollinger Band fill.

package/cpp/_core_src/theme.cpp

@@ -39,6 +39,9 @@ constexpr float kDefaultFloats[VROOM_FLOAT_COUNT_] = {
     0.f,    // VOLUME_RADIUS_PX — square by default
     1.5f,   // LINE_WIDTH_PX — line-chart polyline stroke width
     0.28f,  // LINE_GRADIENT_OPACITY — fill under the line, ramped to 0 at the pane bottom
+    0.f,    // LINE_TENSION — straight segments by default
+    1.f,    // LINE_TIP_DOT — the line's leading end is marked by default
+    0.f,    // LINE_TIP_PULSE — the ring is opt-in; it never lets the chart idle
 };
 
 }  // namespace