react-native-vroom-chart 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Darion Welch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# react-native-vroom-chart
+
+React Native component for the vroom Skia candlestick chart.
+
+```tsx
+import { VroomChart } from 'react-native-vroom-chart';
+
+<VroomChart
+  candles={candles}
+  width={width}
+  height={240}
+  onCrosshair={(e) => console.log(e)}
+/>
+```
+
+## Peer dependencies
+
+- `react-native` ≥ 0.76
+- `@shopify/react-native-skia` ≥ 1.5 — provides the Skia runtime we draw into
+- `react-native-gesture-handler` ≥ 2.16 — long-press / pan / pinch recognition
+
+## Status
+
+Pre-alpha. The TS layer renders a placeholder chart area with working
+gestures (long-press crosshair); the actual candle rendering will move to
+the C++ core (`@vroomchart/core`) via JSI once that bridge lands. See
+`cpp/README.md`.

package/android/README.md

@@ -0,0 +1,7 @@
+# Android shim (placeholder)
+
+When native is wired up, this directory will hold the JNI bindings and a
+Java/Kotlin view that hosts the chart and forwards gestures into the C++ core.
+
+`build.gradle` (also to come) will compile `cpp/` + this directory + the
+linked `@vroomchart/core` static library via CMake.

package/cpp/README.md

@@ -0,0 +1,11 @@
+# JSI bridge (placeholder)
+
+When the JS API is stable enough to wire to native, this directory will hold:
+
+- `VroomChartJSI.h` / `VroomChartJSI.cpp` — JSI HostObject(s) exposing the C
+  facade from `@vroomchart/core` to JS.
+- Glue for borrowing an `SkCanvas` from `@shopify/react-native-skia` and
+  passing it to `vroom_chart_draw`.
+
+Until then the JS layer fakes the rendering with RN-Skia primitives so we
+can iterate on the component API without native rebuilds.

package/cpp/VroomChartHostObject.cpp

