react-native-vroom-chart 0.4.0 → 0.6.0

package/cpp/VroomChartHostObject.cpp

@@ -1,6 +1,8 @@
 #include "VroomChartHostObject.h"
 
 #include <cstring>
+#include <string>
+#include <vector>
 
 #include "chart_internal.h"
 #include "vroom/vroom_chart.h"
@@ -27,7 +29,7 @@ ChartHostObject::~ChartHostObject() {
 std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
     jsi::Runtime& rt) {
   std::vector<jsi::PropNameID> out;
-  out.reserve(24);
+  out.reserve(29);
   out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
@@ -51,10 +53,77 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   out.push_back(jsi::PropNameID::forAscii(rt, "setMACD"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setOverlays"));
   out.push_back(jsi::PropNameID::forAscii(rt, "setVWAP"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setBollinger"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "coordAt"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLines"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "hitTestPriceLine"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineHover"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setPriceLineDrag"));
   out.push_back(jsi::PropNameID::forAscii(rt, "render"));
   return out;
 }
 
+#if defined(__ANDROID__)
+// Android only: RN-Skia is compiled into its own librnskia.so, separate from
+// libvroomchart.so. Constructing a RNSkia::JsiSkPicture directly here (as iOS
+// does, below) gives it a vtable/typeinfo from *our* .so; when RN-Skia's own
+// compiled code later consumes it (e.g. Convertor.h's
+// `getPropertyValue<sk_sp<SkPicture>>`, which does
+// `value.asObject(rt).asHostObject<JsiSkPicture>(rt)` — a dynamic_pointer_cast
+// under the hood), the cast fails cross-.so with "Object is not a HostObject
+// of desired type", because the object's *runtime* type was never actually
+// compiled inside librnskia.so. iOS statically links everything into one
+// binary, so no such mismatch exists there.
+//
+// The fix: build the picture through RN-Skia's own public JS API instead
+// (`Skia.Picture.MakePicture(bytes)`, the same call `require(...).png`-style
+// static pictures use), so the resulting JsiSkPicture is genuinely
+// constructed by librnskia.so's own code. This costs a serialize +
+// re-parse of the picture's draw ops per call — real overhead on a gesture
+// hot path — but is the only ABI-safe option found so far. Revisit if
+// profiling shows this mattering (e.g. a merged-.so build, or a lighter
+// bridge that avoids the round trip).
+#include "include/core/SkData.h"
+
+namespace {
+class SkDataMutableBuffer : public facebook::jsi::MutableBuffer {
+ public:
+  explicit SkDataMutableBuffer(sk_sp<SkData> data) : data_(std::move(data)) {}
+  size_t size() const override { return data_->size(); }
+  uint8_t* data() override {
+    return const_cast<uint8_t*>(
+        static_cast<const uint8_t*>(data_->data()));
+  }
+
+ private:
+  sk_sp<SkData> data_;
+};
+}  // namespace
+
+static facebook::jsi::Value wrapPicture(facebook::jsi::Runtime& rt,
+                                       const sk_sp<SkPicture>& pic) {
+  if (!pic) return facebook::jsi::Value::null();
+  sk_sp<SkData> serialized = pic->serialize();
+  if (!serialized) return facebook::jsi::Value::null();
+
+  auto buffer = std::make_shared<SkDataMutableBuffer>(std::move(serialized));
+  jsi::ArrayBuffer arrayBuffer(rt, buffer);
+
+  auto skiaApi = rt.global().getProperty(rt, "SkiaApi");
+  if (!skiaApi.isObject()) return facebook::jsi::Value::null();
+  auto pictureFactory = skiaApi.asObject(rt).getProperty(rt, "Picture");
+  if (!pictureFactory.isObject()) return facebook::jsi::Value::null();
+  auto makePicture =
+      pictureFactory.asObject(rt).getPropertyAsFunction(rt, "MakePicture");
+
+  // Mirrors JsiSkPictureFactory::MakePicture's expected argument shape: an
+  // object with a `.buffer` property holding the ArrayBuffer (matching a
+  // Uint8Array-like value; the factory ignores everything else about it).
+  jsi::Object arg(rt);
+  arg.setProperty(rt, "buffer", arrayBuffer);
+  return makePicture.call(rt, arg);
+}
+#else
 // Shared helper: wraps a fresh picture for return to JS, with memory pressure
 // reported to Hermes so GC keeps up under gesture-rate churn.
 static facebook::jsi::Value wrapPicture(facebook::jsi::Runtime& rt,
@@ -65,6 +134,7 @@ static facebook::jsi::Value wrapPicture(facebook::jsi::Runtime& rt,
   return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(rt, host,
                                                      /*context=*/nullptr);
 }
+#endif
 
 jsi::Value ChartHostObject::get(jsi::Runtime& rt,
                                 const jsi::PropNameID& propName) {
@@ -551,6 +621,200 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  if (name == "setBollinger") {
+    // setBollinger({enabled, period, mult, source, basisKind, upperColor,
+    // upperWidth, middleColor, middleWidth, lowerColor, lowerWidth,
+    // fillEnabled, fillOpacity}) — Bollinger Bands overlay. No render; the
+    // next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setBollinger"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isObject()) return jsi::Value::undefined();
+          auto s = args[0].asObject(rt2);
+          VroomBollinger cfg{};
+          cfg.enabled = s.getProperty(rt2, "enabled").asBool() ? 1 : 0;
+          cfg.period = static_cast<int32_t>(
+              s.getProperty(rt2, "period").asNumber());
+          cfg.mult = static_cast<float>(
+              s.getProperty(rt2, "mult").asNumber());
+          cfg.source = static_cast<int32_t>(
+              s.getProperty(rt2, "source").asNumber());
+          cfg.basis_kind = static_cast<int32_t>(
+              s.getProperty(rt2, "basisKind").asNumber());
+          cfg.upper_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "upperColor").asNumber());
+          cfg.upper_width = static_cast<float>(
+              s.getProperty(rt2, "upperWidth").asNumber());
+          cfg.middle_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "middleColor").asNumber());
+          cfg.middle_width = static_cast<float>(
+              s.getProperty(rt2, "middleWidth").asNumber());
+          cfg.lower_color = static_cast<uint32_t>(
+              s.getProperty(rt2, "lowerColor").asNumber());
+          cfg.lower_width = static_cast<float>(
+              s.getProperty(rt2, "lowerWidth").asNumber());
+          cfg.fill_enabled =
+              s.getProperty(rt2, "fillEnabled").asBool() ? 1 : 0;
+          cfg.fill_opacity = static_cast<float>(
+              s.getProperty(rt2, "fillOpacity").asNumber());
+          vroom_chart_set_bollinger(chart_, &cfg);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "coordAt") {
+    // coordAt(x, y) -> { timeMs, price } | null. The continuous data coordinate
+    // at a pixel — not snapped to a candle slot. Null when there are no candles
+    // or the viewport is degenerate. No rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "coordAt"),
+        2,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::null();
+          VroomCoord c{};
+          if (!vroom_chart_coord_at(chart_,
+                                    static_cast<float>(args[0].asNumber()),
+                                    static_cast<float>(args[1].asNumber()), &c)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "timeMs", static_cast<double>(c.time_ms));
+          obj.setProperty(rt2, "price", c.price);
+          return obj;
+        });
+  }
+
+  if (name == "setPriceLines") {
+    // setPriceLines({ lines: [{ price, color, width, lineStyle, text, quantity,
+    // flags }, ...], bodyBg, fontSizePx, lineLengthFrac, align, hoverBoost }) —
+    // replaces the full set of price status lines. No render; the next render()
+    // picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setPriceLines"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1 || !args[0].isObject()) return jsi::Value::undefined();
+          auto cfg = args[0].asObject(rt2);
+          auto lines_val = cfg.getProperty(rt2, "lines");
+          if (!lines_val.isObject()) return jsi::Value::undefined();
+          auto lines_obj = lines_val.asObject(rt2);
+          if (!lines_obj.isArray(rt2)) return jsi::Value::undefined();
+          auto arr = lines_obj.asArray(rt2);
+          const size_t len = arr.size(rt2);
+          std::vector<VroomPriceLine> lines(len);
+          // Label storage, kept alive until set_price_lines has copied it.
+          std::vector<std::string> texts(len);
+          std::vector<std::string> quantities(len);
+          for (size_t i = 0; i < len; ++i) {
+            auto l = arr.getValueAtIndex(rt2, i).asObject(rt2);
+            lines[i].price = l.getProperty(rt2, "price").asNumber();
+            lines[i].color = static_cast<uint32_t>(
+                l.getProperty(rt2, "color").asNumber());
+            lines[i].width = static_cast<float>(
+                l.getProperty(rt2, "width").asNumber());
+            lines[i].line_style = static_cast<int32_t>(
+                l.getProperty(rt2, "lineStyle").asNumber());
+            texts[i] = l.getProperty(rt2, "text").asString(rt2).utf8(rt2);
+            quantities[i] =
+                l.getProperty(rt2, "quantity").asString(rt2).utf8(rt2);
+            lines[i].text = texts[i].c_str();
+            lines[i].quantity = quantities[i].c_str();
+            lines[i].flags = static_cast<int32_t>(
+                l.getProperty(rt2, "flags").asNumber());
+          }
+          VroomPriceLineStyle style{};
+          style.body_bg = static_cast<uint32_t>(
+              cfg.getProperty(rt2, "bodyBg").asNumber());
+          style.font_size_px = static_cast<float>(
+              cfg.getProperty(rt2, "fontSizePx").asNumber());
+          style.line_length_frac = static_cast<float>(
+              cfg.getProperty(rt2, "lineLengthFrac").asNumber());
+          style.align = static_cast<int32_t>(
+              cfg.getProperty(rt2, "align").asNumber());
+          style.hover_boost = static_cast<float>(
+              cfg.getProperty(rt2, "hoverBoost").asNumber());
+          vroom_chart_set_price_lines(chart_, lines.data(), lines.size(), &style);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "hitTestPriceLine") {
+    // hitTestPriceLine(x, y) -> { index, part } | null. `part` is 0 for the line
+    // or its label body (the drag target) and 1 for the close button. Cheap
+    // enough to call at gesture rate — no rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "hitTestPriceLine"),
+        2,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 2) return jsi::Value::null();
+          int32_t index = -1, part = -1;
+          if (!vroom_chart_hit_test_price_line(
+                  chart_, static_cast<float>(args[0].asNumber()),
+                  static_cast<float>(args[1].asNumber()), &index, &part)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "index", index);
+          obj.setProperty(rt2, "part", part);
+          return obj;
+        });
+  }
+
+  if (name == "setPriceLineHover") {
+    // setPriceLineHover(index, part) — highlight a price line's segment; -1
+    // clears. No hover on touch, so this exists for parity/pointer devices.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setPriceLineHover"),
+        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_set_price_line_hover(
+              chart_, static_cast<int32_t>(args[0].asNumber()),
+              static_cast<int32_t>(args[1].asNumber()));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setPriceLineDrag") {
+    // setPriceLineDrag(index, price) — live drag preview; index -1 ends it. The
+    // committed price is untouched: restate setPriceLines to apply a move.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setPriceLineDrag"),
+        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_set_price_line_drag(
+              chart_, static_cast<int32_t>(args[0].asNumber()),
+              args[1].asNumber());
+          return jsi::Value::undefined();
+        });
+  }
+
   if (name == "render") {
     return jsi::Function::createFromHostFunction(
         rt,

package/cpp/VroomJsiInstaller.cpp

@@ -40,7 +40,17 @@ static void ensureAxisTypeface(jsi::Runtime& runtime) {
   if (!ctx) return;
   auto mgr = ctx->createFontMgr();
   if (!mgr) return;
-  auto tf = mgr->matchFamilyStyle(nullptr, SkFontStyle());  // system default
+
+  // A null family name is meant to request "the platform default" — CoreText
+  // (iOS) honors that, but Android's SkFontMgr_New_Android does not: it
+  // returns null unless given an actual family name, even though its
+  // underlying font set (sans-serif, arial, ...) is perfectly populated. Fall
+  // back to "sans-serif" (Android's standard generic-family alias) whenever
+  // the null-family lookup comes back empty.
+  auto tf = mgr->matchFamilyStyle(nullptr, SkFontStyle());
+  if (!tf) {
+    tf = mgr->matchFamilyStyle("sans-serif", SkFontStyle());
+  }
   if (!tf) return;
   vroom::set_axis_typeface(tf);
   done = true;

package/cpp/VroomSkiaContext.cpp

@@ -12,13 +12,21 @@ std::shared_ptr<RNSkia::RNSkPlatformContext> getRNSkContext(
   if (!obj.isHostObject(runtime)) return nullptr;
   auto host = obj.asHostObject(runtime);
 
-  auto base = std::dynamic_pointer_cast<RNSkia::JsiSkHostObject>(host);
-  if (!base) return nullptr;
-
-  // The accessor class adds no fields; static_cast is safe even though the
-  // runtime type is JsiSkApi (a different JsiSkHostObject subclass). We only
-  // call the inherited non-virtual getContext() through this view.
-  auto* accessor = static_cast<HostObjectAccessor*>(base.get());
+  // `global.SkiaApi` is always installed by RN-Skia's own
+  // RNSkManager::installBindings() as exactly a `JsiSkApi` host object — never
+  // any other JsiSkHostObject subclass — so this cast is safe as a plain
+  // static_cast, without any RTTI check. We deliberately avoid
+  // dynamic_pointer_cast here: on Android, RN-Skia is compiled into its own
+  // librnskia.so, separate from libvroomchart.so, so a `JsiSkApi` constructed
+  // by librnskia.so's code carries typeinfo from that .so; a dynamic_cast
+  // performed here (in libvroomchart.so) sees an unmerged RTTI record for
+  // "the same" class and always fails, even though the object is perfectly
+  // valid to use. (Same underlying issue as the JsiSkPicture cross-.so cast
+  // documented in VroomChartHostObject.cpp — but there RN-Skia's own compiled
+  // code does the cast on an object *we* construct, so we can't avoid it;
+  // here *we* do the cast on an object *they* construct, so we can just skip
+  // the runtime check we don't need.)
+  auto* accessor = static_cast<HostObjectAccessor*>(host.get());
   return accessor->getContext();
 }
 

package/cpp/_core_include/vroom/vroom_chart.h

@@ -49,6 +49,26 @@ typedef struct VroomOverlay {
     float    width;   // stroke width in px
 } VroomOverlay;
 
+// Bollinger Bands overlay drawn on the price pane: a basis MA of `source` over
+// `period`, banded at ± `mult` × population standard deviation of the same
+// window. Per TradingView semantics the stdev always uses the window's
+// arithmetic mean, even when `basis_kind` selects an EMA basis line.
+typedef struct VroomBollinger {
+    int32_t  enabled;       // 0/1
+    int32_t  period;        // lookback in candles (clamped >= 1; default 20)
+    float    mult;          // stdev multiplier (clamped >= 0; default 2)
+    int32_t  source;        // 0=close,1=open,2=high,3=low,4=hl2,5=hlc3,6=ohlc4
+    int32_t  basis_kind;    // 0 = SMA, 1 = EMA
+    uint32_t upper_color;   // 0xAARRGGBB
+    float    upper_width;   // stroke px
+    uint32_t middle_color;
+    float    middle_width;
+    uint32_t lower_color;
+    float    lower_width;
+    int32_t  fill_enabled;  // 0/1: translucent fill between upper and lower
+    float    fill_opacity;  // 0..1, multiplied into upper_color's alpha
+} VroomBollinger;
+
 // A drawing anchor in data space (so a drawing tracks the candles on pan/zoom).
 typedef struct VroomDrawPoint {
     int64_t time_ms;  // epoch milliseconds (not snapped to a candle slot)
@@ -98,6 +118,44 @@ typedef struct VroomLiquidityStyle {
     float    width_frac;
 } VroomLiquidityStyle;
 
+// ---- Price status lines ---------------------------------------------------
+
+// Bit flags for VroomPriceLine::flags.
+typedef enum {
+    VROOM_PRICE_LINE_DRAGGABLE   = 1 << 0,  // the line can be dragged vertically
+    VROOM_PRICE_LINE_CLOSABLE    = 1 << 1,  // render the trailing close ("x") button
+    VROOM_PRICE_LINE_AXIS_LABEL  = 1 << 2,  // render the price badge in the y-axis strip
+    VROOM_PRICE_LINE_EXTEND_LEFT = 1 << 3,  // extend the line to the pane's left edge
+} VroomPriceLineFlags;
+
+// A consumer-supplied horizontal status line at a fixed price — the primitive
+// behind resting limit orders, take-profits, liquidation levels and the like.
+//
+// Visually: a line across the price pane ending in a label group made of a body
+// pill (`text`), an optional solid-filled `quantity` pill, and an optional close
+// button, plus an optional price badge in the y-axis strip.
+//
+// `text` / `quantity` are UTF-8 and copied internally, so the caller may free
+// them as soon as the call returns. A null or empty string hides that segment.
+typedef struct VroomPriceLine {
+    double      price;
+    uint32_t    color;       // 0xAARRGGBB — line, border, body text, close icon
+    float       width;       // stroke width in px
+    int32_t     line_style;  // 0 = solid, 1 = dotted, 2 = dashed
+    const char* text;        // body label
+    const char* quantity;    // trailing solid-fill segment
+    int32_t     flags;       // bitwise-or of VroomPriceLineFlags
+} VroomPriceLine;
+
+// Layout/style shared by every price line, so the per-line struct stays small.
+typedef struct VroomPriceLineStyle {
+    uint32_t body_bg;           // translucent body/close-button pill fill (0xAARRGGBB)
+    float    font_size_px;      // 0 = inherit VROOM_FLOAT_AXIS_FONT_SIZE_PX
+    float    line_length_frac;  // 0..1 of pane width: the label group's right-edge inset
+    int32_t  align;             // 0 = left, 1 = center, 2 = right
+    float    hover_boost;       // brightness multiplier for the hovered segment (1 = flat)
+} VroomPriceLineStyle;
+
 // A continuous data coordinate at a pixel position (no candle snapping). Used to
 // translate a drawing-tool click into a data-space anchor.
 typedef struct VroomCoord {
@@ -321,6 +379,11 @@ void vroom_chart_set_overlays(VroomChart* chart, const VroomOverlay* overlays,
 void vroom_chart_set_vwap(VroomChart* chart, bool enabled, int reset_offset_min,
                           uint32_t color, float width);
 
+// Configures the Bollinger Bands overlay (three price-pane lines + an optional
+// translucent fill between the bands; no pane is reserved). Color/width/fill
+// changes only re-render; enabled/period/mult/source/basis changes recompute.
+void vroom_chart_set_bollinger(VroomChart* chart, const VroomBollinger* cfg);
+
 // ---- Drawings (line annotations) ------------------------------------------
 
 // Replaces the full set of committed line drawings (data-anchored, so they track
@@ -365,6 +428,38 @@ void vroom_chart_translate_drawing(VroomChart* chart, int32_t index,
 void vroom_chart_set_liquidity(VroomChart* chart, const VroomBand* bands,
                                size_t count, const VroomLiquidityStyle* style);
 
+// ---- Price status lines ---------------------------------------------------
+
+// Replaces the full set of price status lines and their shared style. Lines
+// render on the price pane above the axis labels (so their badges cover any
+// label they overlap) and below the crosshair. A line whose price maps outside
+// the price pane is skipped rather than clamped. Pass count 0 to clear;
+// `style` may be null when count is 0.
+void vroom_chart_set_price_lines(VroomChart* chart, const VroomPriceLine* lines,
+                                 size_t count,
+                                 const VroomPriceLineStyle* style);
+
+// Hit-tests pixel (x_px, y_px) against the price lines. On a hit, fills
+// *out_index with the line index and *out_part with 0 (the line or its label
+// body — the drag target) or 1 (the close button), and returns true. When
+// several lines are within tolerance the nearest in y wins. Only draggable
+// lines report part 0 and only closable lines report part 1. Returns false on a
+// miss (out params untouched). Either out pointer may be null.
+bool vroom_chart_hit_test_price_line(VroomChart* chart, float x_px, float y_px,
+                                     int32_t* out_index, int32_t* out_part);
+
+// Marks a price line's segment as hovered so it renders highlighted. `index` -1
+// clears the hover. `part` matches vroom_chart_hit_test_price_line.
+void vroom_chart_set_price_line_hover(VroomChart* chart, int32_t index,
+                                      int32_t part);
+
+// Drives the live drag preview: the line, its label and its badge render at
+// `price` instead of the committed one, and a faint ghost marks where it
+// started. `index` -1 ends the preview. The committed price is never mutated —
+// the host applies (or rejects) the new price by restating its lines.
+void vroom_chart_set_price_line_drag(VroomChart* chart, int32_t index,
+                                     double price);
+
 // Sets the transient in-progress "draft" the drawing tool shows while the user
 // places points. Node A is always shown; when `has_b`, node B is shown too.
 // `guide != 0` also draws the live preview (a guideline for a line, or a preview

package/cpp/_core_src/bollinger.cpp

@@ -0,0 +1,43 @@
+#include "bollinger.h"
+
+#include <cmath>  // std::nan, std::sqrt
+
+#include "ma.h"
+
+namespace vroom::bollinger {
+
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower) {
+    vroom::ma::compute(candles, n, basis_kind, period, source, middle);
+    upper.assign(n, std::nan(""));
+    lower.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    std::vector<double> src(n);
+    for (std::size_t i = 0; i < n; ++i) src[i] = vroom::ma::source_value(candles[i], source);
+
+    // Two-pass stdev around the true window mean per bar. O(n·period), but
+    // numerically stable — the rolling Σx²−n·mean² form cancels catastrophically
+    // on large prices with small deviations (e.g. BTC-scale values).
+    for (std::size_t i = P - 1; i < n; ++i) {
+        const std::size_t s = i + 1 - P;
+        double mean = 0.0;
+        for (std::size_t j = s; j <= i; ++j) mean += src[j];
+        mean /= static_cast<double>(P);
+        double var = 0.0;
+        for (std::size_t j = s; j <= i; ++j) {
+            const double d = src[j] - mean;
+            var += d * d;
+        }
+        var /= static_cast<double>(P);
+        const double band = mult * std::sqrt(var);
+        upper[i] = middle[i] + band;
+        lower[i] = middle[i] - band;
+    }
+}
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/bollinger.h

@@ -0,0 +1,31 @@
+// Bollinger Bands over a candle source series — pure, no Skia, so it builds
+// into the unit-test target. Drawn as price-pane overlay lines + a band fill.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::bollinger {
+
+// Computes the three band series over [candles, candles+n). `period` is clamped
+// to >= 1; `mult` is the standard-deviation multiplier. `source` is a
+// vroom::ma::Source index and `basis_kind` a vroom::ma::Kind (SMA/EMA).
+//
+//   middle = ma::compute(basis_kind, period, source)
+//   upper/lower = middle ± mult * population stdev of source over the trailing
+//                 period window
+//
+// The stdev always uses the window's arithmetic mean, even when basis_kind
+// selects an EMA basis line (TradingView semantics).
+//
+// Each output is resized to n; values are NaN for i < period-1 and when
+// n < period.
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             double mult, int source, int basis_kind,
+             std::vector<double>& middle, std::vector<double>& upper,
+             std::vector<double>& lower);
+
+}  // namespace vroom::bollinger

package/cpp/_core_src/chart.cpp

@@ -18,6 +18,7 @@
 #include "include/core/SkRect.h"
 #pragma clang diagnostic pop
 
+#include "bollinger.h"
 #include "candles.h"
 #include "chart_internal.h"
 #include "crosshair.h"
@@ -29,6 +30,7 @@
 #include "macd.h"
 #include "macd_pane.h"
 #include "price_indicator.h"
+#include "price_lines.h"
 #include "rsi.h"
 #include "rsi_pane.h"
 #include "volume.h"
@@ -100,6 +102,15 @@ void VroomChart::ensure_vwap() {
     vwap_dirty = false;
 }
 
+void VroomChart::ensure_bollinger() {
+    if (!bollinger.enabled || !bollinger_dirty) return;
+    vroom::bollinger::compute(candles.data(), candles.size(), bollinger.period,
+                              bollinger.mult, bollinger.source,
+                              bollinger.basis_kind, bb_middle_cache,
+                              bb_upper_cache, bb_lower_cache);
+    bollinger_dirty = false;
+}
+
 void VroomChart::draw_chart(SkCanvas* canvas) {
     const auto lay = layout();
 
@@ -149,6 +160,23 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::liquidity::draw(canvas, *this, lay, bounds, candle_right,
                            candle_area_h);
 
+    // 4.7. Bollinger Band fill — the translucent region between the upper and
+    //      lower bands, behind the candles so their bull/bear colors stay
+    //      untinted. The band lines themselves draw above the candles (5.65).
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        if (bollinger.fill_enabled &&
+            bb_upper_cache.size() == candles.size() &&
+            bb_lower_cache.size() == candles.size()) {
+            vroom::ma_overlay::fill_between(
+                canvas, lay, bounds, visible, n,
+                bb_upper_cache.data() + range.start,
+                bb_lower_cache.data() + range.start, window_ms,
+                visible_start_ms, candle_duration_ms, candle_right,
+                candle_area_h, bollinger.upper_color, bollinger.fill_opacity);
+        }
+    }
+
     // 5. Price series — candles, a close-price line, or a blend of the two during
     //    the candle↔line morph. `morph_fade` crossfades candles→line and
     //    `morph_collapse` folds each candle toward its close (the line vertex).
@@ -202,6 +230,28 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
         }
     }
 
+    // 5.65. Bollinger Band lines — upper, lower, then the basis last so it
+    //       reads on top where the bands pinch. Same price scale as the
+    //       candles; the fill went down in 4.7.
+    if (bollinger.enabled) {
+        ensure_bollinger();
+        const std::size_t sz = candles.size();
+        if (bb_upper_cache.size() == sz && bb_lower_cache.size() == sz &&
+            bb_middle_cache.size() == sz) {
+            const auto stroke = [&](const std::vector<double>& cache,
+                                    uint32_t color, float width) {
+                vroom::ma_overlay::draw(canvas, lay, bounds, visible, n,
+                                        cache.data() + range.start, window_ms,
+                                        visible_start_ms, candle_duration_ms,
+                                        candle_right, candle_area_h, color,
+                                        width);
+            };
+            stroke(bb_upper_cache, bollinger.upper_color, bollinger.upper_width);
+            stroke(bb_lower_cache, bollinger.lower_color, bollinger.lower_width);
+            stroke(bb_middle_cache, bollinger.middle_color, bollinger.middle_width);
+        }
+    }
+
     // 5.7. Drawing annotations (committed line tools + the in-progress draft).
     //      On the price pane above the candles/overlays, below the axis labels.
     vroom::drawings::draw(canvas, *this, lay, bounds, candle_right,
@@ -230,6 +280,12 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     vroom::price_indicator::draw(canvas, *this, lay, bounds,
                                  candle_right, candle_area_h);
 
+    // 7.55. Consumer-supplied price status lines — same tier as the current-price
+    //       indicator (their badges must cover the labels underneath), but after
+    //       it so a resting order at the last close stays readable.
+    vroom::price_lines::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