react-native-vroom-chart 0.7.0 → 0.9.0

package/cpp/VroomChartHostObject.cpp

@@ -29,7 +29,7 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(29);
+  out.reserve(39);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
@@ -38,6 +38,13 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setDefaultCandleWidth"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setChartType"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getVisibleRange"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "resetView"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "resetPriceScale"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getVisiblePriceEnvelope"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "beginIntervalMorph"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setIntervalMorph"));
   out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
   out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
   out.push_back(jsi::PropNameID::forAscii(rt, "zoom"));
@@ -297,6 +304,129 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "getVisibleRange") {
+    // getVisibleRange() -> { startMs, endMs }. Both 0 while uninitialized.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getVisibleRange"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          int64_t s = 0, e = 0;
+          vroom_chart_get_visible_range(chart_, &s, &e);
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "startMs", static_cast<double>(s));
+          obj.setProperty(rt2, "endMs", static_cast<double>(e));
+          return obj;
+        });
+  }
+
+  if (name == "resetView") {
+    // resetView() — reframe the most recent candles and re-enable y auto-fit.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "resetView"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_reset_view(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "resetPriceScale") {
+    // resetPriceScale() — re-enable y auto-fit, leaving the time window alone.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "resetPriceScale"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_reset_price_scale(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "getVisiblePriceEnvelope") {
+    // getVisiblePriceEnvelope() -> { low, high } | null. The extent the visible
+    // candles occupy, not the (wider) axis range. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getVisiblePriceEnvelope"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          double low = 0.0, high = 0.0;
+          if (!vroom_chart_get_visible_price_envelope(chart_, &low, &high)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "low", low);
+          obj.setProperty(rt2, "high", high);
+          return obj;
+        });
+  }
+
+  if (name == "preservePriceEnvelope") {
+    // preservePriceEnvelope(prevLow, prevHigh) — scale-lock a manual price
+    // range across a timeframe switch. No-op in auto-y mode.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "preservePriceEnvelope"),
+        2,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::undefined();
+          vroom_chart_preserve_price_envelope(chart_, args[0].asNumber(),
+                                              args[1].asNumber());
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "beginIntervalMorph") {
+    // beginIntervalMorph() — capture the visible candle geometry so the next
+    // setCandles can be animated as a reshape. Call before setCandles.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "beginIntervalMorph"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_begin_interval_morph(chart_);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setIntervalMorph") {
+    // setIntervalMorph(t) — advance the capture toward the new candles. `t` is
+    // pre-eased progress: 0 = the captured frame, 1 = settled (capture freed).
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setIntervalMorph"),
+        1,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::undefined();
+          vroom_chart_set_interval_morph(
+              chart_, static_cast<float>(args[0].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "pan") {
     // pan(dx, dy) -> JsiSkPicture
     // Mutates the visible range and renders in one JSI call so gesture

package/cpp/_core_include/vroom/vroom_chart.h

@@ -172,17 +172,20 @@ typedef struct VroomDrawPoint {
 //                and `b`; the other two corners (a.x,b.y) and (b.x,a.y) derive.
 //   2 = pencil — a freehand path through `points` (in draw order). `a`/`b` mirror
 //                the first/last point so bounds and handle code stay uniform.
+//   3 = path   — straight segments through `points` (in draw order), ending in
+//                an arrowhead on the last one. Same storage as a pencil, but
+//                rendered unsmoothed and with every vertex a grab handle.
 //
-// `points`/`point_count` are only read for kind 2; line and box leave them
-// null/0. Like the rest of this API the points are copied internally, so the
-// caller may free them as soon as the call returns.
+// `points`/`point_count` are only read for kinds 2 and 3; line and box leave
+// them null/0. Like the rest of this API the points are copied internally, so
+// the caller may free them as soon as the call returns.
 typedef struct VroomDrawing {
     VroomDrawPoint        a;
     VroomDrawPoint        b;
     uint32_t              color;        // 0xAARRGGBB
     float                 width;        // stroke width in px
-    int32_t               kind;         // 0 = line, 1 = box, 2 = pencil
-    const VroomDrawPoint* points;       // pencil path (kind 2), else null
+    int32_t               kind;         // 0 = line, 1 = box, 2 = pencil, 3 = path
+    const VroomDrawPoint* points;       // pencil/path points (kind 2/3), else null
     int32_t               point_count;  // number of `points`, else 0
 } VroomDrawing;
 
@@ -291,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;
 
@@ -551,18 +557,31 @@ void vroom_chart_set_drawings(VroomChart* chart, const VroomDrawing* drawings,
                               size_t count);
 
 // Hit-tests pixel (x_px, y_px) against the committed drawings. On a hit, fills
-// *out_index with the drawing index, *out_part with 0 (endpoint A), 1
-// (endpoint B), or 2 (line body), *out_t with the 0..1 grab position along the
-// segment (A→B; 0/1 for handle hits), and returns true. Endpoint hits are only
-// reported for the currently selected drawing (whose handles are visible).
-// Returns false on a miss (out params untouched). Any out pointer may be null.
+// *out_index with the drawing index, *out_part with the sub-part that was hit,
+// *out_t with the 0..1 grab position along the segment (A→B; 0/1 for handle
+// hits, 0 for the shapes that have no meaningful t), and returns true. Handle
+// hits are only reported for the currently selected drawing (whose handles are
+// visible). Returns false on a miss (out params untouched). Any out pointer may
+// be null.
+//
+// `out_part` is per-kind (see VroomDrawing.kind):
+//   line   — 0 (endpoint A), 1 (endpoint B), 2 (body).
+//   box    — 0..3 (corners, in the order a, (b.x,a.y), b, (a.x,b.y)), 4 (body).
+//   pencil — 5 (body; a stroke has no handles).
+//   path   — 6 (body), or VROOM_DRAW_PART_VERTEX + i for vertex i. The offset
+//            keeps a vertex index from colliding with the small part numbers
+//            above, and is why a path is capped at VROOM_PATH_MAX_POINTS.
+#define VROOM_DRAW_PART_VERTEX 100
+#define VROOM_PATH_MAX_POINTS  64
 bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px, float y_px,
                                   int32_t* out_index, int32_t* out_part,
                                   float* out_t);
 
-// Selects a committed drawing (renders its endpoint handles). `index` -1 clears
-// the selection. `grabbed_endpoint` 0/1 renders that handle 50% larger while it's
-// being dragged; -1 for none. An out-of-range index clears the selection.
+// Selects a committed drawing (renders its handles). `index` -1 clears the
+// selection. `grabbed_endpoint` renders that handle 50% larger while it's being
+// dragged (0/1 for a line, 0 for the box corner the host normalized to, the
+// vertex index for a path); -1 for none. An out-of-range index clears the
+// selection.
 void vroom_chart_set_selected_drawing(VroomChart* chart, int32_t index,
                                       int32_t grabbed_endpoint);
 
@@ -572,8 +591,16 @@ void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t index,
                                        int32_t endpoint, int64_t time_ms,
                                        double price);
 
+// Moves one vertex of a committed path (kind 3) to a new data-space anchor, for
+// live handle dragging. `vertex` indexes `points`; a/b are re-mirrored onto the
+// first/last point afterwards. No-op for an out-of-range drawing/vertex index or
+// a drawing that isn't a path.
+void vroom_chart_move_drawing_vertex(VroomChart* chart, int32_t index,
+                                     int32_t vertex, int64_t time_ms,
+                                     double price);
+
 // Shifts a whole committed drawing by a *relative* data-space delta — `a`, `b`,
-// and (for a pencil) every path point. Used for live body dragging of shapes
+// and (for a pencil or path) every point. Used for live body dragging of shapes
 // whose points can't be restated cheaply. No-op for an out-of-range index.
 void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
                                    int64_t d_time_ms, double d_price);
@@ -642,6 +669,19 @@ void vroom_chart_start_draft_stroke(VroomChart* chart, uint32_t color,
 void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_ms,
                                     double price);
 
+// Restates the whole in-progress path (kind 3) draft: `count` vertices placed so
+// far, plus — when `has_cursor` — a rubber-band segment from the last vertex to
+// (cursor_time, cursor_price) carrying the arrow tip. Each placed vertex renders
+// a node dot. A path is placed one deliberate click at a time (so `count` stays
+// small, see VROOM_PATH_MAX_POINTS), which is why this restates rather than
+// appending: the host stays the sole owner of the vertex list, and undoing a
+// point is just a shorter array. Pass count 0 with has_cursor false to show
+// nothing; the points are copied, so the caller may free them on return.
+void vroom_chart_set_draft_path(VroomChart* chart, const VroomDrawPoint* points,
+                                int32_t count, bool has_cursor,
+                                int64_t cursor_time, double cursor_price,
+                                uint32_t color, float width);
+
 // Clears the draft (hides the in-progress node dots / guideline / stroke).
 void vroom_chart_clear_draft(VroomChart* chart);
 

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
@@ -182,9 +188,10 @@ struct VroomChart {
     // Committed drawings, anchored in data space so they track the candles on
     // pan/zoom. Drawn on the price pane above candles/overlays.
     //
-    // Mirrors the public VroomDrawing but *owns* its points, so a pencil path
-    // (kind 2) can carry a variable number of them. For line/box `points` is
-    // empty and only a/b are used; for pencil a/b mirror the first/last point.
+    // Mirrors the public VroomDrawing but *owns* its points, so a pencil stroke
+    // (kind 2) or path (kind 3) can carry a variable number of them. For
+    // line/box `points` is empty and only a/b are used; for pencil/path a/b
+    // mirror the first/last point.
     struct StoredDrawing {
         VroomDrawPoint              a{};
         VroomDrawPoint              b{};
@@ -199,7 +206,9 @@ struct VroomChart {
     // draft_a is always drawn (node dot); draft_b is drawn when draft_has_b.
     // draft_guide draws the live guideline A->B; when false only node dots show
     // (the committed segment renders via `drawings`). draft_color/draft_width
-    // style the guideline to match the eventual line.
+    // style the guideline to match the eventual line. For a path (draft_kind 3)
+    // draft_points holds the vertices placed so far and draft_b is the cursor
+    // the rubber-band segment runs to (when draft_has_b).
     bool           draft_active = false;
     VroomDrawPoint draft_a{};
     bool           draft_has_b = false;
@@ -207,14 +216,16 @@ struct VroomChart {
     bool           draft_guide = false;
     uint32_t       draft_color = 0xff2962ff;
     float          draft_width = 2.f;
-    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil (VroomDrawing)
-    // Freehand stroke in progress (draft_kind 2), grown one point at a time.
+    int32_t        draft_kind = 0;  // 0 = line, 1 = box, 2 = pencil, 3 = path
+    // Points of the in-progress stroke (draft_kind 2, grown one at a time) or
+    // path (draft_kind 3, restated per click/move).
     std::vector<VroomDrawPoint> draft_points;
 
     // Selection/editing state for committed drawings. selected_drawing indexes
-    // `drawings` (or -1); its endpoints render as handles. grabbed_endpoint is
-    // 0 (A) or 1 (B) while that handle is being dragged (rendered 50% larger),
-    // else -1.
+    // `drawings` (or -1); its handles render on top. grabbed_endpoint is the
+    // handle being dragged — 0 (A) or 1 (B) for a line, 0 for a box (the host
+    // normalizes the grabbed corner to endpoint 0), the vertex index for a path
+    // — rendered 50% larger; -1 when none.
     int32_t        selected_drawing = -1;
     int32_t        grabbed_endpoint = -1;
 
@@ -302,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
@@ -883,8 +907,9 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
                                          const VroomDrawing* drawings,
                                          size_t count) {
     if (!chart) return;
-    // Deep-copy into the owning form: a pencil's path lives in the chart, so the
-    // caller's `points` buffer may be freed as soon as this returns.
+    // Deep-copy into the owning form: a pencil stroke's or path's points live in
+    // the chart, so the caller's `points` buffer may be freed as soon as this
+    // returns.
     chart->drawings.clear();
     chart->drawings.reserve(count);
     for (size_t i = 0; i < count; ++i) {
@@ -895,7 +920,7 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
         d.color = src.color;
         d.width = src.width;
         d.kind = src.kind;
-        if (src.kind == 2 && src.points && src.point_count > 0) {
+        if ((src.kind == 2 || src.kind == 3) && src.points && src.point_count > 0) {
             d.points.assign(src.points, src.points + src.point_count);
             // Keep a/b mirroring the path ends so bounds/handle code is uniform.
             d.a = d.points.front();
@@ -1025,6 +1050,27 @@ extern "C" void vroom_chart_append_draft_point(VroomChart* chart, int64_t time_m
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_set_draft_path(VroomChart* chart,
+                                           const VroomDrawPoint* points,
+                                           int32_t count, bool has_cursor,
+                                           int64_t cursor_time,
+                                           double cursor_price, uint32_t color,
+                                           float width) {
+    if (!chart) return;
+    chart->draft_active = true;
+    chart->draft_kind = 3;
+    chart->draft_guide = true;
+    chart->draft_color = color;
+    chart->draft_width = width;
+    chart->draft_points.clear();
+    if (points && count > 0) chart->draft_points.assign(points, points + count);
+    chart->draft_has_b = has_cursor;
+    chart->draft_b = VroomDrawPoint{cursor_time, cursor_price};
+    // draft_a doubles as the first placed vertex for the shared node-dot path.
+    if (!chart->draft_points.empty()) chart->draft_a = chart->draft_points.front();
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_clear_draft(VroomChart* chart) {
     if (!chart) return;
     if (!chart->draft_active) return;
@@ -1151,6 +1197,21 @@ extern "C" void vroom_chart_move_drawing_endpoint(VroomChart* chart, int32_t ind
     chart->mark_dirty();
 }
 
+extern "C" void vroom_chart_move_drawing_vertex(VroomChart* chart, int32_t index,
+                                                int32_t vertex, int64_t time_ms,
+                                                double price) {
+    if (!chart) return;
+    if (index < 0 || index >= static_cast<int32_t>(chart->drawings.size())) return;
+    auto& d = chart->drawings[index];
+    if (d.kind != 3) return;
+    if (vertex < 0 || vertex >= static_cast<int32_t>(d.points.size())) return;
+    d.points[vertex] = VroomDrawPoint{time_ms, price};
+    // a/b mirror the path ends, so moving a terminal vertex has to restate them.
+    d.a = d.points.front();
+    d.b = d.points.back();
+    chart->mark_dirty();
+}
+
 extern "C" void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
                                               int64_t d_time_ms, double d_price) {
     if (!chart) return;
@@ -1160,6 +1221,7 @@ extern "C" void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
         p.time_ms += d_time_ms;
         p.price += d_price;
     };
+    // a/b mirror the path/stroke ends, so shifting everything keeps them in sync.
     shift(d.a);
     shift(d.b);
     for (VroomDrawPoint& p : d.points) shift(p);

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