@@ -0,0 +1,458 @@
+#include "VroomChartHostObject.h"
+
+#include <cstring>
+
+#include "chart_internal.h"
+#include "vroom/vroom_chart.h"
+
+// RN-Skia headers.
+#include "JsiSkHostObjects.h"
+#include "JsiSkPicture.h"
+
+namespace vroom {
+
+namespace jsi = facebook::jsi;
+
+ChartHostObject::ChartHostObject() {
+  chart_ = vroom_chart_create(nullptr, nullptr);
+}
+
+ChartHostObject::~ChartHostObject() {
+  if (chart_) {
+    vroom_chart_destroy(chart_);
+    chart_ = nullptr;
+  }
+}
+
+std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
+    jsi::Runtime& rt) {
+  std::vector<jsi::PropNameID> out;
+  out.reserve(19);
+  out.push_back(jsi::PropNameID::forAscii(rt, "setCandles"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setSize"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setColor"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setVisibleRange"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "pan"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "translate"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "zoom"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "scalePriceAxis"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "scaleTimeAxis"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getAxisMetrics"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "isAnimating"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setCrosshair"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "clearCrosshair"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "getCrosshairCandle"));
+  out.push_back(jsi::PropNameID::forAscii(rt, "setRSI"));
+  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, "render"));
+  return out;
+}
+
+// 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,
+                                       const sk_sp<SkPicture>& pic) {
+  if (!pic) return facebook::jsi::Value::null();
+  auto host =
+      std::make_shared<RNSkia::JsiSkPicture>(/*context=*/nullptr, pic);
+  return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(rt, host,
+                                                     /*context=*/nullptr);
+}
+
+jsi::Value ChartHostObject::get(jsi::Runtime& rt,
+                                const jsi::PropNameID& propName) {
+  const std::string name = propName.utf8(rt);
+
+  if (name == "setCandles") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setCandles"),
+        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 obj = args[0].asObject(rt2);
+          if (!obj.isArrayBuffer(rt2)) return jsi::Value::undefined();
+          auto buf = obj.getArrayBuffer(rt2);
+
+          const size_t bytes = buf.size(rt2);
+          const size_t n = bytes / sizeof(VroomCandle);
+          if (n == 0 || n * sizeof(VroomCandle) != bytes) {
+            return jsi::Value::undefined();
+          }
+          const auto* data =
+              reinterpret_cast<const VroomCandle*>(buf.data(rt2));
+          vroom_chart_set_candles(chart_, data, n);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setSize") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setSize"),
+        3,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 3) return jsi::Value::undefined();
+          const float w = static_cast<float>(args[0].asNumber());
+          const float h = static_cast<float>(args[1].asNumber());
+          const float r = static_cast<float>(args[2].asNumber());
+          vroom_chart_set_size(chart_, w, h, r);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setColor") {
+    // setColor(keyIndex, argb) — keyIndex is a VroomColorKey; argb is a packed
+    // 0xAARRGGBB integer. The core bounds-checks the key and marks dirty.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setColor"),
+        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();
+          const int key = static_cast<int>(args[0].asNumber());
+          const uint32_t argb =
+              static_cast<uint32_t>(args[1].asNumber());
+          vroom_chart_set_color(chart_, static_cast<VroomColorKey>(key), argb);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setVisibleRange") {
+    // Pass 0,0 to clear (show all).
+    // Timestamps are Number on the JS side — fine for ms-since-epoch since
+    // those fit in 53 bits well past year 285,000.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setVisibleRange"),
+        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();
+          const int64_t s = static_cast<int64_t>(args[0].asNumber());
+          const int64_t e = static_cast<int64_t>(args[1].asNumber());
+          vroom_chart_set_visible_range(chart_, s, e);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "pan") {
+    // pan(dx, dy) -> JsiSkPicture
+    // Mutates the visible range and renders in one JSI call so gesture
+    // handlers don't pay round-trip overhead twice per frame.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "pan"),
+        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();
+          const float dx = static_cast<float>(args[0].asNumber());
+          const float dy = static_cast<float>(args[1].asNumber());
+          vroom_chart_pan(chart_, dx, dy);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "translate") {
+    // translate(dx, dy) -> JsiSkPicture — shifts time + price bounds
+    // without rescaling. Wired to the two-finger pan gesture in JS.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "translate"),
+        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();
+          const float dx = static_cast<float>(args[0].asNumber());
+          const float dy = static_cast<float>(args[1].asNumber());
+          vroom_chart_translate(chart_, dx, dy);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "zoom") {
+    // zoom(scaleX, scaleY, fx, fy) -> JsiSkPicture
+    // Per-axis multiplicative factors since the last call (> 1 = zoom in).
+    // scaleX scales the time window around fx; scaleY scales price around fy.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "zoom"),
+        4,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 4) return jsi::Value::null();
+          const float sx = static_cast<float>(args[0].asNumber());
+          const float sy = static_cast<float>(args[1].asNumber());
+          const float fx = static_cast<float>(args[2].asNumber());
+          const float fy = static_cast<float>(args[3].asNumber());
+          vroom_chart_zoom(chart_, sx, sy, fx, fy);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "scalePriceAxis") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "scalePriceAxis"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::null();
+          const float dy = static_cast<float>(args[0].asNumber());
+          vroom_chart_scale_price_axis(chart_, dy);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "scaleTimeAxis") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "scaleTimeAxis"),
+        1,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 1) return jsi::Value::null();
+          const float dx = static_cast<float>(args[0].asNumber());
+          vroom_chart_scale_time_axis(chart_, dx);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "getAxisMetrics") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getAxisMetrics"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          float yw = 0.f, xh = 0.f, ih = 0.f;
+          vroom_chart_get_axis_metrics(chart_, &yw, &xh, &ih);
+          jsi::Object obj(rt2);
+          obj.setProperty(rt2, "yAxisWidth", static_cast<double>(yw));
+          obj.setProperty(rt2, "xAxisHeight", static_cast<double>(xh));
+          obj.setProperty(rt2, "indicatorHeight", static_cast<double>(ih));
+          return obj;
+        });
+  }
+
+  if (name == "isAnimating") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "isAnimating"),
+        0,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          return jsi::Value(is_animating(chart_));
+        });
+  }
+
+  if (name == "setCrosshair") {
+    // setCrosshair(x, y) -> JsiSkPicture. Activates the crosshair at (x, y) in
+    // pixels (y already lifted above the touch on the JS side) and renders.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setCrosshair"),
+        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();
+          const float x = static_cast<float>(args[0].asNumber());
+          const float y = static_cast<float>(args[1].asNumber());
+          vroom_chart_set_crosshair(chart_, x, y);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "clearCrosshair") {
+    // clearCrosshair() -> JsiSkPicture. Hides the crosshair and renders.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "clearCrosshair"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          vroom_chart_clear_crosshair(chart_);
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  if (name == "getCrosshairCandle") {
+    // getCrosshairCandle() -> { timeMs, open, high, low, close, volume } | null.
+    // The OHLCV of the candle the crosshair currently snaps to; null when the
+    // crosshair is inactive. Cheap to call at gesture rate — no rendering.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "getCrosshairCandle"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          VroomCandle c{};
+          if (!vroom_chart_get_crosshair_candle(chart_, &c)) {
+            return jsi::Value::null();
+          }
+          jsi::Object obj(rt2);
+          // time_ms fits in 53 bits well past year 285,000, so Number is exact.
+          obj.setProperty(rt2, "timeMs", static_cast<double>(c.time_ms));
+          obj.setProperty(rt2, "open", c.open);
+          obj.setProperty(rt2, "high", c.high);
+          obj.setProperty(rt2, "low", c.low);
+          obj.setProperty(rt2, "close", c.close);
+          obj.setProperty(rt2, "volume", c.volume);
+          return obj;
+        });
+  }
+
+  if (name == "setRSI") {
+    // setRSI(enabled, period, upperBand, lowerBand, maEnabled, maPeriod) —
+    // configures the RSI pane. No render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setRSI"),
+        6,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 6) return jsi::Value::undefined();
+          const bool enabled = args[0].asBool();
+          const int period = static_cast<int>(args[1].asNumber());
+          const double upper = args[2].asNumber();
+          const double lower = args[3].asNumber();
+          const bool ma_enabled = args[4].asBool();
+          const int ma_period = static_cast<int>(args[5].asNumber());
+          vroom_chart_set_rsi(chart_, enabled, period, upper, lower, ma_enabled,
+                              ma_period);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setMACD") {
+    // setMACD(enabled, fast, slow, signal) — configures the MACD pane. No
+    // render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setMACD"),
+        4,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 4) return jsi::Value::undefined();
+          const bool enabled = args[0].asBool();
+          const int fast = static_cast<int>(args[1].asNumber());
+          const int slow = static_cast<int>(args[2].asNumber());
+          const int signal = static_cast<int>(args[3].asNumber());
+          vroom_chart_set_macd(chart_, enabled, fast, slow, signal);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setOverlays") {
+    // setOverlays([{ kind, period, source, color, width }, ...]) — replaces the
+    // full set of MA/EMA overlay lines. No render; the next render() picks it up.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setOverlays"),
+        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 obj = args[0].asObject(rt2);
+          if (!obj.isArray(rt2)) return jsi::Value::undefined();
+          auto arr = obj.asArray(rt2);
+          const size_t len = arr.size(rt2);
+          std::vector<VroomOverlay> overlays;
+          overlays.reserve(len);
+          for (size_t i = 0; i < len; ++i) {
+            auto o = arr.getValueAtIndex(rt2, i).asObject(rt2);
+            VroomOverlay ov;
+            ov.kind = static_cast<int32_t>(
+                o.getProperty(rt2, "kind").asNumber());
+            ov.period = static_cast<int32_t>(
+                o.getProperty(rt2, "period").asNumber());
+            ov.source = static_cast<int32_t>(
+                o.getProperty(rt2, "source").asNumber());
+            ov.color = static_cast<uint32_t>(
+                o.getProperty(rt2, "color").asNumber());
+            ov.width = static_cast<float>(
+                o.getProperty(rt2, "width").asNumber());
+            overlays.push_back(ov);
+          }
+          vroom_chart_set_overlays(chart_, overlays.data(), overlays.size());
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "setVWAP") {
+    // setVWAP(enabled, resetOffsetMin, color, width) — session VWAP overlay.
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "setVWAP"),
+        4,
+        [this](jsi::Runtime& /*rt2*/,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* args,
+               size_t count) -> jsi::Value {
+          if (count < 4) return jsi::Value::undefined();
+          const bool enabled = args[0].asBool();
+          const int reset = static_cast<int>(args[1].asNumber());
+          const uint32_t color = static_cast<uint32_t>(args[2].asNumber());
+          const float width = static_cast<float>(args[3].asNumber());
+          vroom_chart_set_vwap(chart_, enabled, reset, color, width);
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (name == "render") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "render"),
+        0,
+        [this](jsi::Runtime& rt2,
+               const jsi::Value& /*thisVal*/,
+               const jsi::Value* /*args*/,
+               size_t /*count*/) -> jsi::Value {
+          return wrapPicture(rt2, render_chart_picture(chart_));
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+}  // namespace vroom

