react-native-vroom-chart 0.10.0 → 0.11.1

package/cpp/_core_include/vroom/vroom_chart.h

@@ -187,6 +187,13 @@ typedef struct VroomDrawing {
     int32_t               kind;         // 0 = line, 1 = box, 2 = pencil, 3 = path
     const VroomDrawPoint* points;       // pencil/path points (kind 2/3), else null
     int32_t               point_count;  // number of `points`, else 0
+    // Box (kind 1) interior fill, 0xAARRGGBB. Alpha 0 means unset, in which case
+    // the interior falls back to `color` at 10% alpha. Ignored by other kinds.
+    uint32_t              fill;
+    // Protects the drawing from editing: hit_test reports its body (so a host
+    // can still select it and offer to unlock) but never its handles, and no
+    // handles are drawn. Rendering is otherwise unaffected.
+    bool                  locked;
 } VroomDrawing;
 
 // A resting-liquidity band: a price interval carrying a total order size on one
@@ -257,6 +264,14 @@ typedef struct VroomCoord {
     double  price;
 } VroomCoord;
 
+// An axis-aligned rectangle in CSS pixels, relative to the chart's top-left.
+typedef struct VroomRect {
+    float x;
+    float y;
+    float width;
+    float height;
+} VroomRect;
+
 // ---- Styling keys ---------------------------------------------------------
 
 typedef enum {
@@ -578,6 +593,18 @@ bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px, float y_px,
                                   int32_t* out_index, int32_t* out_part,
                                   float* out_t);
 
+// Fills *out with the pixel bounding box of committed drawing `index` and
+// returns true; false (out untouched) for an out-of-range index, an empty
+// series, or a degenerate viewport.
+//
+// The rectangle spans the shape's painted extent — every anchor of a pencil or
+// path, both corners of a line or box — grown by half the stroke width, so it
+// covers the pixels the stroke actually paints. It is the anchor a host uses to
+// position UI against the selection, and because it is computed from live core
+// state it stays correct mid-reshape, before the edit reaches the host's array.
+bool vroom_chart_drawing_bounds(VroomChart* chart, int32_t index,
+                                VroomRect* out);
+
 // Selects a committed drawing (renders its handles). `index` -1 clears the
 // selection. `grabbed_endpoint` renders that handle 50% larger while it's being
 // dragged (0/1 for a line, 0 for the box corner the host normalized to, the

package/cpp/_core_src/chart.cpp

@@ -36,6 +36,7 @@
 #include "rsi.h"
 #include "rsi_pane.h"
 #include "style_inherit.h"
+#include "tip_anchor.h"
 #include "tip_pulse.h"
 #include "volume.h"
 #include "vwap.h"
@@ -311,16 +312,23 @@ void VroomChart::draw_chart(SkCanvas* canvas) {
     // 5.8. Line-mode tip marker — the dot (and optional pulse) at the newest
     //      close. Above the overlays so it stays the eye's anchor, but before the
     //      axis masks, which trim the ring at the price scale.
+    //
+    //      Unlike every layer above, this one anchors to the newest candle in
+    //      the series rather than the newest on screen, so panning into history
+    //      carries the dot off the right edge with its candle (tip_anchor.h).
     if (fade > 0.f && theme.floats[VROOM_FLOAT_LINE_TIP_DOT] > 0.5f) {
+        const auto anchor = vroom::tip_anchor::at(range.start, range.end,
+                                                  candles.size(), morphing);
         vroom::ma_overlay::draw_close_tip(
-            canvas, lay, bounds, visible, n, window_ms, visible_start_ms,
-            candle_duration_ms, candle_right, candle_area_h,
+            canvas, lay, bounds, visible, anchor.slot_count, window_ms,
+            visible_start_ms, candle_duration_ms, candle_right, candle_area_h,
             theme.colors[VROOM_COLOR_LINE],
             theme.colors[VROOM_COLOR_BACKGROUND],
             theme.floats[VROOM_FLOAT_LINE_WIDTH_PX], fade,
             theme.floats[VROOM_FLOAT_LINE_TIP_PULSE] > 0.5f,
             tip_pulse_elapsed_s / vroom::tip_pulse::kPeriodSeconds,
-            morph_src, morph_n, morph_t);
+            anchor.use_morph ? morph_src : nullptr,
+            anchor.use_morph ? morph_n : 0, morph_t);
     }
 
     // 6. Axis backgrounds (mask any candle overflow). The x-axis separator

package/cpp/_core_src/chart.h

@@ -23,6 +23,7 @@
 #pragma clang diagnostic pop
 
 #include "labels.h"
+#include "price_format.h"
 #include "theme.h"
 #include "viewport.h"
 
