react-native-vroom-chart 0.5.0 → 0.6.0

package/android/CMakeLists.txt

@@ -0,0 +1,143 @@
+# android/CMakeLists.txt
+#
+# Builds libvroomchart.so from the same platform-agnostic JSI glue and chart
+# core the iOS podspec compiles (see ../react-native-vroom-chart.podspec),
+# plus this directory's small JNI entry point (src/main/cpp/VroomChartJni.cpp).
+#
+# RN-Skia's headers (JsiSkHostObjects.h, RNSkPlatformContext.h — needed by
+# ../cpp/VroomSkiaContext.cpp) aren't consumed via CMake's prefab mechanism;
+# instead we point directly at @shopify/react-native-skia's `cpp/` sources,
+# mirroring the podspec's `require.resolve('@shopify/react-native-skia/package.json')`
+# trick (VROOM_SKIA_CPP_DIR is computed the same way in build.gradle).
+#
+# IMPORTANT — SK_GRAPHITE ABI note: RNSkPlatformContext's vtable layout
+# differs depending on whether SK_GRAPHITE was defined when RN-Skia's own
+# Android build compiled RNSkAndroidPlatformContext (the concrete class whose
+# vtable we call into via VroomSkiaContext.cpp's `ctx->createFontMgr()`).
+# We must define SK_GRAPHITE identically to however RN-Skia's own CMakeLists
+# (android/CMakeLists.txt) decided it, or virtual calls resolve to the wrong
+# vtable slot. We replicate their libskia.a symbol probe below rather than
+# hard-coding an assumption.
+cmake_minimum_required(VERSION 3.22)
+project(vroomchart)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+find_package(ReactAndroid REQUIRED CONFIG)
+# Prefab package name matches the Gradle project name AGP autolinking assigns
+# RN-Skia (":shopify_react-native-skia"), not the "rnskia" module name inside
+# its own `prefab { rnskia { ... } }` block — that block key becomes the
+# `shopify_react-native-skia::rnskia` *target* name below, not the package.
+find_package(shopify_react-native-skia REQUIRED CONFIG)
+
+if(NOT DEFINED VROOM_SKIA_CPP_DIR)
+  message(FATAL_ERROR "VROOM_SKIA_CPP_DIR not set — passed from android/build.gradle.")
+endif()
+
+# RN-Skia's own package root is one level up from its cpp/ dir; its prebuilt
+# Skia static libs live at <root>/libs/android/<abi>/libskia.a.
+get_filename_component(VROOM_SKIA_PKG_DIR "${VROOM_SKIA_CPP_DIR}" DIRECTORY)
+set(VROOM_SKIA_LIBS_DIR "${VROOM_SKIA_PKG_DIR}/libs/android/${ANDROID_ABI}")
+
+# Our chart core calls Skia types (SkCanvas, SkPaint, SkFont, ...) and
+# RN-Skia's own JSI plumbing (RNJsi::JsiHostObject, JsiSkPicture, ...)
+# directly — none of that is header-only, and we need *both* libraries:
+#   - librnskia.so (RN-Skia's prefab-published `rnskia` module, consumed above
+#     via `implementation project(":shopify_react-native-skia")`) for RNJsi's
+#     own symbols (JsiHostObject, JsiSkPicture, ...), which only exist there.
+#   - libskia.a (RN-Skia's bundled prebuilt Skia static lib) for direct Skia
+#     calls (SkCanvas::drawRect, SkFont, ...): librnskia.so links libskia.a
+#     internally but doesn't re-export its symbols, so linking librnskia.so
+#     alone leaves every direct Skia call undefined.
+# Recompiling RN-Skia's cpp/jsi/*.cpp ourselves instead of linking librnskia.so
+# was considered and rejected — it would duplicate RNJsi's symbols (and their
+# static/global state) across two separately-loaded .so's, which is fine on
+# iOS's single static binary but not here.
+add_library(vroom_skia_prebuilt STATIC IMPORTED)
+set_property(TARGET vroom_skia_prebuilt PROPERTY
+  IMPORTED_LOCATION "${VROOM_SKIA_LIBS_DIR}/libskia.a")
+
+set(SK_GRAPHITE_AVAILABLE OFF)
+if(EXISTS "${VROOM_SKIA_LIBS_DIR}/libskia.a")
+  execute_process(
+    COMMAND nm "${VROOM_SKIA_LIBS_DIR}/libskia.a"
+    COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+    OUTPUT_VARIABLE VROOM_NM_OUTPUT
+    ERROR_QUIET
+    RESULT_VARIABLE VROOM_NM_RESULT
+  )
+  if(VROOM_NM_RESULT EQUAL 0 AND NOT "${VROOM_NM_OUTPUT}" STREQUAL "")
+    set(SK_GRAPHITE_AVAILABLE ON)
+  endif()
+endif()
+
+# The chart core (shared across iOS/Android/WASM — see ../../core/CMakeLists.txt).
+set(VROOM_CORE_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/_core_include")
+set(VROOM_CORE_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/_core_src")
+file(GLOB VROOM_CORE_SOURCES CONFIGURE_DEPENDS "${VROOM_CORE_SRC_DIR}/*.cpp")
+
+add_library(vroomchart SHARED
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomJsiInstaller.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomChartHostObject.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp/VroomSkiaContext.cpp"
+  ${VROOM_CORE_SOURCES}
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/VroomChartJni.cpp"
+)
+
+target_include_directories(vroomchart PRIVATE
+  "${VROOM_CORE_INCLUDE_DIR}"
+  "${VROOM_CORE_SRC_DIR}"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../cpp"
+  # RN-Skia headers — mirrors its own android/CMakeLists.txt include list.
+  "${VROOM_SKIA_CPP_DIR}"
+  "${VROOM_SKIA_CPP_DIR}/api"
+  "${VROOM_SKIA_CPP_DIR}/jsi"
+  "${VROOM_SKIA_CPP_DIR}/rnskia"
+  "${VROOM_SKIA_CPP_DIR}/rnskia/values"
+  "${VROOM_SKIA_CPP_DIR}/utils"
+  "${VROOM_SKIA_CPP_DIR}/skia"
+  "${VROOM_SKIA_CPP_DIR}/dawn/include"
+  # RNSkPlatformContext.h pulls in ReactCommon/CallInvoker.h directly, which
+  # isn't part of the prefab-published jsi headers — same dirs RN-Skia's own
+  # android/CMakeLists.txt adds for the same reason.
+  "${REACT_NATIVE_DIR}/ReactCommon"
+  "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+  "${REACT_NATIVE_DIR}/ReactCommon/runtimeexecutor"
+)
+
+target_compile_definitions(vroomchart PRIVATE
+  SK_BUILD_FOR_ANDROID
+  SK_DISABLE_LEGACY_SHAPER_FACTORY
+  SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API
+  ONANDROID
+  ON_ANDROID
+)
+if(SK_GRAPHITE_AVAILABLE)
+  target_compile_definitions(vroomchart PRIVATE SK_GRAPHITE)
+else()
+  target_compile_definitions(vroomchart PRIVATE SK_GL SK_GANESH)
+endif()
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  include("${REACT_NATIVE_DIR}/ReactCommon/cmake-utils/react-native-flags.cmake")
+  target_compile_reactnative_options(vroomchart PRIVATE)
+else()
+  target_compile_options(vroomchart PRIVATE -fexceptions -frtti -std=c++20 -Wall)
+endif()
+
+# ../cpp/_core_include/vroom/vroom_chart.h forward-declares `struct SkCanvas;`
+# (to keep the public C facade header Skia-free); Skia itself declares
+# `class SkCanvas`. This tag mismatch is harmless but react-native-flags.cmake
+# enables -Werror, which would otherwise turn it into a build failure.
+target_compile_options(vroomchart PRIVATE -Wno-mismatched-tags)
+
+find_library(VROOM_LOG_LIB log)
+
+target_link_libraries(vroomchart
+  ${VROOM_LOG_LIB}
+  ReactAndroid::jsi
+  shopify_react-native-skia::rnskia
+  vroom_skia_prebuilt
+)

package/android/README.md

@@ -1,7 +1,62 @@
-# Android shim (placeholder)
+# Android bridge
 
-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.
+Android equivalent of `../ios/`: a small TurboModule
+([`VroomChartModule.kt`](src/main/java/com/vroom/chart/VroomChartModule.kt)) whose
+`install()` hands the JSI runtime pointer to a native `vroomchart` library
+(built by [`CMakeLists.txt`](CMakeLists.txt)) that installs
+`global.VroomChartJSI` via the same platform-agnostic
+[`../cpp/VroomJsiInstaller.cpp`](../cpp/VroomJsiInstaller.cpp) the iOS bridge
+uses.
 
-`build.gradle` (also to come) will compile `cpp/` + this directory + the
-linked `@vroomchart/core` static library via CMake.
+The chart core itself (`../cpp/_core_src`) and the RN-Skia font/context glue
+(`../cpp/VroomSkiaContext.*`) are unmodified and shared across iOS and
+Android — only the platform glue (this directory + `../ios/`) differs.
+`../cpp/VroomChartHostObject.cpp` has one small `#if defined(__ANDROID__)`
+branch (see "Cross-`.so` Skia objects" below).
+
+`build.gradle` resolves `@shopify/react-native-skia`'s `cpp/` sources via
+Node module resolution (mirroring `../react-native-vroom-chart.podspec`'s
+`require.resolve` trick) so `VroomSkiaContext.cpp` can include RN-Skia's
+`JsiSkHostObjects.h` / `RNSkPlatformContext.h`. `CMakeLists.txt` also
+replicates RN-Skia's own Graphite-vs-Ganesh detection (probing its bundled
+`libskia.a`) so `SK_GRAPHITE` is defined identically to however RN-Skia's own
+Android build was compiled — `RNSkPlatformContext`'s vtable layout depends on
+that macro, and a mismatch would corrupt the virtual call in
+`VroomJsiInstaller.cpp`'s `ensureAxisTypeface`.
+
+We link two RN-Skia-adjacent libraries into `libvroomchart.so`, for two
+different reasons:
+  - `shopify_react-native-skia::rnskia` (RN-Skia's own prefab-published
+    shared library, `librnskia.so`) — for `RNJsi::JsiHostObject` and friends,
+    whose out-of-line methods are compiled only there.
+  - RN-Skia's bundled `libskia.a` (imported directly by path, since it isn't
+    prefab-published) — for direct Skia calls (`SkCanvas::drawRect`, `SkFont`,
+    ...), since `librnskia.so` links `libskia.a` internally but doesn't
+    re-export its symbols.
+
+### Cross-`.so` Skia objects
+
+Unlike iOS (one static binary), Android compiles RN-Skia into its own
+`librnskia.so`, separate from `libvroomchart.so`. That's transparent for most
+of the JSI bridge, but **`RNSkia::JsiSkPicture` — the object `render()` /
+`pan()` / etc. return to JS — can't be constructed directly in
+`libvroomchart.so` on Android.** RN-Skia's own C++ (e.g.
+`cpp/api/recorder/Convertor.h`'s `getPropertyValue<sk_sp<SkPicture>>`, which
+runs whenever `<Picture>` reads the value) does
+`value.asObject(rt).asHostObject<JsiSkPicture>(rt)`, a `dynamic_pointer_cast`
+under the hood. A `JsiSkPicture` we construct ourselves has a vtable/typeinfo
+compiled into *our* `.so`; that cast — running inside `librnskia.so` — sees a
+different, unmerged RTTI record for "the same" class and fails with `Object
+is not a HostObject of desired type`.
+
+`VroomChartHostObject.cpp`'s `wrapPicture()` works around this only on
+Android: instead of constructing `RNSkia::JsiSkPicture` directly (as iOS
+does), it serializes the `SkPicture` (`SkPicture::serialize()`) and calls
+RN-Skia's own public JS API, `Skia.Picture.MakePicture(bytes)`, via JSI. That
+runs `JsiSkPictureFactory::MakePicture` — genuinely compiled inside
+`librnskia.so` — so the returned object's RTTI matches what
+`librnskia.so`'s own code expects. This costs a serialize + re-parse of the
+picture's draw commands on every `render()`/gesture call, which is real
+overhead on what's meant to be a 60fps hot path; if that shows up in
+profiling, revisit (e.g. a merged-`.so` build, or a lighter-weight bridge
+that avoids the round trip).