package/cpp/VroomChartHostObject.h

@@ -0,0 +1,36 @@
+// Per-chart JSI HostObject. One instance is created by
+// VroomChartJSI.create() and held by the React component. When the JS object
+// is garbage collected, this destructor runs and deletes the underlying
+// VroomChart, freeing the candle buffer and any cached pictures.
+//
+// Methods exposed to JS:
+//   setCandles(arrayBuffer)   — copies packed VroomCandle[] into the core
+//   setSize(width, height, pxRatio)
+//   render() -> JsiSkPicture  — returns the current chart picture
+
+#pragma once
+
+#include <memory>
+
+#include <jsi/jsi.h>
+
+struct VroomChart;
+
+namespace vroom {
+
+class ChartHostObject : public facebook::jsi::HostObject {
+ public:
+  ChartHostObject();
+  ~ChartHostObject() override;
+
+  facebook::jsi::Value get(facebook::jsi::Runtime& runtime,
+                           const facebook::jsi::PropNameID& name) override;
+
+  std::vector<facebook::jsi::PropNameID> getPropertyNames(
+      facebook::jsi::Runtime& runtime) override;
+
+ private:
+  VroomChart* chart_ = nullptr;
+};
+
+}  // namespace vroom

package/cpp/VroomJsiInstaller.cpp

