react-native-vroom-chart 0.1.0

package/cpp/VroomSkiaContext.h

@@ -0,0 +1,30 @@
+// Helpers for reaching into RN-Skia's installed JSI bindings to grab its
+// RNSkPlatformContext — which we need so we can use JsiSkFontMgrFactory to
+// get the system font manager cross-platform.
+//
+// JsiSkHostObject::getContext() is protected, so we use a "friend helper"
+// subclass that exposes it via `using`. We never construct an instance —
+// we just static_cast existing host objects to the accessor type.
+
+#pragma once
+
+#include <memory>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"      // RNSkia::JsiSkHostObject
+#include "RNSkPlatformContext.h"   // RNSkia::RNSkPlatformContext
+
+namespace vroom {
+
+class HostObjectAccessor : public RNSkia::JsiSkHostObject {
+ public:
+  using RNSkia::JsiSkHostObject::getContext;
+};
+
+// Returns the RN-Skia platform context by reading global.SkiaApi.
+// Returns nullptr if SkiaApi isn't on the global yet (RN-Skia not installed).
+std::shared_ptr<RNSkia::RNSkPlatformContext> getRNSkContext(
+    facebook::jsi::Runtime& runtime);
+
+}  // namespace vroom

package/cpp/_core_include/vroom/vroom_chart.h