@@ -89,6 +90,12 @@ struct VroomChart {
     // label. 0 = uncomputed; layout() falls back to a width ratio.
     float axis_width_px = 0.f;
 
+    // How prices render, derived from the asset's own scale. Cached beside the
+    // width because the two are measured together — every label site reads this
+    // so none of them can disagree with the strip they're drawn in. Both are
+    // refreshed by labels::recompute_axis_width.
+    vroom::PriceFormat price_fmt{};
+
     // --- price bounds (y-axis state) ---------------------------------------
     // Two modes. Auto (price_bounds_manual == false, the default): the y-range
     // continuously follows the visible candles each frame and `price_bounds`
@@ -199,6 +206,8 @@ struct VroomChart {
         float                       width = 2.f;
         int32_t                     kind = 0;
         std::vector<VroomDrawPoint> points;  // pencil path (kind 2)
+        uint32_t                    fill = 0;      // 0 alpha = derive from color
+        bool                        locked = false;
     };
     std::vector<StoredDrawing> drawings;
 

package/cpp/_core_src/chart_facade.cpp

@@ -926,6 +926,8 @@ extern "C" void vroom_chart_set_drawings(VroomChart* chart,
         d.color = src.color;
         d.width = src.width;
         d.kind = src.kind;
+        d.fill = src.fill;
+        d.locked = src.locked;
         if ((src.kind == 2 || src.kind == 3) && src.points && src.point_count > 0) {
             d.points.assign(src.points, src.points + src.point_count);
             // Keep a/b mirroring the path ends so bounds/handle code is uniform.
@@ -1152,6 +1154,31 @@ extern "C" bool vroom_chart_hit_test_drawing(VroomChart* chart, float x_px,
     return true;
 }
 
+extern "C" bool vroom_chart_drawing_bounds(VroomChart* chart, int32_t index,
+                                           VroomRect* out) {
+    if (!chart || !out || chart->candles.empty()) return false;
+    const int64_t window_ms = chart->visible_end_ms - chart->visible_start_ms;
+    if (window_ms <= 0) return false;
+    const auto lay = chart->layout();
+    // Same bounds as coord_at / draw_chart so the rectangle matches the render.
+    const auto range = vroom::visible_indices(
+        chart->candles.data(), chart->candles.size(),
+        chart->visible_start_ms, chart->visible_end_ms);
+    const size_t n = range.end - range.start;
+    const auto bounds =
+        chart->price_bounds_manual
+            ? chart->price_bounds
+            : vroom::auto_price_bounds(chart->candles.data() + range.start, n);
+    vroom::drawing_bounds::RectPx r{};
+    if (!vroom::drawings::bounds_of(*chart, lay, bounds, window_ms, index, &r))
+        return false;
+    out->x = r.x;
+    out->y = r.y;
+    out->width = r.width;
+    out->height = r.height;
+    return true;
+}
+
 extern "C" bool vroom_chart_hit_test_price_line(VroomChart* chart, float x_px,
                                                 float y_px, int32_t* out_index,
                                                 int32_t* out_part) {

package/cpp/_core_src/crosshair.cpp

@@ -20,6 +20,7 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "price_format.h"
 #include "theme.h"
 #include "ticks.h"
 
@@ -146,11 +147,12 @@ void draw(SkCanvas* canvas,
     // sharing the y-axis labels' column.
     if (lay.y_axis_width_px > 0.f) {
         const double price = vroom::y_to_price(lay, bounds, cy);
-        char buf[32];
-        const int decimals = vroom::price_decimals(
+        char buf[48];
+        const vroom::PriceFormat fmt = vroom::with_tick_guard(
+            chart.price_fmt,
             vroom::pick_price_interval(bounds.max - bounds.min,
                                        vroom::price_pane_bottom(lay)));
-        vroom::format_price(buf, sizeof(buf), price, decimals);
+        vroom::format_price(buf, sizeof(buf), price, fmt);
         const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
         draw_badge(canvas, font, buf, axis_center_x, cy, badge_fill,
                    SK_ColorWHITE);

package/cpp/_core_src/drawing_bounds.h

@@ -0,0 +1,70 @@
+// The pixel bounding box of a drawing (see bounds_of in drawings.cpp).
+//
+// A host anchoring UI to a selected drawing needs one rectangle, whatever the
+// shape: a box and a freehand stroke both have to yield something positionable.
+// Reducing the projected anchors to their extent gives that uniformly, where the
+// anchors themselves would not — a pencil stroke's `a`/`b` are just its first
+// and last samples, which say nothing about how far the stroke wandered between
+// them.
+//
+// The extent is grown by half the stroke width on every side, because a stroke
+// straddles its path: a 2px line through y=100 paints 99..101. Without that the
+// rectangle would clip the very pixels it is meant to describe.
+//
+// Skia-free and header-only so the unit tests can cover it; see
+// tests/test_drawing_bounds.cpp.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+namespace vroom::drawing_bounds {
+
+// An axis-aligned rectangle in CSS pixels, relative to the chart's top-left.
+struct RectPx {
+    float x = 0.f;
+    float y = 0.f;
+    float width = 0.f;
+    float height = 0.f;
+};
+
+// Accumulates projected points into their extent. Points are fed one at a time
+// so callers can project straight from their own storage without materializing
+// an intermediate array.
+struct Accumulator {
+    float min_x = 0.f;
+    float min_y = 0.f;
+    float max_x = 0.f;
+    float max_y = 0.f;
+    bool  has = false;
+
+    // Non-finite coordinates are dropped rather than propagated: a single NaN
+    // would otherwise poison every comparison and hand the host an unusable
+    // rectangle.
+    void add(float x, float y) {
+        if (!std::isfinite(x) || !std::isfinite(y)) return;
+        if (!has) {
+            min_x = max_x = x;
+            min_y = max_y = y;
+            has = true;
+            return;
+        }
+        min_x = std::min(min_x, x);
+        max_x = std::max(max_x, x);
+        min_y = std::min(min_y, y);
+        max_y = std::max(max_y, y);
+    }
+
+    // The extent grown by half of `stroke_width` on each side. A single point
+    // yields a zero-extent rectangle inflated to the stroke's own footprint,
+    // which is exactly what a one-sample pencil stroke paints.
+    RectPx to_rect(float stroke_width) const {
+        if (!has) return RectPx{};
+        const float pad = std::max(stroke_width, 0.f) * 0.5f;
+        return RectPx{min_x - pad, min_y - pad, (max_x - min_x) + pad * 2.f,
+                      (max_y - min_y) + pad * 2.f};
+    }
+};
+
+}  // namespace vroom::drawing_bounds

package/cpp/_core_src/drawings.cpp

@@ -51,17 +51,23 @@ SkRect box_rect(SkPoint a, SkPoint b) {
                             std::max(a.fX, b.fX), std::max(a.fY, b.fY));
 }
 
-// Strokes the box outline and paints a faint fill (~10% of the border alpha) of
-// the same color, spanning opposite corners `a` and `b`.
-void draw_box(SkCanvas* canvas, SkPoint a, SkPoint b, SkColor color, float width) {
+// Strokes the box outline and paints its interior, spanning opposite corners
+// `a` and `b`. `fill_color` is used as given; alpha 0 means the caller didn't
+// set one, and the interior falls back to a faint tint of the border (~10% of
+// its alpha) — a solid default would hide the candles the box was drawn around.
+void draw_box(SkCanvas* canvas, SkPoint a, SkPoint b, SkColor color, float width,
+              SkColor fill_color) {
     const SkRect r = box_rect(a, b);
 
     SkPaint fill;
     fill.setAntiAlias(true);
     fill.setStyle(SkPaint::kFill_Style);
-    // Faint fill: 10% of the border's alpha, same RGB.
-    const U8CPU fill_alpha = static_cast<U8CPU>(SkColorGetA(color) * 0.1f);
-    fill.setColor(SkColorSetA(color, fill_alpha));
+    if (SkColorGetA(fill_color) != 0) {
+        fill.setColor(fill_color);
+    } else {
+        const U8CPU fill_alpha = static_cast<U8CPU>(SkColorGetA(color) * 0.1f);
+        fill.setColor(SkColorSetA(color, fill_alpha));
+    }
     canvas->drawRect(r, fill);
 
     SkPaint border;
@@ -334,7 +340,8 @@ void draw(SkCanvas* canvas,
             const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
             const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
             if (d.kind == 1) {
-                draw_box(canvas, a, b, static_cast<SkColor>(d.color), d.width);
+                draw_box(canvas, a, b, static_cast<SkColor>(d.color), d.width,
+                         static_cast<SkColor>(d.fill));
                 continue;
             }
             SkPaint line;
@@ -348,9 +355,12 @@ void draw(SkCanvas* canvas,
     }
 
     // 1b. Handles on the selected committed drawing (unclipped, like the draft's
-    //     dots). The grabbed endpoint renders 50% larger.
+    //     dots). The grabbed endpoint renders 50% larger. A locked drawing shows
+    //     none: nothing about it can be dragged, so an affordance saying
+    //     otherwise would be a lie.
     if (chart.selected_drawing >= 0 &&
-        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size() &&
+        !chart.drawings[chart.selected_drawing].locked) {
         const auto& d = chart.drawings[chart.selected_drawing];
         const SkPoint sa = to_px(chart, lay, bounds, window_ms, d.a);
         const SkPoint sb = to_px(chart, lay, bounds, window_ms, d.b);
@@ -432,8 +442,10 @@ void draw(SkCanvas* canvas,
         canvas->save();
         canvas->clipRect(clip);
         if (chart.draft_kind == 1) {
+            // The draft has no fill of its own — the preview shows the default
+            // tint until the box is committed with one.
             draw_box(canvas, a, b, static_cast<SkColor>(chart.draft_color),
-                     chart.draft_width);
+                     chart.draft_width, SK_ColorTRANSPARENT);
         } else {
             SkPaint guide;
             guide.setAntiAlias(true);
@@ -463,9 +475,13 @@ HitResult hit_test(const VroomChart& chart,
     if (window_ms <= 0 || chart.drawings.empty()) return miss;
 
     // Grab-priority: if a drawing is selected, its (visible) handles win first.
+    // A locked drawing draws no handles, so there is nothing here to grab — it
+    // falls through to the body pass and stays selectable, which is how a host
+    // toolbar can still reach it to unlock it.
     constexpr float kHandleHit = kNodeRingRadius + 6.f;
     if (chart.selected_drawing >= 0 &&
-        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size()) {
+        static_cast<size_t>(chart.selected_drawing) < chart.drawings.size() &&
+        !chart.drawings[chart.selected_drawing].locked) {
         const auto& d = chart.drawings[chart.selected_drawing];
         const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
         const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
@@ -546,4 +562,37 @@ HitResult hit_test(const VroomChart& chart,
     return best_i >= 0 ? HitResult{best_i, best_part, best_t} : miss;
 }
 
+bool bounds_of(const VroomChart& chart,
+               const Layout& lay,
+               const PriceBounds& bounds,
+               int64_t window_ms,
+               int32_t index,
+               vroom::drawing_bounds::RectPx* out) {
+    if (!out || window_ms <= 0) return false;
+    if (index < 0 || static_cast<size_t>(index) >= chart.drawings.size())
+        return false;
+    const auto& d = chart.drawings[static_cast<size_t>(index)];
+
+    vroom::drawing_bounds::Accumulator acc;
+    if ((d.kind == 2 || d.kind == 3) && !d.points.empty()) {
+        // Pencil/path: every sample counts. `a`/`b` only mirror the first and
+        // last, so they would miss however far the stroke wandered between them.
+        for (const auto& p : d.points) {
+            const SkPoint q = to_px(chart, lay, bounds, window_ms, p);
+            acc.add(q.fX, q.fY);
+        }
+    } else {
+        // Line/box: the two stored corners already span the shape — a box's
+        // derived corners are exactly their extent.
+        const SkPoint a = to_px(chart, lay, bounds, window_ms, d.a);
+        const SkPoint b = to_px(chart, lay, bounds, window_ms, d.b);
+        acc.add(a.fX, a.fY);
+        acc.add(b.fX, b.fY);
+    }
+    if (!acc.has) return false;
+
+    *out = acc.to_rect(d.width > 0.f ? d.width : 2.f);
+    return true;
+}
+
 }  // namespace vroom::drawings

package/cpp/_core_src/drawings.h

@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include "drawing_bounds.h"
 #include "viewport.h"
 #include "vroom/vroom_chart.h"
 
@@ -59,4 +60,18 @@ HitResult hit_test(const VroomChart& chart,
                    float x,
                    float y);
 
+// The pixel bounding box of committed drawing `index`, written to `out`. False
+// (leaving `out` untouched) for an out-of-range index or a degenerate viewport.
+//
+// The rectangle covers the shape's painted extent — every anchor of a pencil or
+// path, both corners of a line or box — grown by half the stroke width. It is
+// what the host positions a selection toolbar against, so it tracks the drawing
+// live through a pan, a zoom, and a reshape in progress.
+bool bounds_of(const VroomChart& chart,
+               const vroom::Layout& lay,
+               const vroom::PriceBounds& bounds,
+               int64_t window_ms,
+               int32_t index,
+               vroom::drawing_bounds::RectPx* out);
+
 }  // namespace vroom::drawings

package/cpp/_core_src/labels.cpp

@@ -19,6 +19,7 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "price_format.h"
 #include "ticks.h"
 #include "viewport.h"
 
@@ -47,6 +48,19 @@ void advance(Fade& f, float step, float dt) {
     }
 }
 
+// What the asset is worth, which is what its price precision keys off. The
+// newest close rather than the visible range, so panning and zooming don't
+// shift the decimals around under the user.
+//
+// An asset that has crossed orders of magnitude within one series (a token at
+// 0.00001 that later trades at 100) reads its recent scale here, so deep
+// history would round flat — the tick guard at each label site is what rescues
+// it, since the bounds down there are tiny enough to demand more decimals.
+double reference_price(const VroomChart& chart) {
+    if (!chart.candles.empty()) return chart.candles.back().close;
+    return (chart.price_bounds.max + chart.price_bounds.min) * 0.5;
+}
+
 // Drives a whole axis off the morph envelope instead of the per-label fades:
 // everything in the phase's tick set shares one opacity, and anything outside it
 // is dropped outright. At the midpoint the axis is transparent, so swapping the
@@ -153,15 +167,16 @@ void draw_y_labels(SkCanvas* canvas,
     // Horizontal center of the y-axis container ([width - y_axis_width, width]).
     // Labels (and the price box) center on this so their text shares a column.
     const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
-    const int decimals = vroom::price_decimals(
+    const vroom::PriceFormat fmt = vroom::with_tick_guard(
+        chart.price_fmt,
         vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
 
     for (const auto& f : chart.y_fades) {
         if (f.opacity <= 1e-3f) continue;
         const float y = vroom::price_to_y(lay, bounds, f.price);
 
-        char buf[32];
-        vroom::format_price(buf, sizeof(buf), f.price, decimals);
+        char buf[48];
+        vroom::format_price(buf, sizeof(buf), f.price, fmt);
         const size_t len = std::strlen(buf);
         const float text_w = font.measureText(
             buf, len, SkTextEncoding::kUTF8);
@@ -347,6 +362,10 @@ void gc_x_fades(VroomChart& chart) {
 // ----- Axis-width sizing ----------------------------------------------------
 
 void recompute_axis_width(VroomChart& chart) {
+    // Precision first, and unconditionally: the label sites read it whether or
+    // not a typeface has loaded, and it's what the measurement below sizes for.
+    chart.price_fmt = vroom::price_format_for(reference_price(chart));
+
     auto tf = vroom::axis_typeface();
     if (!tf) {
         chart.axis_width_px = 0.f;
@@ -370,11 +389,16 @@ void recompute_axis_width(VroomChart& chart) {
 
     SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
     const auto lay = chart.layout();
-    const int decimals = vroom::price_decimals(
+    // Same guard the label sites apply, against the bounds this is sizing for,
+    // so a zoom deep enough to add decimals widens the strip to hold them.
+    const vroom::PriceFormat fmt = vroom::with_tick_guard(
+        chart.price_fmt,
         vroom::pick_price_interval(hi - lo, vroom::price_pane_bottom(lay)));
-    char buf_hi[32], buf_lo[32];
-    vroom::format_price(buf_hi, sizeof(buf_hi), hi, decimals);
-    vroom::format_price(buf_lo, sizeof(buf_lo), lo, decimals);
+    // At the same decimals the longest label is whichever bound has the most
+    // integer digits, separators included.
+    char buf_hi[48], buf_lo[48];
+    vroom::format_price(buf_hi, sizeof(buf_hi), hi, fmt);
+    vroom::format_price(buf_lo, sizeof(buf_lo), lo, fmt);
     const float w_hi = font.measureText(
         buf_hi, std::strlen(buf_hi), SkTextEncoding::kUTF8);
     const float w_lo = font.measureText(

package/cpp/_core_src/ma_overlay.h

@@ -108,6 +108,11 @@ void draw_close_gradient(SkCanvas* canvas,
 // switch. `opacity` scales everything, fading the marker in with the line during
 // the candle→line morph.
 //
+// `n` counts the slots to the candle being marked, which is the series' newest
+// rather than the visible slice's — see tip_anchor.h, which derives it. That
+// candle can sit off the pane when panned into history, and the marker then
+// draws nothing.
+//
 // `pulse_phase` is in cycles and wraps, so the caller can hand over elapsed time
 // divided by tip_pulse::kPeriodSeconds. Ignored unless `pulse`.
 void draw_close_tip(SkCanvas* canvas,

package/cpp/_core_src/price_format.cpp

@@ -0,0 +1,87 @@
+#include "price_format.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+
+namespace vroom {
+
+namespace {
+
+// Room for %.*f of any finite double at kPriceMaxDecimals: sign, the 309
+// integer digits DBL_MAX can reach, the point, and the decimals.
+constexpr size_t kPlainCap = 340;
+
+constexpr char kGroupSeparator = ',';
+constexpr int kGroupSize = 3;
+
+}  // namespace
+
+int significant_decimals(double reference) {
+    const double r = std::fabs(reference);
+    if (!(r > 0.0) || !std::isfinite(r)) return kPriceMinDecimals;
+    // floor(log10) is the exponent of the leading digit, so subtracting it from
+    // the digit budget lands the last significant digit on the final decimal.
+    const int exponent = static_cast<int>(std::floor(std::log10(r)));
+    return std::clamp(kPriceSigDigits - 1 - exponent, kPriceMinDecimals,
+                      kPriceMaxDecimals);
+}
+
+PriceFormat price_format_for(double reference) {
+    return PriceFormat{significant_decimals(reference), true};
+}
+
+int price_decimals(double interval) {
+    if (!(interval > 0.0) || !std::isfinite(interval)) return kPriceMinDecimals;
+    const double d = std::ceil(-std::log10(interval) - 1e-12);
+    if (d < 0.0) return 0;
+    if (d > static_cast<double>(kPriceMaxDecimals)) return kPriceMaxDecimals;
+    return static_cast<int>(d);
+}
+
+PriceFormat with_tick_guard(const PriceFormat& fmt, double interval) {
+    return PriceFormat{std::max(fmt.decimals, price_decimals(interval)),
+                       fmt.group};
+}
+
+void format_price(char* buf, size_t buf_size, double price,
+                  const PriceFormat& fmt) {
+    if (!buf || buf_size == 0) return;
+    const int decimals = std::clamp(fmt.decimals, 0, kPriceMaxDecimals);
+
+    char plain[kPlainCap];
+    if (std::snprintf(plain, sizeof(plain), "%.*f", decimals, price) < 0) {
+        buf[0] = '\0';
+        return;
+    }
+    if (!fmt.group) {
+        std::snprintf(buf, buf_size, "%s", plain);
+        return;
+    }
+
+    const char* src = plain;
+    size_t out = 0;
+    // Leaves room for the terminator on every write, so the result truncates
+    // the way snprintf would rather than running off the end.
+    const auto put = [&](char c) {
+        if (out + 1 < buf_size) buf[out++] = c;
+    };
+
+    if (*src == '-' || *src == '+') put(*src++);
+
+    // Digits up to the point, or the whole run when decimals == 0. A non-finite
+    // price has none, and falls through to the tail copy as "inf" / "nan".
+    const char* int_end = src;
+    while (*int_end >= '0' && *int_end <= '9') ++int_end;
+
+    const ptrdiff_t digits = int_end - src;
+    for (ptrdiff_t i = 0; i < digits; ++i) {
+        if (i > 0 && (digits - i) % kGroupSize == 0) put(kGroupSeparator);
+        put(src[i]);
+    }
+    for (const char* p = int_end; *p != '\0'; ++p) put(*p);
+
+    buf[out] = '\0';
+}
+
+}  // namespace vroom

package/cpp/_core_src/price_format.h

@@ -0,0 +1,69 @@
+// How a price is turned into the string on the y-axis.
+//
+// Precision follows the asset's own scale rather than the tick interval: a
+// sub-cent token needs nine decimals to say anything at all, while a
+// five-figure one is unreadable past two. Deriving it from the interval — as
+// the axis used to — gets both wrong, printing "84000" for the one and
+// "0.000060" for the other.
+//
+// The rule is a fixed count of significant digits with a floor, which is what
+// reproduces a conventional price scale across the whole range:
+//
+//   4.4094e-5 -> 9 decimals   0.000044094
+//   0.023397  -> 6 decimals   0.023397
+//   80285.20  -> 2 decimals   80,285.20   (floor)
+//   2513.92   -> 2 decimals   2,513.92    (floor)
+//
+// The reference is the asset's own price, not the visible range, so the
+// precision holds steady while the user pans and zooms. A range-derived count
+// would change under the user's finger and drag the axis width along with it.
+//
+// Skia-free and separately compiled so the unit tests can cover it; see
+// tests/test_price_format.cpp.
+
+#pragma once
+
+#include <cstddef>
+
+namespace vroom {
+
+// Significant digits a price is quoted to. Five is what conventional price
+// scales show: it keeps 0.023397 intact and still fits 0.000044094.
+inline constexpr int kPriceSigDigits = 5;
+
+// Prices at or above ~1 unit read as currency, where fewer than two decimals
+// looks broken (a "$84,000" axis next to a "$80,285.20" last price).
+inline constexpr int kPriceMinDecimals = 2;
+
+// Past this the digits are noise, and %.*f starts printing the binary
+// representation's tail rather than anything the feed meant.
+inline constexpr int kPriceMaxDecimals = 12;
+
+// How to render a price. `group` inserts thousands separators, which only ever
+// affects the integer part.
+struct PriceFormat {
+    int  decimals = kPriceMinDecimals;
+    bool group = true;
+};
+
+// Decimals giving kPriceSigDigits significant digits for an asset priced around
+// |reference|, clamped to [kPriceMinDecimals, kPriceMaxDecimals]. A zero or
+// non-finite reference falls back to the floor.
+int significant_decimals(double reference);
+
+// The format for an asset priced around `reference`.
+PriceFormat price_format_for(double reference);
+
+// Decimal places needed so adjacent ticks `interval` apart don't collapse to
+// the same string. 0.01 → 2, 0.005 → 3, 1e-8 → 8. Clamped to [0, 12].
+int price_decimals(double interval);
+
+// `fmt` raised, if need be, so ticks `interval` apart stay distinct. The asset's
+// precision is the floor; only a zoom deeper than that precision adds to it.
+PriceFormat with_tick_guard(const PriceFormat& fmt, double interval);
+
+// Writes `price` into `buf` per `fmt`, truncating rather than overrunning.
+void format_price(char* buf, size_t buf_size, double price,
+                  const PriceFormat& fmt);
+
+}  // namespace vroom

package/cpp/_core_src/price_indicator.cpp

@@ -18,6 +18,7 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "price_format.h"
 #include "theme.h"
 #include "ticks.h"
 #include "viewport.h"
@@ -66,10 +67,11 @@ void draw(SkCanvas* canvas,
     font.setSubpixel(true);
     font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
 
-    char buf[32];
-    const int decimals = vroom::price_decimals(
+    char buf[48];
+    const vroom::PriceFormat fmt = vroom::with_tick_guard(
+        chart.price_fmt,
         vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
-    vroom::format_price(buf, sizeof(buf), last.close, decimals);
+    vroom::format_price(buf, sizeof(buf), last.close, fmt);
     const size_t len = std::strlen(buf);
 
     // Measure the tight glyph bounds (origin at the baseline) so we can center

package/cpp/_core_src/price_lines.cpp

@@ -21,6 +21,7 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "price_format.h"
 #include "price_line_layout.h"
 #include "theme.h"
 #include "ticks.h"
@@ -214,11 +215,11 @@ void draw_axis_badge(SkCanvas* canvas,
                      double price,
                      float y,
                      SkColor fill,
-                     int decimals) {
+                     const PriceFormat& fmt) {
     if (lay.y_axis_width_px <= 0.f) return;
 
-    char buf[32];
-    vroom::format_price(buf, sizeof(buf), price, decimals);
+    char buf[48];
+    vroom::format_price(buf, sizeof(buf), price, fmt);
     const size_t len = std::strlen(buf);
 
     SkRect tb;
@@ -255,7 +256,8 @@ void draw(SkCanvas* canvas,
     const VroomPriceLineStyle& style = chart.price_line_style;
     SkFont font;
     const bool has_font = label_font(chart, &font);
-    const int decimals = vroom::price_decimals(
+    const vroom::PriceFormat fmt = vroom::with_tick_guard(
+        chart.price_fmt,
         vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
 
     for (size_t i = 0; i < chart.price_lines.size(); ++i) {
@@ -355,7 +357,7 @@ void draw(SkCanvas* canvas,
 
         if (has_font && (pl.flags & VROOM_PRICE_LINE_AXIS_LABEL) != 0) {
             draw_axis_badge(canvas, font, lay, render_price(chart, i), y,
-                            line_color, decimals);
+                            line_color, fmt);
         }
     }
 }

package/cpp/_core_src/ticks.cpp

@@ -2,7 +2,6 @@
 
 #include <algorithm>
 #include <cmath>
-#include <cstdio>
 #include <ctime>
 
 namespace vroom {
@@ -146,17 +145,4 @@ double pick_price_interval(double range, float candle_area_h) {
     return nice * magnitude;
 }
 
-int price_decimals(double interval) {
-    if (!(interval > 0.0) || !std::isfinite(interval)) return 2;
-    const double d = std::ceil(-std::log10(interval) - 1e-12);
-    if (d < 0.0) return 0;
-    if (d > 12.0) return 12;
-    return static_cast<int>(d);
-}
-
-void format_price(char* buf, size_t buf_size, double price, int decimals) {
-    if (!buf || buf_size == 0) return;
-    std::snprintf(buf, buf_size, "%.*f", decimals, price);
-}
-
 }  // namespace vroom

package/cpp/_core_src/ticks.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 
 namespace vroom {
@@ -49,13 +48,8 @@ int64_t next_tick(int64_t t, const TimeTick& tick);
 // "Nice number" tick selection for the y-axis: snaps to 1, 2, or 5 × 10ⁿ
 // based on the price range and target spacing. Returns the price interval
 // in the same units as the data (e.g. dollars).
+//
+// Turning that interval into a label string is price_format.h's job.
 double pick_price_interval(double range, float candle_area_h);
 
-// Decimal places needed so adjacent ticks `interval` apart don't collapse to
-// the same string. 0.01 → 2, 0.005 → 3, 1e-8 → 8. Clamped to [0, 12].
-int price_decimals(double interval);
-
-// Writes `price` into `buf` using `decimals` (from price_decimals).
-void format_price(char* buf, size_t buf_size, double price, int decimals);
-
 }  // namespace vroom

package/cpp/_core_src/tip_anchor.h

@@ -0,0 +1,49 @@
+// Which slot the line chart's tip marker anchors to (see draw_close_tip in
+// ma_overlay.cpp).
+//
+// The tip marks the newest close in the *series*, not the newest close on
+// screen — the same rule the price indicator follows (price_indicator.cpp).
+// Panning into history therefore carries the dot off the right edge with the
+// candle it belongs to, where draw_close_tip's on-pane guard drops it.
+//
+// Every other line-chart layer draws the visible slice, so the tip is the one
+// caller that has to reach past range.end. The slice is a view into the same
+// contiguous candle buffer, so widening the slot count is enough to reach the
+// newest candle — no second pointer.
+//
+// Skia-free and header-only so the unit tests can cover it; see
+// tests/test_tip_anchor.cpp.
+
+#pragma once
+
+#include <cstddef>
+
+namespace vroom::tip_anchor {
+
+// How draw_close_tip should be called for one frame.
+struct Anchor {
+    // Slot count to pass in place of the visible count, so slot 0 resolves to
+    // the newest candle in the series. Never 0 for a non-empty visible slice.
+    std::size_t slot_count;
+    // Whether the interval-morph capture still lines up with slot 0.
+    bool use_morph;
+};
+
+// `range_start`/`range_end` are the visible slice's half-open bounds into a
+// series of `total` candles; `morphing` is whether an interval morph is running.
+//
+// The capture taken at a timeframe switch is indexed from the newest *visible*
+// candle, so it only pairs with slot 0 while the newest candle is the one at the
+// right edge. Scrolled back, pairing them would interpolate the tip between two
+// unrelated candles and strand the dot mid-pane for the length of the switch.
+inline Anchor at(std::size_t range_start,
+                 std::size_t range_end,
+                 std::size_t total,
+                 bool morphing) {
+    // A caller with an empty or out-of-bounds slice has nothing to anchor to;
+    // reporting 0 slots lets draw_close_tip take its existing early-out.
+    if (range_start >= total) return Anchor{0, false};
+    return Anchor{total - range_start, morphing && range_end >= total};
+}
+
+}  // namespace vroom::tip_anchor

package/lib/index.d.mts

@@ -177,6 +177,12 @@ type DrawingBase = {
     color?: VroomColor;
     /** Stroke width in px. Default 2. */
     width?: number;
+    /**
+     * Protect the drawing from editing. A locked drawing still renders and can
+     * still be selected — so a toolbar can offer to unlock it — but it can't be
+     * dragged, reshaped or deleted, and its grab handles aren't drawn. Web only.
+     */
+    locked?: boolean;
 };
 /** A two-point trendline from `points[0]` to `points[1]`. */
 type LineDrawing = DrawingBase & {
@@ -192,6 +198,15 @@ type BoxDrawing = DrawingBase & {
     type: 'box';
     /** Two opposite corners, in data space. */
     points: [DrawPoint, DrawPoint];
+    /**
+     * Interior fill, painted beneath the stroke. Omitted, the interior keeps its
+     * default tint of the stroke color at 10% alpha.
+     *
+     * A solid fill hides the candles the box was drawn around, so this usually
+     * wants an alpha — as the high byte of an 8-digit hex (`'#5400ce2c'` is a
+     * green at 33%), since vroom reads hex as `#aarrggbb`, not CSS `#rrggbbaa`.
+     */
+    fill?: VroomColor;
 };
 /**
  * A freehand pencil stroke: an open path through `points`, in order. Unlike the
@@ -224,6 +239,35 @@ type PathDrawing = DrawingBase & {
  * `'line'` and `'box'` are always exactly two points.
  */
 type Drawing = LineDrawing | BoxDrawing | PencilDrawing | PathDrawing;
+/** An axis-aligned rectangle in CSS px, relative to the chart container. */
+type DrawingRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** The currently selected drawing and where it sits on screen. */
+type DrawingSelection = {
+    /**
+     * The selected drawing. While a drag or reshape is in flight this holds the
+     * last committed geometry — the edit reaches you through `onDrawingChange`
+     * on release — whereas `rect` tracks the shape live.
+     */
+    drawing: Drawing;
+    /** The drawing's bounds in CSS px, relative to the chart container. */
+    rect: DrawingRect;
+};
+/**
+ * The subset of a drawing's appearance a host can change after the fact,
+ * through `restyle`. Fields left out are kept as they were.
+ */
+type DrawingStyle = {
+    color?: VroomColor;
+    width?: number;
+    /** Box interior fill; ignored by the other drawing types. */
+    fill?: VroomColor;
+    locked?: boolean;
+};
 /**
  * Storage adapter for **managed** drawing persistence. Provide it via the
  * `drawingStore` prop and the chart owns the drawings array itself — loading and
@@ -264,11 +308,11 @@ type UndoRedoState = {
     canRedo: boolean;
 };
 /**
- * Programmatic undo/redo controls, published through the `historyRef` prop in
- * managed mode — for toolbar buttons and other UI outside the chart. The
- * keyboard shortcuts (⌘Z / ⇧⌘Z / Ctrl+Y) work without this.
+ * Programmatic controls over the chart's drawings, published through the
+ * `historyRef` prop in managed mode — for toolbar buttons and other UI outside
+ * the chart. The keyboard shortcuts (⌘Z / ⇧⌘Z / Ctrl+Y) work without this.
  */
-type UndoRedoControls = {
+type DrawingControls = {
     /** Roll back the most recent committed drawing action. No-op when empty. */
     undo: () => void;
     /** Re-apply the most recently undone action. No-op when empty. */
@@ -279,6 +323,16 @@ type UndoRedoControls = {
      * chart for what the user perceives as a brand-new context.
      */
     clearHistory: () => void;
+    /**
+     * Restyle the drawing with this `id`, merging `patch` over its current
+     * appearance. No-op for an unknown id.
+     *
+     * In managed mode the chart owns the drawings array, so this is the only way
+     * to say "this drawing's color is now X" — the array is otherwise mutated by
+     * user gestures alone. The change records an undo step and persists like any
+     * other edit.
+     */
+    restyle: (id: string, patch: DrawingStyle) => void;
 };
 /** Price source for a moving average. */
 type MASource = 'close' | 'open' | 'high' | 'low' | 'hl2' | 'hlc3' | 'ohlc4';
@@ -749,6 +803,17 @@ type VroomChartCoreProps = {
      * drawing with this `id` from your controlled `drawings` state. Web only.
      */
     onDrawingDelete?: (id: string) => void;
+    /**
+     * Fired when the selected drawing changes, and again whenever its position on
+     * screen moves — panning, zooming, resizing, or dragging the shape itself.
+     * `null` on deselect.
+     *
+     * Anchor a floating toolbar to `selection.rect` and it will stay attached to
+     * the drawing: the rect is recomputed from live chart state once per painted
+     * frame, so it tracks 1:1 rather than settling after the gesture. Works in
+     * both controlled and managed mode. Web only.
+     */
+    onSelectionChange?: (selection: DrawingSelection | null) => void;
     /**
      * Fired when the chart wants the mode changed — e.g. it requests `'pan'` after
      * the user clicks away from a just-drawn line. Since `mode` is controlled, the
@@ -769,13 +834,13 @@ type VroomChartCoreProps = {
      */
     onHistoryChange?: (state: UndoRedoState) => void;
     /**
-     * Receives programmatic `undo`/`redo`/`clearHistory` controls in managed mode
-     * (e.g. `useRef<UndoRedoControls | null>(null)` passed here, then
+     * Receives programmatic `undo`/`redo`/`clearHistory`/`restyle` controls in
+     * managed mode (e.g. `useRef<DrawingControls | null>(null)` passed here, then
      * `historyRef.current?.undo()` from a toolbar button). Set to `null` while
      * unmounted or when no `drawingStore` is present. Web only.
      */
     historyRef?: {
-        current: UndoRedoControls | null;
+        current: DrawingControls | null;
     };
     /**
      * Fired when the user presses the undo shortcut (⌘Z / Ctrl+Z) in controlled

package/lib/index.d.ts

@@ -177,6 +177,12 @@ type DrawingBase = {
     color?: VroomColor;
     /** Stroke width in px. Default 2. */
     width?: number;
+    /**
+     * Protect the drawing from editing. A locked drawing still renders and can
+     * still be selected — so a toolbar can offer to unlock it — but it can't be
+     * dragged, reshaped or deleted, and its grab handles aren't drawn. Web only.
+     */
+    locked?: boolean;
 };
 /** A two-point trendline from `points[0]` to `points[1]`. */
 type LineDrawing = DrawingBase & {
@@ -192,6 +198,15 @@ type BoxDrawing = DrawingBase & {
     type: 'box';
     /** Two opposite corners, in data space. */
     points: [DrawPoint, DrawPoint];
+    /**
+     * Interior fill, painted beneath the stroke. Omitted, the interior keeps its
+     * default tint of the stroke color at 10% alpha.
+     *
+     * A solid fill hides the candles the box was drawn around, so this usually
+     * wants an alpha — as the high byte of an 8-digit hex (`'#5400ce2c'` is a
+     * green at 33%), since vroom reads hex as `#aarrggbb`, not CSS `#rrggbbaa`.
+     */
+    fill?: VroomColor;
 };
 /**
  * A freehand pencil stroke: an open path through `points`, in order. Unlike the
@@ -224,6 +239,35 @@ type PathDrawing = DrawingBase & {
  * `'line'` and `'box'` are always exactly two points.
  */
 type Drawing = LineDrawing | BoxDrawing | PencilDrawing | PathDrawing;
+/** An axis-aligned rectangle in CSS px, relative to the chart container. */
+type DrawingRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** The currently selected drawing and where it sits on screen. */
+type DrawingSelection = {
+    /**
+     * The selected drawing. While a drag or reshape is in flight this holds the
+     * last committed geometry — the edit reaches you through `onDrawingChange`
+     * on release — whereas `rect` tracks the shape live.
+     */
+    drawing: Drawing;
+    /** The drawing's bounds in CSS px, relative to the chart container. */
+    rect: DrawingRect;
+};
+/**
+ * The subset of a drawing's appearance a host can change after the fact,
+ * through `restyle`. Fields left out are kept as they were.
+ */
+type DrawingStyle = {
+    color?: VroomColor;
+    width?: number;
+    /** Box interior fill; ignored by the other drawing types. */
+    fill?: VroomColor;
+    locked?: boolean;
+};
 /**
  * Storage adapter for **managed** drawing persistence. Provide it via the
  * `drawingStore` prop and the chart owns the drawings array itself — loading and
@@ -264,11 +308,11 @@ type UndoRedoState = {
     canRedo: boolean;
 };
 /**
- * Programmatic undo/redo controls, published through the `historyRef` prop in
- * managed mode — for toolbar buttons and other UI outside the chart. The
- * keyboard shortcuts (⌘Z / ⇧⌘Z / Ctrl+Y) work without this.
+ * Programmatic controls over the chart's drawings, published through the
+ * `historyRef` prop in managed mode — for toolbar buttons and other UI outside
+ * the chart. The keyboard shortcuts (⌘Z / ⇧⌘Z / Ctrl+Y) work without this.
  */
-type UndoRedoControls = {
+type DrawingControls = {
     /** Roll back the most recent committed drawing action. No-op when empty. */
     undo: () => void;
     /** Re-apply the most recently undone action. No-op when empty. */
@@ -279,6 +323,16 @@ type UndoRedoControls = {
      * chart for what the user perceives as a brand-new context.
      */
     clearHistory: () => void;
+    /**
+     * Restyle the drawing with this `id`, merging `patch` over its current
+     * appearance. No-op for an unknown id.
+     *
+     * In managed mode the chart owns the drawings array, so this is the only way
+     * to say "this drawing's color is now X" — the array is otherwise mutated by
+     * user gestures alone. The change records an undo step and persists like any
+     * other edit.
+     */
+    restyle: (id: string, patch: DrawingStyle) => void;
 };
 /** Price source for a moving average. */
 type MASource = 'close' | 'open' | 'high' | 'low' | 'hl2' | 'hlc3' | 'ohlc4';
@@ -749,6 +803,17 @@ type VroomChartCoreProps = {
      * drawing with this `id` from your controlled `drawings` state. Web only.
      */
     onDrawingDelete?: (id: string) => void;
+    /**
+     * Fired when the selected drawing changes, and again whenever its position on
+     * screen moves — panning, zooming, resizing, or dragging the shape itself.
+     * `null` on deselect.
+     *
+     * Anchor a floating toolbar to `selection.rect` and it will stay attached to
+     * the drawing: the rect is recomputed from live chart state once per painted
+     * frame, so it tracks 1:1 rather than settling after the gesture. Works in
+     * both controlled and managed mode. Web only.
+     */
+    onSelectionChange?: (selection: DrawingSelection | null) => void;
     /**
      * Fired when the chart wants the mode changed — e.g. it requests `'pan'` after
      * the user clicks away from a just-drawn line. Since `mode` is controlled, the
@@ -769,13 +834,13 @@ type VroomChartCoreProps = {
      */
     onHistoryChange?: (state: UndoRedoState) => void;
     /**
-     * Receives programmatic `undo`/`redo`/`clearHistory` controls in managed mode
-     * (e.g. `useRef<UndoRedoControls | null>(null)` passed here, then
+     * Receives programmatic `undo`/`redo`/`clearHistory`/`restyle` controls in
+     * managed mode (e.g. `useRef<DrawingControls | null>(null)` passed here, then
      * `historyRef.current?.undo()` from a toolbar button). Set to `null` while
      * unmounted or when no `drawingStore` is present. Web only.
      */
     historyRef?: {
-        current: UndoRedoControls | null;
+        current: DrawingControls | null;
     };
     /**
      * Fired when the user presses the undo shortcut (⌘Z / Ctrl+Z) in controlled

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vroom-chart",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Mobile-first Skia candlestick chart for React Native",
   "license": "MIT",
   "author": "Darion Welch",
@@ -83,6 +83,7 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "build": "tsup",
+    "check:podspec": "ruby scripts/check-podspec-portable.rb",
     "vendor:core": "node scripts/vendor-core.mjs"
   }
 }

package/react-native-vroom-chart.podspec

@@ -1,16 +1,30 @@
 require "json"
+require "pathname"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
-# Resolve the absolute path to the @shopify/react-native-skia source.
-# We need it because RN-Skia ships its Skia headers via `#include "include/core/SkPicture.h"`,
-# which only resolves when the include path points at the source `cpp/` and `cpp/skia/`
-# directories — CocoaPods' flat Headers/Public/ layout loses the `include/...` prefix.
+# Locate the @shopify/react-native-skia source. We need it because RN-Skia ships
+# its Skia headers via `#include "include/core/SkPicture.h"`, which only resolves
+# when the include path points at the source `cpp/` and `cpp/skia/` directories —
+# CocoaPods' flat Headers/Public/ layout loses the `include/...` prefix.
+#
+# The paths must be emitted relative to $(PODS_TARGET_SRCROOT), never absolute.
+# CocoaPods serializes this spec to `Pods/Local Podspecs/*.podspec.json` and hashes
+# that file into Podfile.lock's SPEC CHECKSUMS, so an absolute path bakes the
+# checkout root of whoever ran `pod install` into the lockfile and every other
+# machine fails `pod install --deployment`. Resolving at spec-eval time (rather
+# than hardcoding `../@shopify/react-native-skia`) keeps this correct under
+# non-hoisted layouts such as pnpm's.
 skia_pkg_json = `node --print "require.resolve('@shopify/react-native-skia/package.json')"`.strip
+raise "react-native-vroom-chart: could not resolve @shopify/react-native-skia" if skia_pkg_json.empty?
 skia_src_dir = File.dirname(skia_pkg_json)
-skia_cpp_dir = File.join(skia_src_dir, "cpp")
-skia_skia_dir = File.join(skia_src_dir, "cpp", "skia")
-skia_api_dir = File.join(skia_src_dir, "cpp", "api")
+skia_rel_dir = File.join("$(PODS_TARGET_SRCROOT)",
+  Pathname.new(skia_src_dir).relative_path_from(Pathname.new(__dir__)).to_s)
+skia_cpp_dir = File.join(skia_rel_dir, "cpp")
+skia_skia_dir = File.join(skia_rel_dir, "cpp", "skia")
+skia_api_dir = File.join(skia_rel_dir, "cpp", "api")
+# Absolute is fine here: the result only selects a preprocessor-define string,
+# so it never reaches the emitted spec.
 use_graphite = File.exist?(File.join(skia_src_dir, "libs", ".graphite"))
 skia_preprocessor_defs = use_graphite ?
   "$(inherited) SK_GRAPHITE=1 SK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API=1 SK_DISABLE_LEGACY_SHAPER_FACTORY=1" :