package/android/build.gradle

@@ -0,0 +1,115 @@
+// android/build.gradle
+//
+// Builds the Android half of the JSI bridge: a small `vroomchart` native
+// library (see CMakeLists.txt) plus the TurboModule that installs it
+// (see src/main/java/com/vroom/chart). Modeled on
+// @shopify/react-native-skia/android/build.gradle and
+// react-native-worklets/android/build.gradle, which solve the same
+// "compile custom C++ against the RN/RN-Skia JSI internals" problem.
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "arm64-v8a", "x86", "x86_64"]
+}
+
+// Resolves a package's directory via Node's own module resolution, so this
+// works whether react-native-vroom-chart is installed flat or (as in this
+// monorepo) via pnpm's nested .pnpm store.
+def resolvePackageDir(packageJsonSpecifier) {
+  def packageJsonPath = providers.exec {
+    workingDir(rootDir)
+    commandLine("node", "--print", "require.resolve('${packageJsonSpecifier}')")
+  }.standardOutput.asText.get().trim()
+  return file(packageJsonPath).parentFile
+}
+
+def reactNativeDir = resolvePackageDir("react-native/package.json")
+def skiaCppDir = new File(resolvePackageDir("@shopify/react-native-skia/package.json"), "cpp")
+
+// Mirror ../cpp/_core_{src,include} from ../../core/{src,include} whenever
+// the monorepo core is present, so edits to packages/core/ propagate on the
+// next build without a separate vendoring step. This matches
+// ../react-native-vroom-chart.podspec's iOS behavior; a published package
+// (no ../../core) falls back to the committed vendored copies instead
+// (see ../scripts/vendor-core.mjs).
+def coreRoot = file("${projectDir}/../../core")
+if (coreRoot.isDirectory()) {
+  ["src", "include"].each { sub ->
+    def dst = file("${projectDir}/../cpp/_core_${sub}")
+    delete dst
+    copy {
+      from "${coreRoot}/${sub}"
+      into dst
+    }
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.vroom.chart"
+  compileSdkVersion safeExtGet("compileSdkVersion", 36)
+
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 36)
+
+    externalNativeBuild {
+      cmake {
+        abiFilters(*reactNativeArchitectures())
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DREACT_NATIVE_DIR=${reactNativeDir}",
+                  "-DVROOM_SKIA_CPP_DIR=${skiaCppDir}"
+      }
+    }
+  }
+
+  buildFeatures {
+    // Consumes the `ReactAndroid` prefab package (published by
+    // com.facebook.react:react-android) so CMake can `find_package(ReactAndroid)`
+    // for the jsi headers/library without us hand-resolving RN's AAR layout.
+    prefab true
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  lintOptions {
+    abortOnError false
+  }
+}
+
+repositories {
+  maven {
+    url("${reactNativeDir}/android")
+  }
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  // ../cpp/VroomChartHostObject.cpp constructs RN-Skia JSI host objects
+  // (JsiSkPicture, etc.) whose base class (RNJsi::JsiHostObject) has
+  // out-of-line methods compiled into RN-Skia's own native library — we link
+  // against its prefab-published `rnskia` package (below, in CMakeLists.txt)
+  // rather than recompiling those .cpp files ourselves, to avoid duplicate
+  // definitions of RNSkia's internals across two separately-loaded .so's.
+  implementation project(":shopify_react-native-skia")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/VroomChartJni.cpp

@@ -0,0 +1,24 @@
+// JNI entry point for VroomChartModule.install() (see
+// ../java/com/vroom/chart/VroomChartModule.kt). This is the Android
+// equivalent of ../../ios/VroomChartModule.mm's `-install` method: it
+// reinterprets the JSI runtime pointer handed over from Java and calls the
+// same platform-agnostic vroom::installJsi() the iOS bridge uses.
+
+#include <jni.h>
+
+#include <jsi/jsi.h>
+
+#include "VroomJsiInstaller.h"
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_vroom_chart_VroomChartModule_nativeInstall(JNIEnv* /*env*/,
+                                                      jobject /*thiz*/,
+                                                      jlong runtimePointer) {
+  auto* runtime =
+      reinterpret_cast<facebook::jsi::Runtime*>(runtimePointer);
+  if (runtime == nullptr) {
+    return JNI_FALSE;
+  }
+  vroom::installJsi(*runtime);
+  return JNI_TRUE;
+}

package/android/src/main/java/com/vroom/chart/VroomChartModule.kt

@@ -0,0 +1,31 @@
+package com.vroom.chart
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+// TurboModule counterpart to ../../ios/VroomChartModule.mm. `install()` hands
+// the JSI runtime pointer to the native `vroomchart` library (see
+// ../../CMakeLists.txt), which installs `global.VroomChartJSI` via the same
+// platform-agnostic vroom::installJsi() the iOS bridge calls.
+//
+// `NativeVroomChartSpec` is generated by React Native's codegen from
+// ../../../src/NativeVroomChart.ts (codegenConfig.android.javaPackageName in
+// package.json) — the same class name iOS's codegen generates.
+@ReactModule(name = NativeVroomChartSpec.NAME)
+class VroomChartModule(reactContext: ReactApplicationContext) :
+    NativeVroomChartSpec(reactContext) {
+
+  companion object {
+    init {
+      System.loadLibrary("vroomchart")
+    }
+  }
+
+  private external fun nativeInstall(runtimePointer: Long): Boolean
+
+  override fun install(): Boolean {
+    val runtimePointer =
+        reactApplicationContext.javaScriptContextHolder?.get() ?: return false
+    return nativeInstall(runtimePointer)
+  }
+}

package/android/src/main/java/com/vroom/chart/VroomChartPackage.kt

@@ -0,0 +1,31 @@
+package com.vroom.chart
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class VroomChartPackage : BaseReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+      if (name == NativeVroomChartSpec.NAME) {
+        VroomChartModule(reactContext)
+      } else {
+        null
+      }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mutableMapOf(
+        NativeVroomChartSpec.NAME to
+            ReactModuleInfo(
+                NativeVroomChartSpec.NAME,
+                VroomChartModule::class.java.name,
+                /* canOverrideExistingModule = */ false,
+                /* needsEagerInit = */ false,
+                /* isCxxModule = */ false,
+                /* isTurboModule = */ true,
+            ),
+    )
+  }
+}

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"));
@@ -52,10 +54,76 @@ std::vector<jsi::PropNameID> ChartHostObject::getPropertyNames(
   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,
@@ -66,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) {
@@ -598,6 +667,154 @@ jsi::Value ChartHostObject::get(jsi::Runtime& rt,
         });
   }
 
+  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,