@@ -0,0 +1,195 @@
+// vroom_chart.h — public C facade for the vroom chart core.
+//
+// Threading: All calls must happen on a single thread (the render thread the
+// host picked). The core does no internal locking.
+//
+// Rendering model: push. The core fires `on_redraw_requested` when something
+// visual changed. The host marks dirty and calls `vroom_chart_draw` on the
+// next vsync — never re-enter draw from the callback.
+//
+// Gestures: host-driven. The host wires its native gesture recognizers
+// (UIPanGestureRecognizer / Android GestureDetector / RNGH) and calls
+// `vroom_chart_pan`, `vroom_chart_zoom`, `vroom_chart_set_crosshair`,
+// `vroom_chart_clear_crosshair`. The core has no gesture state machine.
+
+#ifndef VROOM_CHART_H
+#define VROOM_CHART_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward-declare Skia types as opaque so this header has no Skia dependency.
+// The implementation casts back to SkCanvas* internally.
+typedef struct SkCanvas SkCanvas;
+
+typedef struct VroomChart VroomChart;
+
+// ---- Data types -----------------------------------------------------------
+
+typedef struct VroomCandle {
+    int64_t time_ms;   // epoch milliseconds, ascending, non-overlapping
+    double  open;
+    double  high;
+    double  low;
+    double  close;
+    double  volume;
+} VroomCandle;
+
+// A moving-average overlay line drawn on the price pane.
+typedef struct VroomOverlay {
+    int32_t  kind;    // 0 = SMA, 1 = EMA
+    int32_t  period;  // lookback in candles (>= 1)
+    int32_t  source;  // 0=close,1=open,2=high,3=low,4=hl2,5=hlc3,6=ohlc4
+    uint32_t color;   // 0xAARRGGBB
+    float    width;   // stroke width in px
+} VroomOverlay;
+
+// ---- Styling keys ---------------------------------------------------------
+
+typedef enum {
+    VROOM_COLOR_BACKGROUND = 0,
+    VROOM_COLOR_BULL,
+    VROOM_COLOR_BEAR,
+    VROOM_COLOR_WICK,
+    VROOM_COLOR_GRID,
+    VROOM_COLOR_AXIS_TEXT,
+    VROOM_COLOR_CROSSHAIR,
+    VROOM_COLOR_TOOLTIP_BG,
+    VROOM_COLOR_TOOLTIP_TEXT,
+    VROOM_COLOR_CROSSHAIR_TARGET,  // the hollow ring/dot at the intersection
+    VROOM_COLOR_COUNT_
+} VroomColorKey;
+
+typedef enum {
+    VROOM_FLOAT_CANDLE_WIDTH_RATIO = 0,  // 0..1 of slot width
+    VROOM_FLOAT_WICK_WIDTH_PX,
+    VROOM_FLOAT_RIGHT_PADDING_PX,        // small gutter between candles and y-axis
+    VROOM_FLOAT_AXIS_FONT_SIZE_PX,
+    VROOM_FLOAT_Y_AXIS_WIDTH_RATIO,      // fallback y-axis width when no typeface
+    VROOM_FLOAT_X_AXIS_HEIGHT_PX,        // bottom strip reserved for time labels
+    VROOM_FLOAT_VOLUME_OPACITY,          // volume bar opacity (1=opaque)
+    VROOM_FLOAT_INDICATOR_HEIGHT_FRAC,   // below-chart indicator pane, fraction of height
+    VROOM_FLOAT_COUNT_
+} VroomFloatKey;
+
+// ---- Callbacks ------------------------------------------------------------
+
+typedef struct {
+    void (*on_redraw_requested)(void* ctx);
+    void (*on_viewport_changed)(void* ctx, int64_t start_ms, int64_t end_ms);
+    void (*on_crosshair_changed)(void* ctx, bool active, int64_t ms, double price);
+} VroomCallbacks;
+
+// ---- Lifecycle ------------------------------------------------------------
+
+VroomChart* vroom_chart_create(const VroomCallbacks* cb, void* user_ctx);
+void        vroom_chart_destroy(VroomChart* chart);
+
+// ---- Data (copied internally; caller may free immediately) ----------------
+
+void vroom_chart_set_candles(VroomChart* chart, const VroomCandle* data, size_t count);
+void vroom_chart_append_candle(VroomChart* chart, const VroomCandle* c);
+void vroom_chart_update_last(VroomChart* chart, const VroomCandle* c);
+
+// ---- Sizing ---------------------------------------------------------------
+
+void vroom_chart_set_size(VroomChart* chart, float width_px, float height_px, float px_ratio);
+
+// ---- Viewport -------------------------------------------------------------
+
+void vroom_chart_set_visible_range(VroomChart* chart, int64_t start_ms, int64_t end_ms);
+void vroom_chart_pan(VroomChart* chart, float dx_px, float dy_px);
+// Directional zoom. scale_x scales the time window around focus_x_px (>1 =
+// narrower window, wider candles); scale_y scales the price range around
+// focus_y_px (>1 = taller candles). Pass 1.0 for an axis to leave it untouched.
+void vroom_chart_zoom(VroomChart* chart, float scale_x, float scale_y,
+                      float focus_x_px, float focus_y_px);
+
+// Two-finger translation. Shifts the time window like pan (dx) and shifts
+// the price bounds vertically (dy) without changing their range — so the
+// chart slides without rescaling. dy > 0 (drag down) moves content down
+// (price labels move down to higher numbers).
+void vroom_chart_translate(VroomChart* chart, float dx_px, float dy_px);
+
+// Axis-drag controls — used by JS gesture handlers that detect a drag
+// started on the y-axis or x-axis strip. Scaling pivots around the natural
+// anchor (price center for y, right edge for x).
+//
+// Sign conventions:
+//   scale_price_axis: dy > 0 (drag down) widens the price range → candles shrink
+//   scale_time_axis:  dx > 0 (drag right) widens the time range → candles thin
+void vroom_chart_scale_price_axis(VroomChart* chart, float dy_px);
+void vroom_chart_scale_time_axis(VroomChart* chart, float dx_px);
+
+// Reads the current y-axis width, x-axis height, and below-chart indicator pane
+// height in pixels so callers can hit-test gestures against each region on the
+// JS side. out_indicator_height_px is 0 when no indicator pane is shown.
+void vroom_chart_get_axis_metrics(VroomChart* chart,
+                                   float* out_y_axis_width_px,
+                                   float* out_x_axis_height_px,
+                                   float* out_indicator_height_px);
+
+// ---- Crosshair ------------------------------------------------------------
+
+void vroom_chart_set_crosshair(VroomChart* chart, float x_px, float y_px);
+void vroom_chart_clear_crosshair(VroomChart* chart);
+
+// Fills *out with the OHLCV of the candle the crosshair currently snaps to and
+// returns true. Returns false (leaving *out untouched) when the crosshair is
+// inactive or there are no visible candles. Stateless — recomputes the snap
+// from the current crosshair x and visible window, matching what's rendered.
+bool vroom_chart_get_crosshair_candle(VroomChart* chart, VroomCandle* out);
+
+// ---- Indicators -----------------------------------------------------------
+
+// Configures the RSI indicator (rendered in a pane below the candles). `period`
+// is the RSI lookback in candle counts (clamped >= 2). `upper_band`/`lower_band`
+// are the overbought/oversold reference levels (0..100; default 70/30).
+// `ma_enabled` toggles the RSI-based moving-average trendline and `ma_period`
+// is its length (clamped >= 1). When enabled, the candle pane shrinks by
+// VROOM_FLOAT_INDICATOR_HEIGHT_FRAC.
+void vroom_chart_set_rsi(VroomChart* chart, bool enabled, int period,
+                         double upper_band, double lower_band,
+                         bool ma_enabled, int ma_period);
+
+// Configures the MACD indicator (its own pane below the candles). `fast`/`slow`
+// are the EMA lengths (clamped >= 1, slow forced > fast; default 12/26) and
+// `signal` is the signal-line EMA length (clamped >= 1; default 9). Panes stack
+// in enable order, most recently enabled at the bottom.
+void vroom_chart_set_macd(VroomChart* chart, bool enabled, int fast, int slow,
+                          int signal);
+
+// Replaces the full set of moving-average overlay lines (SMA/EMA) drawn on the
+// price pane. Pass count 0 to clear them. Overlays don't reserve a pane.
+void vroom_chart_set_overlays(VroomChart* chart, const VroomOverlay* overlays,
+                              size_t count);
+
+// Configures the session VWAP overlay (a single price-pane line). The session
+// resets each UTC day shifted by `reset_offset_min` minutes (the configurable
+// reset time). `color` is 0xAARRGGBB; `width` is the stroke px.
+void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
+                          uint32_t color, float width);
+
+// ---- Rendering ------------------------------------------------------------
+
+void vroom_chart_draw(VroomChart* chart, SkCanvas* canvas);
+
+// True while any axis-label fade is still animating. Hosts that drive their own
+// redraw loop (e.g. the web WASM build) poll this to know when to keep ticking.
+bool vroom_chart_is_animating(VroomChart* chart);
+
+// ---- Styling --------------------------------------------------------------
+
+void vroom_chart_set_color(VroomChart* chart, VroomColorKey key, uint32_t argb);
+void vroom_chart_set_float(VroomChart* chart, VroomFloatKey key, float value);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // VROOM_CHART_H