@@ -0,0 +1,69 @@
+// Installs global.VroomChartJSI on the JSI runtime.
+//
+// API:
+//   VroomChartJSI.create() -> ChartHostObject
+//     methods on the returned object:
+//       setCandles(arrayBuffer)
+//       setSize(w, h, pxRatio)
+//       render() -> JsiSkPicture
+//
+// The host object's lifetime is managed by JS GC — when the React component
+// drops its reference, the underlying VroomChart is destroyed.
+
+#include "VroomJsiInstaller.h"
+
+#include <memory>
+
+#include "VroomChartHostObject.h"
+#include "VroomSkiaContext.h"
+
+#include "chart_internal.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkFontStyle.h"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+namespace vroom {
+
+namespace jsi = facebook::jsi;
+
+// Loads the system typeface once via RN-Skia's platform context and hands
+// it to the chart core. Retries on each create() until it succeeds (in case
+// SkiaApi isn't installed yet when our first chart instance is created).
+static void ensureAxisTypeface(jsi::Runtime& runtime) {
+  static bool done = false;
+  if (done) return;
+  auto ctx = vroom::getRNSkContext(runtime);
+  if (!ctx) return;
+  auto mgr = ctx->createFontMgr();
+  if (!mgr) return;
+  auto tf = mgr->matchFamilyStyle(nullptr, SkFontStyle());  // system default
+  if (!tf) return;
+  vroom::set_axis_typeface(tf);
+  done = true;
+}
+
+void installJsi(jsi::Runtime& runtime) {
+  auto create = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forAscii(runtime, "create"),
+      0,
+      [](jsi::Runtime& rt,
+         const jsi::Value& /*thisVal*/,
+         const jsi::Value* /*args*/,
+         size_t /*count*/) -> jsi::Value {
+        ensureAxisTypeface(rt);
+        auto host = std::make_shared<ChartHostObject>();
+        return jsi::Object::createFromHostObject(rt, host);
+      });
+
+  jsi::Object api(runtime);
+  api.setProperty(runtime, "create", std::move(create));
+
+  runtime.global().setProperty(runtime, "VroomChartJSI", std::move(api));
+}
+
+}  // namespace vroom

package/cpp/VroomJsiInstaller.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace vroom {
+
+// Installs `global.VroomChartJSI` on the given runtime. Idempotent.
+void installJsi(facebook::jsi::Runtime& runtime);
+
+}  // namespace vroom

package/cpp/VroomSkiaContext.cpp

@@ -0,0 +1,25 @@
+#include "VroomSkiaContext.h"
+
+namespace vroom {
+
+namespace jsi = facebook::jsi;
+
+std::shared_ptr<RNSkia::RNSkPlatformContext> getRNSkContext(
+    jsi::Runtime& runtime) {
+  auto val = runtime.global().getProperty(runtime, "SkiaApi");
+  if (!val.isObject()) return nullptr;
+  auto obj = val.asObject(runtime);
+  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());
+  return accessor->getContext();
+}
+
+}  // namespace vroom