package/cpp/_core_src/candles.cpp

@@ -0,0 +1,74 @@
+#include "candles.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkRect.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::candles {
+
+void draw(SkCanvas* canvas,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const Layout& lay,
+          const Theme& theme,
+          const PriceBounds& bounds,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms) {
+    if (!canvas || n == 0) return;
+
+    const float body_w = vroom::candle_body_width(
+        lay, window_ms, candle_duration_ms);
+
+    SkPaint bull_paint;
+    bull_paint.setAntiAlias(true);
+    bull_paint.setColor(theme.colors[VROOM_COLOR_BULL]);
+
+    SkPaint bear_paint;
+    bear_paint.setAntiAlias(true);
+    bear_paint.setColor(theme.colors[VROOM_COLOR_BEAR]);
+
+    SkPaint wick_bull;
+    wick_bull.setAntiAlias(true);
+    wick_bull.setColor(theme.colors[VROOM_COLOR_BULL]);
+    wick_bull.setStrokeWidth(theme.floats[VROOM_FLOAT_WICK_WIDTH_PX]);
+    wick_bull.setStyle(SkPaint::kStroke_Style);
+
+    SkPaint wick_bear = wick_bull;
+    wick_bear.setColor(theme.colors[VROOM_COLOR_BEAR]);
+
+    const float half_body = body_w * 0.5f;
+
+    for (std::size_t i = 0; i < n; ++i) {
+        const auto& c = visible[i];
+        const bool bull = c.close >= c.open;
+
+        const float cx = vroom::candle_center_x(
+            lay, c.time_ms, candle_duration_ms,
+            visible_start_ms, window_ms);
+        const float y_high = vroom::price_to_y(lay, bounds, c.high);
+        const float y_low = vroom::price_to_y(lay, bounds, c.low);
+        const float y_open = vroom::price_to_y(lay, bounds, c.open);
+        const float y_close = vroom::price_to_y(lay, bounds, c.close);
+
+        canvas->drawLine(cx, y_high, cx, y_low,
+                         bull ? wick_bull : wick_bear);
+
+        const float y_top = std::min(y_open, y_close);
+        const float y_bot = std::max(y_open, y_close);
+        const float h = std::max(1.f, y_bot - y_top);
+        canvas->drawRect(
+            SkRect::MakeXYWH(cx - half_body, y_top, body_w, h),
+            bull ? bull_paint : bear_paint);
+    }
+}
+
+}  // namespace vroom::candles

package/cpp/_core_src/candles.h

@@ -0,0 +1,34 @@
+// Candle drawing — the wick+body loop, extracted so it can sit alongside
+// future drawing modules (volume bars, indicator overlays, etc.) without
+// growing the chart orchestrator.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+struct PriceBounds;
+struct Theme;
+}  // namespace vroom
+
+namespace vroom::candles {
+
+// Draws every candle in [visible, visible + n). The visible slice should
+// already be filtered by `visible_indices` in viewport.h.
+void draw(SkCanvas* canvas,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const Layout& lay,
+          const Theme& theme,
+          const PriceBounds& bounds,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms);
+
+}  // namespace vroom::candles

package/cpp/_core_src/chart.cpp

@@ -0,0 +1,317 @@
+// VroomChart engine — orchestration only.
+//
+// The struct definition lives in chart.h; per-subsystem rendering and the
+// public C facade live in candles.cpp, labels.cpp, and chart_facade.cpp.
+// This file keeps just the constructor, the small helpers used everywhere
+// (mark_dirty, layout, is_animating_now), the picture cache lifecycle
+// (rebuild_chart_picture), and the top-level draw_chart that composes all
+// the layers in z-order.
+
+#include "chart.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPicture.h"
+#include "include/core/SkPictureRecorder.h"
+#include "include/core/SkRect.h"
+#pragma clang diagnostic pop
+
+#include "candles.h"
+#include "chart_internal.h"
+#include "crosshair.h"
+#include "labels.h"
+#include "ma.h"
+#include "ma_overlay.h"
+#include "macd.h"
+#include "macd_pane.h"
+#include "price_indicator.h"
+#include "rsi.h"
+#include "rsi_pane.h"
+#include "volume.h"
+#include "vwap.h"
+#include "theme.h"
+#include "viewport.h"
+
+VroomChart::VroomChart() : theme(vroom::default_theme()) {}
+
+void VroomChart::mark_dirty() {
+    chart_dirty = true;
+    if (cb.on_redraw_requested) cb.on_redraw_requested(user_ctx);
+}
+
+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 float indicator_h = static_cast<float>(pane_count) * height_px *
+                              theme.floats[VROOM_FLOAT_INDICATOR_HEIGHT_FRAC];
+    return vroom::Layout{
+        width_px,
+        height_px,
+        axis_w,
+        theme.floats[VROOM_FLOAT_X_AXIS_HEIGHT_PX],
+        theme.floats[VROOM_FLOAT_RIGHT_PADDING_PX],
+        theme.floats[VROOM_FLOAT_CANDLE_WIDTH_RATIO],
+        0.05f,
+        0.05f,
+        indicator_h,
+    };
+}
+
+void VroomChart::ensure_rsi() {
+    if (!rsi_enabled || !rsi_dirty) return;
+    vroom::rsi::compute(candles.data(), candles.size(), rsi_period, rsi_cache);
+    if (rsi_ma_enabled) {
+        vroom::rsi::compute_ma(rsi_cache, rsi_ma_period, rsi_ma_cache);
+    } else {
+        rsi_ma_cache.clear();
+    }
+    rsi_dirty = false;
+}
+
+void VroomChart::ensure_macd() {
+    if (!macd_enabled || !macd_dirty) return;
+    vroom::macd::compute(candles.data(), candles.size(), macd_fast, macd_slow,
+                         macd_signal, macd_cache, macd_signal_cache,
+                         macd_hist_cache);
+    macd_dirty = false;
+}
+
+void VroomChart::ensure_overlays() {
+    if (!overlays_dirty) return;
+    overlay_caches.resize(overlays.size());
+    for (std::size_t i = 0; i < overlays.size(); ++i) {
+        const auto& ov = overlays[i];
+        vroom::ma::compute(candles.data(), candles.size(), ov.kind, ov.period,
+                           ov.source, overlay_caches[i]);
+    }
+    overlays_dirty = false;
+}
+
+void VroomChart::ensure_vwap() {
+    if (!vwap_enabled || !vwap_dirty) return;
+    vroom::vwap::compute(candles.data(), candles.size(), vwap_reset_offset_min,
+                         vwap_cache, vwap_breaks);
+    vwap_dirty = false;
+}
+
+void VroomChart::draw_chart(SkCanvas* canvas) {
+    const auto lay = layout();
+
+    // 1. Background
+    SkPaint bg;
+    bg.setColor(theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(SkRect::MakeWH(width_px, height_px), bg);
+
+    if (candles.empty()) return;
+
+    // 2. Visible slice + bounds + window_ms + geometry
+    const auto range = vroom::visible_indices(
+        candles.data(), candles.size(),
+        visible_start_ms, visible_end_ms);
+    const size_t n = range.end - range.start;
+    if (n == 0) return;
+    const ::VroomCandle* visible = candles.data() + range.start;
+
+    const auto bounds = price_bounds_initialized
+        ? price_bounds
+        : vroom::price_bounds(visible, n);
+    const int64_t window_ms = visible_end_ms - visible_start_ms;
+
+    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;
+
+    // 3. Update label fade state ONCE per frame — both gridlines and labels
+    //    share these opacities so their animations stay in lockstep.
+    vroom::labels::update_y_fades(*this, lay, bounds);
+    vroom::labels::update_x_fades(*this, lay);
+
+    // 4. Gridlines — drawn before candles so candle bodies overlay them.
+    //    Vertical (time) gridlines are intentionally disabled for now —
+    //    re-enable by adding `vroom::labels::draw_x_gridlines(canvas, *this,
+    //    candle_right, candle_area_h);` here.
+    vroom::labels::draw_y_gridlines(canvas, *this, lay, bounds,
+                                    candle_right, candle_area_h);
+
+    // 4.5. Volume bars — drawn under the candles so candles z-index above.
+    vroom::volume::draw(canvas, visible, n, lay, theme,
+                        window_ms, visible_start_ms, candle_duration_ms);
+
+    // 5. Candles (wicks + bodies)
+    vroom::candles::draw(canvas, visible, n, lay, theme, bounds,
+                         window_ms, visible_start_ms, candle_duration_ms);
+
+    // 5.5. Moving-average overlay lines (SMA/EMA) on the price pane, over the
+    //      candles. They share the candle price scale and don't reserve a pane.
+    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 (session, configurable reset) — a single price-pane line
+    //      that breaks at each session reset (vwap_breaks).
+    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, vwap_color, vwap_width, brk);
+        }
+    }
+
+    // 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.
+    SkPaint axis_bg;
+    axis_bg.setColor(theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(
+        SkRect::MakeXYWH(0, vroom::x_axis_top(lay), candle_right,
+                         lay.x_axis_height_px),
+        axis_bg);
+    const float axis_block_w = width_px - candle_right;
+    canvas->drawRect(
+        SkRect::MakeXYWH(candle_right, 0, axis_block_w, height_px),
+        axis_bg);
+
+    // 7. Labels (read from y_fades / x_fades, no state mutation here)
+    vroom::labels::draw_y_labels(canvas, *this, lay, bounds);
+    vroom::labels::draw_x_labels(canvas, *this, lay);
+
+    // 7.5. Current-price line + box — above labels so the box covers any label
+    //      it overlaps; tracks the latest close as the price scale moves.
+    vroom::price_indicator::draw(canvas, *this, lay, bounds,
+                                 candle_right, candle_area_h);
+
+    // 7.6. Indicator panes stacked below the candles, ordered by enable
+    //      sequence (most recently enabled at the bottom). Each pane is
+    //      INDICATOR_HEIGHT_FRAC of the height; the candle pane already shrank
+    //      to fit them (see layout()).
+    if (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_enabled && 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;
+        }
+    }
+
+    // 7.7. Crosshair — drawn last so it sits on top of everything, including the
+    //      indicator panes. The vertical line runs down to x_axis_top so it
+    //      stays visible across the candle area and all below-chart panes; the
+    //      horizontal line + ring stay in the price pane (clamped to
+    //      candle_area_h).
+    if (crosshair_active) {
+        const float snap_x = vroom::snap_x_to_candle(
+            lay, visible, n, candle_duration_ms, visible_start_ms, window_ms,
+            crosshair_x_px);
+        vroom::crosshair::draw(canvas, *this, candle_right, candle_area_h,
+                               vroom::x_axis_top(lay), snap_x);
+    }
+
+    // 8. GC fades that have fully faded out and aren't coming back.
+    vroom::labels::gc_y_fades(*this);
+    vroom::labels::gc_x_fades(*this);
+}
+
+void VroomChart::rebuild_chart_picture() {
+    // Compute dt for fade animations. We cap large gaps (resume from
+    // background, long idle) so we don't snap animations to completion.
+    auto now = std::chrono::steady_clock::now();
+    float dt = 0.f;
+    if (anim_started) {
+        dt = std::chrono::duration<float>(now - last_anim_tick).count();
+        if (dt > 0.1f) dt = 0.f;
+    }
+    last_anim_tick = now;
+    anim_started = true;
+    last_dt_seconds = dt;
+
+    SkPictureRecorder recorder;
+    SkCanvas* canvas = recorder.beginRecording(SkRect::MakeWH(width_px, height_px));
+    draw_chart(canvas);
+    chart_picture = recorder.finishRecordingAsPicture();
+    chart_dirty = false;
+}
+
+bool VroomChart::is_animating_now() const {
+    for (const auto& f : y_fades) {
+        if (f.opacity != f.target) return true;
+    }
+    for (const auto& f : x_fades) {
+        if (f.opacity != f.target) return true;
+    }
+    return false;
+}
+
+// chart_internal.h exports — bridge layer (JSI HostObject) consumers.
+
+namespace vroom {
+
+sk_sp<SkPicture> render_chart_picture(VroomChart* chart) {
+    if (!chart) return nullptr;
+    if (chart->chart_dirty || !chart->chart_picture || chart->is_animating_now()) {
+        chart->rebuild_chart_picture();
+    }
+    return chart->chart_picture;
+}
+
+bool is_animating(VroomChart* chart) {
+    return chart ? chart->is_animating_now() : false;
+}
+
+}  // namespace vroom