view.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <atomic>
#include <cstdint>
#include <pulp/view/css_animation.hpp>
#include <pulp/view/geometry.hpp>
#include <pulp/view/input_events.hpp>
#include <pulp/view/theme.hpp>
#include <pulp/canvas/canvas.hpp>
#include <pulp/canvas/view_effect.hpp>
#include <functional>
#include <optional>
#include <vector>
#include <memory>
#include <string>
#include <string_view>
 
#include <pulp/dataplane/fwd.hpp>
 
namespace pulp::view {
 
class WindowHost;  // Forward declaration for View→Host back-reference
class PluginViewHost;
class WidgetBridge;
class GestureArbiter; class GestureRecognizer;
class FrameClock;
class WidgetPainter;     // pulp/view/widget_painter.hpp — pluggable paint delegate
class WidgetMetrics;     // pulp/view/widget_metrics.hpp — pluggable sizing delegate
class SelectableText;    // pulp/view/selectable_text.hpp — cross-widget text selection
class FrameClockBinding; // pulp/view/value_source_binding.hpp
struct ViewValueBindings; // pulp/view/src/view.cpp — lazily allocated value-source bindings
struct FileDragRequest;  // pulp/view/drag_drop.hpp
struct ActiveDrag;       // pulp/view/drag_drop.hpp
struct DropData;         // pulp/view/drag_drop.hpp
class ComboBox;          // pulp/view/ui_components.hpp — held (as View*) in RootInteractionState
class View;

enum class RuntimeViewKind : std::uint8_t {
    generic, knob, fader, toggle, scroll, eq_curve, design_frame
};

class ViewCapture {
public:
    void set(View* view) noexcept;
    void reset() noexcept;
    bool has_value() const noexcept { return view_ != nullptr; }
    View* live_in(View& root) const noexcept;
 
private:
    View* view_ = nullptr;
    std::uint64_t instance_id_ = 0;
    mutable View* validated_root_ = nullptr;
    mutable std::uint64_t validated_root_instance_id_ = 0;
    mutable std::uint64_t validated_generation_ = 0;
};
 
// Base class for all UI elements
// Views form a tree: each view has zero or more children and one optional parent
class View {
public:
    View();
    virtual ~View();
 
    View(const View&) = delete;
    View& operator=(const View&) = delete;
 
    // ── Bounds and layout ────────────────────────────────────────────────
 
    // The view's bounds in its parent's coordinate space
    Rect bounds() const { return bounds_; }
    void set_bounds(Rect r);
 
    // The view's local bounds (origin at 0,0)
    Rect local_bounds() const { return {0, 0, bounds_.width, bounds_.height}; }
 
    // Flex layout style
    FlexStyle& flex() { return flex_; }
    const FlexStyle& flex() const { return flex_; }
 
    GridStyle& grid() { return grid_; }
    const GridStyle& grid() const { return grid_; }
 
    void set_layout_mode(LayoutMode m) { layout_mode_ = m; }
    LayoutMode layout_mode() const { return layout_mode_; }

    void set_subpixel_layout(bool v) { subpixel_layout_ = v; }
    bool subpixel_layout() const { return subpixel_layout_; }
    void set_captured_frame_root(bool v) {
        captured_frame_root_ = v;
    }
    bool captured_frame_root() const {
        return captured_frame_root_;
    }
 
    // ── Child management ─────────────────────────────────────────────────

    std::unique_ptr<View> add_child(std::unique_ptr<View> child);
    // Transactional variant used by structural adapters that must recover the
    // owned child if an attach hook rejects it. On throw, `child` is restored.
    // Returns false, with `child` untouched, when the child is refused.
    bool add_child_transactional(std::unique_ptr<View>& child);
    std::unique_ptr<View> remove_child(View* child);

    bool move_child_to_index(View* child, size_t index);

    void retire(std::unique_ptr<View> owned) noexcept;

    static std::uint64_t structure_generation() noexcept;
    std::uint64_t root_structure_generation() const noexcept;
 
    size_t child_count() const { return children_.size(); }
    View* child_at(size_t index) { return children_[index].get(); }
    const View* child_at(size_t index) const { return children_[index].get(); }
    View* parent() const { return parent_; }
 
    // ── Reload state (live-swap item 1.4b) ───────────────────────────────
    // A CUSTOM widget overrides these to carry its own state across a
    // scripted-UI hot reload, beyond the built-in knob/fader/combo/segmented/
    // toggle/checkbox/xy coverage the WidgetBridge snapshots by type.
    // save_reload_state writes an opaque blob and returns true to OPT IN;
    // restore_reload_state applies a blob previously written by the same widget
    // type (matched by the script's widget id). Default: no custom state
    // (returns false), so every existing widget is unaffected — the bridge only
    // stores/restores a blob for widgets that opt in.
    virtual bool save_reload_state(std::string& /*out_blob*/) const { return false; }
    virtual bool restore_reload_state(std::string_view /*blob*/) { return false; }
 
    // ── View recycling (ViewPool, planning 2.3) ──────────────────────────
    // A recyclable View can be parked in a ViewPool when it scrolls out of a
    // virtualized list/grid (or is torn down by a hot reload) and handed back
    // later instead of being destroyed and rebuilt. Recycling is OPT-IN: a
    // subclass must override supports_reuse() to return true, otherwise
    // ViewPool::release() destroys it and adoption stays behavior-neutral.
    //
    // supports_reuse() advertises that prepare_for_reuse() leaves the instance
    // in a safe, blank-slate state — no live callbacks into freed state, no
    // stale bounds/selection/focus. Only override it once that contract holds.
    virtual bool supports_reuse() const { return false; }
 
    // Scrub every piece of per-instance state that must NOT survive into the
    // next user of a recycled View. The ViewPool calls this on the acquire
    // path, so a pooled view carries no live state while parked. Subclasses
    // that add their own callbacks / cached state MUST override this, reset
    // their own members, then call View::prepare_for_reuse() to run the base
    // reset below. The base impl clears bounds/visibility/opacity/access
    // labels/pointer+hover+focus state AND EVERY base-class callback — a
    // recycled view firing a stale on_click/on_drag/etc. into a torn-down
    // closure is the exact use-after-free this guards against.
    //
    // Precondition: the view must be detached (no parent) — a pooled view is
    // never part of a live tree.
    virtual void prepare_for_reuse();
 
    // ── Hit testing ──────────────────────────────────────────────────────
 
    // Find the deepest child containing the point. A detached root accepts
    // painted root-local coordinates and peels its own scale; recursive calls
    // receive the child's already-unscaled local coordinates.
    virtual View* hit_test(Point local_point);
 
    // ── Theme ────────────────────────────────────────────────────────────
 
    void set_theme(const Theme& theme) { theme_ = theme; request_repaint(); }
    const Theme& theme() const { return theme_; }
 
    // Resolve a color: check own theme first, then walk up to parent
    Color resolve_color(const std::string& name, Color fallback = {}) const;

    void set_color(std::string name, Color c) {
        theme_.colors[std::move(name)] = c;
        request_repaint();
    }
 
    // ── Paint delegate ───────────────────────────────────────────────────
    //
    // A WidgetPainter installed here supplies the pixels for the stock controls
    // in this view AND its whole subtree, unless a descendant installs its own.
    // See widget_painter.hpp. Each hook defaults to declining, so a delegate
    // restyles only the controls it implements and the rest keep Pulp's look.
 
    void set_painter(std::shared_ptr<WidgetPainter> p);
    const std::shared_ptr<WidgetPainter>& painter() const { return painter_; }

    WidgetPainter* effective_painter() const;
 
    // ── Metrics delegate ─────────────────────────────────────────────────
    //
    // The sizing sibling of the painter: same install, same subtree cascade,
    // same decline-by-default hooks. Consulted during LAYOUT, where there is no
    // canvas — which is why it is a separate object from the painter. Widgets
    // reach it from `intrinsic_width()`/`intrinsic_height()` (the function the
    // layout engine already calls to measure a leaf), or directly when they
    // position themselves. See widget_metrics.hpp.
 
    void set_metrics(std::shared_ptr<WidgetMetrics> m);
    const std::shared_ptr<WidgetMetrics>& metrics() const { return metrics_; }

    WidgetMetrics* effective_metrics() const;
 
    // ── CSS-style typography inheritance ─────────────────────────────────
    //
    // Mirrors CSS: setting `color: white` on a parent View cascades down
    // to every text descendant unless overridden. These fields are stored
    // on the View but DO NOT affect the View's own paint — they're picked
    // up by Label::paint() (and other text widgets) when the widget has
    // no explicit value of its own.
    //
    // The cascade order at paint time is:
    //   1. Widget's own explicit value (e.g. Label::set_font_size on this Label)
    //   2. inheritable_*() — walks up the parent chain returning the first
    //      ancestor that set the matching field
    //   3. Theme token / widget default fallback (existing behavior)
    //
    // text_align uses int rather than LabelAlign to keep View free of a
    // back-include of widgets.hpp; the int matches LabelAlign's enum
    // order: 0 = left, 1 = center, 2 = right.
 
    void set_inheritable_text_color(Color c) {
        inh_text_color_ = c;
        invalidate_subtree_caches_up();
    }
    void clear_inheritable_text_color() { inh_text_color_.reset(); }
    std::optional<Color> inheritable_text_color() const;
 
    // An inheritable typography value is read by every descendant Label that
    // did not set its own, so it changes their measured boxes and must move
    // the layout generation for the same reason Label's own setters do.
    // Guarded on a real change so a replayed identical style stays clean.
    void set_inheritable_font_size(float size) {
        if (inh_font_size_ && *inh_font_size_ == size)
            return;
        inh_font_size_ = size;
        invalidate_layout();
    }
    void clear_inheritable_font_size() { inh_font_size_.reset(); }
    std::optional<float> inheritable_font_size() const;
 
    void set_inheritable_letter_spacing(float sp) {
        if (inh_letter_spacing_ && *inh_letter_spacing_ == sp)
            return;
        inh_letter_spacing_ = sp;
        invalidate_layout();
    }
    void clear_inheritable_letter_spacing() { inh_letter_spacing_.reset(); }
    std::optional<float> inheritable_letter_spacing() const;
 
    void set_inheritable_font_weight(int w) {
        if (inh_font_weight_ && *inh_font_weight_ == w)
            return;
        inh_font_weight_ = w;
        invalidate_layout();
    }
    void clear_inheritable_font_weight() { inh_font_weight_.reset(); }
    std::optional<int> inheritable_font_weight() const;

    void set_inheritable_font_family(std::string f) {
        if (inh_font_family_ && *inh_font_family_ == f)
            return;
        inh_font_family_ = std::move(f);
        invalidate_layout();
    }
    void clear_inheritable_font_family() { inh_font_family_.reset(); }
    std::optional<std::string> inheritable_font_family() const;

    void set_inheritable_text_align(int a) { inh_text_align_ = a; }
    void clear_inheritable_text_align() { inh_text_align_.reset(); }
    std::optional<int> inheritable_text_align() const;
 
    // ── Visibility ───────────────────────────────────────────────────────
 
    bool visible() const { return visible_; }
    void set_visible(bool v) {
        if (visibility_quarantine_count_ > 0) {
            visible_after_quarantine_ = v;
            return;
        }
        const bool changed = visible_ != v;
        visible_ = v;
        invalidate_subtree_caches_up();
        if (changed) {
            // Parent layout decides whether this child occupies space. Dirty
            // the whole path so showing a child assigns fresh bounds and
            // hiding it lets siblings close the gap before the repaint.
            for (View* node = this; node; node = node->parent_)
                node->invalidate_layout();
            request_repaint();
        }
    }
 
    // ── Layout ───────────────────────────────────────────────────────────
 
    // Perform flex layout on children (virtual so ScrollView can override)
    virtual void layout_children();
    void layout_children_if_needed() {
        if (layout_is_current()) return;
        layout_children();
        mark_layout_current();
    }
    bool layout_is_current() const noexcept {
        return applied_layout_generation_ == tree_layout_generation();
    }
    void mark_layout_current() noexcept {
        applied_layout_generation_ = tree_layout_generation();
    }

    std::uint64_t tree_layout_generation() const noexcept;
    virtual bool owns_child_layout() const { return false; }

    virtual float intrinsic_width() const { return 0; }
    virtual float intrinsic_height() const;  // default: sum of visible children for containers
 
    // ── Painting ──────────────────────────────────────────────────────────
 
    // Paint this view and all children into a canvas
    virtual void paint_all(canvas::Canvas& canvas);
 
    // Last paint cycle's wall-clock cost.
    // Updated by paint_all() at the end of each paint pass. Exposed so
    // the inspector property panel can show per-view timing without
    // adding new instrumentation per query.
    //
    //   last_paint_self_ns()         — time spent INSIDE this view's
    //                                  paint(canvas) override only.
    //   last_paint_with_children_ns() — time spent INSIDE paint(canvas)
    //                                  PLUS time recursively painting
    //                                  every descendant. The
    //                                  difference (with_children - self)
    //                                  attributes child cost cleanly.
    //
    // Both are 0 until the view has been painted at least once. Updated
    // every frame; readers see the most recent sample. Storage is two
    // uint32_t fields per view (cap at ~4s of paint time which is far
    // beyond any realistic frame budget).
    std::uint32_t last_paint_self_ns() const { return last_paint_self_ns_; }
    std::uint32_t last_paint_with_children_ns() const { return last_paint_with_children_ns_; }
 
    // ── Lifecycle (override in subclasses) ────────────────────────────────
 
    virtual void paint(canvas::Canvas&) {}
    virtual void on_resized() {}
    virtual void on_attached() {}
    virtual void on_detached() {}
    virtual void advance_animations(float dt) { (void)dt; }
    virtual void on_frame_clock_changed() {}
 
    // ── Input events (rich, with modifiers and pointer ID) ──────────────

    virtual void on_mouse_event(const MouseEvent& event) {
        // An `overflow: scroll` container consumes the wheel the way
        // ScrollView does — it is the scroll boundary, so the tick does not
        // also reach the pointer callback.
        if (event.is_wheel && handle_scroll_wheel(event))
            return;
        auto callback = on_pointer_event;
        if (callback) callback(event);
    }

    bool handle_scroll_wheel(const MouseEvent& event);
    virtual bool wants_wheel_value() const { return false; }
    virtual void on_wheel(float delta_y) { (void)delta_y; }
    virtual bool is_gesture_active() const { return false; }
    virtual bool wants_wheel_scroll() const;
    virtual bool wants_mouse_input() const { return false; }
    virtual bool on_key_event(const KeyEvent& event) { (void)event; return false; }
    virtual void on_text_input(const TextInputEvent& event) { (void)event; }
    virtual void on_focus_changed(bool gained) { has_focus_ = gained; }

    virtual void on_gesture_event(const GestureEvent& event) {
        if (on_gesture_cb) on_gesture_cb(event);
    }
    GestureRecognizer& add_gesture_recognizer(std::unique_ptr<GestureRecognizer> recognizer);
    void clear_gesture_recognizers(); size_t gesture_recognizer_count() const { return gesture_recognizers_.size(); }
    GestureRecognizer* gesture_recognizer_at(size_t index); const GestureRecognizer* gesture_recognizer_at(size_t index) const;
    bool dispatch_gesture_pointer_event(const MouseEvent& root_event, double timestamp_seconds = -1.0);
    void advance_gesture_recognizers(double timestamp_seconds = -1.0); bool has_time_driven_gestures() const;

    bool gesture_claimed_pointer() const;
    // ── Pointer capture (W3C setPointerCapture) ─────────────────────────

    void set_pointer_capture(int pointer_id);
    void release_pointer_capture(int pointer_id);
    bool has_pointer_capture(int pointer_id) const;
 
    // ── Legacy event handlers (kept for backward compatibility) ──────────
 
    virtual void on_mouse_down(Point pos) { (void)pos; }
    virtual void on_mouse_up(Point pos) { (void)pos; }
    virtual void on_mouse_drag(Point pos) { (void)pos; }

    virtual void on_mouse_cancel(Point pos) { on_mouse_up(pos); }
    virtual void on_key_press(int key_code) { (void)key_code; }
 
    // ── Hover events ──────────────────────────────────────────────────────
 
    virtual void on_mouse_enter() {}
    virtual void on_mouse_leave() {}

    virtual void on_hover_move(Point local_pos) { (void)local_pos; }
 
    bool is_hovered() const { return hovered_; }
    void set_hovered(bool h);

    void set_default_hover_feedback(bool enabled) {
        default_hover_feedback_ = enabled;
    }
    bool default_hover_feedback() const { return default_hover_feedback_; }
 
    // ── Frame clock ─────────────────────────────────────────────────────

    void set_frame_clock(FrameClock* clock);

    FrameClock* frame_clock() const;
 
    // ── Live host→view value sources ────────────────────────────────────────
    // The seam a view showing a live host value (a meter, a readout, a
    // modulation ring) uses instead of hand-rolling a frame-clock-polled
    // reader. nullptr unbinds. UI thread. Semantics, paint-safety, the
    // frames-alive effect and the FrameClock lifetime contract are documented
    // once in value_source_binding.hpp.

    void set_meter_source(std::shared_ptr<MeterSource> source, int channel = 0);
    bool has_meter_source() const;
    int meter_source_channel() const;

    const MeterFrame& meter_frame() const;

    void set_scalar_source(std::shared_ptr<ScalarSource> source);
    bool has_scalar_source() const;

    float scalar_value() const;

    virtual void on_meter_frame(const MeterFrame& frame, float dt) {
        (void)frame;
        (void)dt;
    }

    virtual void on_meter_snapshot_changed() {
        request_repaint();
    }
 
    // ── Transient-animation glue ─────────────────────────────────────────────
    // Tween/easing already exist; what a faithful port re-rolls every time is
    // the View-lifecycle glue — self-(un)subscribing a FrameClock callback and
    // repainting. animate() does exactly that: it interpolates a float from
    // `from` to `to` over `duration_s` seconds through `ease`, applies each
    // step via `apply`, and repaints. It auto-unsubscribes on completion AND on
    // View destruction (so a fade that outlives its view can't use-after-free).
    // Returns an animation id, or -1 if no FrameClock is reachable yet
    // (previews/screenshots — the caller should just set the final value).
    // A non-empty `tag` makes the animation self-cancelling: starting a new one
    // with the same tag cancels the prior (e.g. re-hovering before a fade ends).
    // `on_done` fires once when the tween reaches `to`, never when cancelled.
    int animate(std::function<void(float)> apply, float from, float to,
                float duration_s, std::function<float(float)> ease = {},
                std::function<void()> on_done = {}, const std::string& tag = {});

    void cancel_animation(int id);
    int active_animation_count() const { return static_cast<int>(animations_.size()); }
 
    // ── Theme dimension resolution ──────────────────────────────────────

    float resolve_dimension(const std::string& name, float fallback) const;

    struct SimulatedPointer {
        PointerType type = PointerType::mouse;
        float pressure = 0.5f;
        std::uint16_t modifiers = 0;
        MouseButton button = MouseButton::left;
        int pointer_id = 0;
    };
 
    // Dispatch a synthetic click to the deepest view at the given point
    void simulate_click(Point root_pos);

    void simulate_click(Point root_pos, const SimulatedPointer& pointer);

    bool simulate_context_click(Point root_pos);
 
    // Dispatch a synthetic drag from start to end
    void simulate_drag(Point start, Point end, int steps = 10);

    void simulate_drag(Point start, Point end, int steps,
                       const SimulatedPointer& pointer);
 
    // Dispatch a synthetic hover to the view at the given point
    void simulate_hover(Point root_pos);
 
    // ── Keyboard focus ───────────────────────────────────────────────────
 
    bool focusable() const { return focusable_; }
    void set_focusable(bool f) { focusable_ = f; }

    virtual bool accepts_text_input() const { return false; }

    virtual SelectableText* as_selectable_text() {
        return nullptr;
    }
    const SelectableText* as_selectable_text() const {
        return const_cast<View*>(this)->as_selectable_text();
    }

    void set_text_selection_region(bool region) {
        text_selection_region_ = region;
    }
    bool text_selection_region() const {
        return text_selection_region_;
    }

    bool enabled() const { return enabled_; }
    void set_enabled(bool e) { enabled_ = e; }

    bool hit_testable() const { return hit_testable_; }
    void set_hit_testable(bool h) { hit_testable_ = h; }

    enum class PointerEvents { auto_, none, box_only, box_none };
    void set_pointer_events(PointerEvents p) { pointer_events_ = p; }
    PointerEvents pointer_events() const { return pointer_events_; }

    struct HitSlop {
        float top = 0.0f, right = 0.0f, bottom = 0.0f, left = 0.0f;
        bool empty() const {
            return top == 0.0f && right == 0.0f && bottom == 0.0f && left == 0.0f;
        }
    };
    void set_hit_slop(float uniform) { hit_slop_ = {uniform, uniform, uniform, uniform}; }
    void set_hit_slop(float top, float right, float bottom, float left) {
        hit_slop_ = {top, right, bottom, left};
    }
    void set_hit_slop(HitSlop s) { hit_slop_ = s; }
    HitSlop hit_slop() const { return hit_slop_; }

    Rect hit_bounds() const {
        Rect b = local_bounds();
        return Rect{b.x - hit_slop_.left, b.y - hit_slop_.top,
                    b.width + hit_slop_.left + hit_slop_.right,
                    b.height + hit_slop_.top + hit_slop_.bottom};
    }

    bool backface_visible() const { return backface_visible_; }
    void set_backface_visible(bool v) {
        backface_visible_ = v;
        invalidate_subtree_caches_up();
    }

    bool requires_gpu_host() const { return requires_gpu_host_; }
    void set_requires_gpu_host(bool v) { requires_gpu_host_ = v; }

    bool contains_native_overlay() const { return contains_native_overlay_; }
    void set_contains_native_overlay(bool v) { contains_native_overlay_ = v; }

    virtual std::vector<uint8_t> capture_native_overlay_png(uint32_t /*width*/,
                                                            uint32_t /*height*/) {
        return {};
    }
 
    // ── Layout generation ───────────────────────────────────────────────
    //
    // A process-wide monotonic counter bumped by ANY mutation that can change
    // computed geometry. It exists so a reader (the JS bridge's geometry
    // queries) can answer "has anything moved since I last laid out?" without
    // running a tree walk to find out.
    //
    // Why not the per-View `layout_dirty_` flag: invalidation does NOT
    // propagate upward. `invalidate_layout()` marks the view it is called on,
    // so a flex change on a deep child leaves `root.layout_dirty()` FALSE while
    // the tree is genuinely stale. A guard reading the root's flag would skip a
    // needed pass and hand back stale (often 0x0) bounds — the exact failure
    // `getLayoutRect`'s comment exists to prevent.
    //
    // The bump lives inside the invalidators themselves rather than at the
    // bridge's entry points, so any mutation path is automatically correct —
    // including host resizes, C++-side widget code, and invalidators written
    // after this. OVER-invalidating costs one redundant layout; UNDER-
    // invalidating is a correctness bug, so the counter is deliberately eager.
    //
    // Starts at 1 so a reader initialised to 0 always lays out once.
    static std::uint64_t layout_generation() noexcept {
        return layout_generation_.load(std::memory_order_relaxed);
    }
    static void bump_layout_generation() noexcept {
        layout_generation_.fetch_add(1, std::memory_order_relaxed);
    }

    static std::uint64_t damage_request_count() noexcept {
        return damage_request_count_.load(std::memory_order_relaxed);
    }
    static std::uint64_t unmarked_paint_mutation_count() noexcept {
        return unmarked_paint_mutation_count_.load(std::memory_order_relaxed);
    }

    static void note_unmarked_paint_mutation() noexcept {
        unmarked_paint_mutation_count_.fetch_add(1, std::memory_order_relaxed);
    }

    Rect map_rect_through_own_transform(const Rect& local) const;
 
    static std::uint64_t layout_pass_count() noexcept {
        return layout_pass_count_.load(std::memory_order_relaxed);
    }

    static std::uint64_t constructed_count() noexcept {
        return constructed_count_.load(std::memory_order_relaxed);
    }
    static std::uint64_t destroyed_count() noexcept {
        return destroyed_count_.load(std::memory_order_relaxed);
    }

    void invalidate_layout() {
        layout_dirty_ = true;
        note_layout_mutation();
    }
    bool layout_dirty() const { return layout_dirty_; }
    void clear_layout_dirty() { layout_dirty_ = false; }

    void request_repaint();

    void request_frame();

    void request_repaint(const Rect& local_dirty);

    void request_repaint_self(float halo = 4.0f);

    bool start_file_drag(const FileDragRequest& request);
 
    // ── In-tree drag source (drag_drop.hpp) ──────────────────────────────
    //
    // Begin a drag whose payload stays in this process and in this view tree.
    // The source view owns the gesture: start_drag() on press-and-move,
    // drag_to() on each motion tick, drop_here() on release.
    //
    //     void on_mouse_drag(Point p) override {
    //         if (!drag_active()) { DropData d; d.text = id_; start_drag(d); }
    //         drag_to(local_to_root(p));
    //     }
    //     void on_mouse_up(Point p) override { drop_here(local_to_root(p)); }
    //
    // All three take ROOT coordinates, the space the drop dispatch works in.
 
    bool start_drag(DropData data);
    void drag_to(Point root_pos);
    bool drop_here(Point root_pos);
    void cancel_drag();
    bool drag_active() const;
    bool has_focus() const { return has_focus_; }
    void set_focus(bool f) { has_focus_ = f; }
 
    // Move focus to next/previous focusable widget
    static View* focus_next(View& root, View* current);
    static View* focus_prev(View& root, View* current);
 
    // ── Accessibility ────────────────────────────────────────────────────

    enum class AccessRole {
        none = 0, slider, toggle, label, group, meter, image,   // frozen 0-6
        button, link, checkbox, radio, text_field, combo_box,
        list, list_item, table, row, cell, tab, tab_list,
        menu, menu_item, progress_bar, dialog, heading, scroll_bar,
    };
 
    void set_access_role(AccessRole role) { access_role_ = role; }
    AccessRole access_role() const { return access_role_; }
    void set_implicit_access_role(AccessRole role) {
        implicit_access_role_ = role;
        access_role_ = role;
    }
    void restore_implicit_access_role() {
        access_role_ = implicit_access_role_;
    }

    void set_access_label(std::string label) { access_label_ = std::move(label); }

    void set_derived_access_label(std::string label) {
        derived_access_label_ = std::move(label);
    }

    const std::string& access_label() const {
        return access_label_.empty() ? derived_access_label_ : access_label_;
    }

    bool has_explicit_access_label() const { return !access_label_.empty(); }

    const std::string& derived_access_label() const { return derived_access_label_; }
 
    void set_access_value(std::string value) { access_value_ = std::move(value); }
    const std::string& access_value() const { return access_value_; }
 
    // ARIA state attributes. Tri-state semantics per the ARIA 1.2 spec
    // (`true` / `false` / `mixed` / unset). We store the raw string the JS shim
    // hands us so platform accessibility bridges can read it back verbatim.
    // Setting the empty string clears the state.
    void set_access_pressed(std::string s)  { access_pressed_  = std::move(s); }
    void set_access_checked(std::string s)  { access_checked_  = std::move(s); }
    void set_access_disabled(std::string s) { access_disabled_ = std::move(s); }
    void set_access_hidden(std::string s)   { access_hidden_   = std::move(s); }
    const std::string& access_pressed()  const { return access_pressed_; }
    const std::string& access_checked()  const { return access_checked_; }
    const std::string& access_disabled() const { return access_disabled_; }
    const std::string& access_hidden()   const { return access_hidden_; }

    virtual void on_accessibility_adjust(float delta) { (void)delta; }
 
    // ── Identity ─────────────────────────────────────────────────────────
 
    void set_id(std::string id) { id_ = std::move(id); }
    const std::string& id() const { return id_; }

    void set_anchor_id(std::string anchor) { anchor_id_ = std::move(anchor); }
    const std::string& anchor_id() const { return anchor_id_; }

    std::uint64_t import_binding_instance_id() const { return import_binding_instance_id_; }
    std::weak_ptr<const std::uint64_t> import_binding_lifetime_token() const {
        return import_binding_lifetime_token_;
    }

    struct SourceLocation {
        std::string file;   
        int line = 0;       
        int col = 0;        
 
        bool valid() const { return !file.empty(); }
    };
 
    void set_source_loc(SourceLocation loc) { source_loc_ = std::move(loc); }
    void clear_source_loc() { source_loc_.reset(); }
    bool has_source_loc() const { return source_loc_.has_value(); }
    const SourceLocation& source_loc() const {
        static const SourceLocation kEmpty{};
        return source_loc_ ? *source_loc_ : kEmpty;
    }
 
    // ── Visual properties (CSS Box Model) ────────────────────────────────

    // Opacity is applied by the live compositing layer, outside any cached
    // recording, so it stales no cache -- but it is a paint change nobody
    // marked, which a batched repaint decision has to see.
    void set_opacity(float o) {
        opacity_ = std::clamp(o, 0.0f, 1.0f);
        note_unmarked_paint_mutation();
    }
    float opacity() const { return opacity_; }

    // The paint setters below skip a write that changes nothing: a script
    // that re-applies the same style every frame must not read as an
    // unmarked paint change (which costs a whole-surface repaint).
    void set_background_color(Color c) {
        if (has_bg_ && bg_color_ == c)
            return;
        bg_color_ = c;
        has_bg_ = true;
        invalidate_subtree_caches_up();
    }
    void clear_background_color() {
        if (!has_bg_)
            return;
        has_bg_ = false;
        invalidate_subtree_caches_up();
    }
    bool has_background_color() const { return has_bg_; }
    Color background_color() const { return bg_color_; }

    void set_captured_box_paint_rect(float left, float top, float right,
                                     float bottom, float device_scale) {
        captured_box_paint_left_ = left;
        captured_box_paint_top_ = top;
        captured_box_paint_right_ = right;
        captured_box_paint_bottom_ = bottom;
        captured_box_paint_scale_ = device_scale > 0.0f ? device_scale : 0.0f;
    }
    bool has_captured_box_paint_rect() const {
        return captured_box_paint_scale_ > 0.0f;
    }
    float captured_box_paint_left() const { return captured_box_paint_left_; }
    float captured_box_paint_top() const { return captured_box_paint_top_; }
    float captured_box_paint_right() const { return captured_box_paint_right_; }
    float captured_box_paint_bottom() const { return captured_box_paint_bottom_; }
    Rect self_paint_bounds() const;

    void set_background_repeat(std::string kw) {
        background_repeat_ = std::move(kw);
        invalidate_subtree_caches_up();
    }
    const std::string& background_repeat() const { return background_repeat_; }

    void set_border(Color c, float width, float radius = 0) {
        border_color_ = c; border_width_ = width; corner_radius_ = radius; has_border_ = true;
        invalidate_subtree_caches_up();
    }
    void clear_border() { has_border_ = false; invalidate_subtree_caches_up(); }
    bool has_border() const { return has_border_; }
    Color border_color() const { return border_color_; }
    float border_width() const { return border_width_; }
    float corner_radius() const { return corner_radius_; }

    void set_border_color(Color c) {
        if (has_border_ && border_color_ == c)
            return;
        border_color_ = c;
        has_border_ = true;
        invalidate_subtree_caches_up();
    }
    void set_border_width(float w) {
        if (has_border_ && border_width_ == w)
            return;
        border_width_ = w;
        has_border_ = true;
        invalidate_subtree_caches_up();
    }
    void set_border_radius(float r) {
        if (corner_radius_ == r && corner_radius_pct_ == 0)
            return;
        corner_radius_ = r;
        corner_radius_pct_ = 0;
        invalidate_subtree_caches_up();
    }

    void set_border_radius_pct(float pct) {
        if (corner_radius_pct_ == pct)
            return;
        corner_radius_pct_ = pct;
        invalidate_subtree_caches_up();
    }
    float corner_radius_pct() const { return corner_radius_pct_; }

    enum class BorderCurve { circular, continuous };
    void set_border_curve(BorderCurve c) { border_curve_ = c; invalidate_subtree_caches_up(); }
    BorderCurve border_curve() const     { return border_curve_; }
    float effective_corner_radius(float width, float height) const {
        if (corner_radius_pct_ > 0.0f) {
            return corner_radius_pct_ * 0.01f * std::min(width, height);
        }
        return corner_radius_;
    }

    enum class BorderStyle {
        solid,   
        dashed,  
        dotted,  
        double_, 
        groove,  
        ridge,   
        inset,   
        outset,  
        none,    
        hidden,  
    };
    void set_border_style(BorderStyle s) { border_style_ = s; invalidate_subtree_caches_up(); }
    BorderStyle border_style() const { return border_style_; }

    enum class ListStyleType {
        none,     
        disc,     
        circle,   
        square,   
        decimal,  
        // CSS Counter Styles Level 3 keywords. Storage-only today; View itself
        // does not paint the marker glyphs. The slots exist so the bridge can
        // round-trip the consumer's keyword honestly. Underscored C++
        // identifiers map to hyphenated CSS keywords (e.g. lower_roman ↔
        // "lower-roman").
        decimal_leading_zero,  
        lower_roman,           
        upper_roman,           
        lower_alpha,           
        upper_alpha,           
        lower_latin,           
        upper_latin,           
        lower_greek,           
        armenian,              
        georgian,              
    };
    enum class ListStylePosition {
        outside,  
        inside,   
    };
    void set_list_style_type(ListStyleType t) { list_style_type_ = t; }
    ListStyleType list_style_type() const { return list_style_type_; }
    void set_list_style_image(std::string url) { list_style_image_ = std::move(url); }
    const std::string& list_style_image() const { return list_style_image_; }
    void set_list_style_position(ListStylePosition p) { list_style_position_ = p; }
    ListStylePosition list_style_position() const { return list_style_position_; }

    void set_outline_color(Color c) {
        outline_color_ = c;
        invalidate_subtree_caches_up();
    }
    void set_outline_offset(float px) {
        outline_offset_ = px;
        invalidate_subtree_caches_up();
    }
    void set_outline_style(BorderStyle s) {
        outline_style_ = s;
        invalidate_subtree_caches_up();
    }
    void set_outline_width(float px) {
        outline_width_ = px;
        invalidate_subtree_caches_up();
    }
    Color outline_color() const { return outline_color_; }
    float outline_offset() const { return outline_offset_; }
    BorderStyle outline_style() const { return outline_style_; }
    float outline_width() const { return outline_width_; }
 

    void set_border_top(Color c, float w) { border_top_ = {c, w}; border_top_set_ = true; border_top_color_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_right(Color c, float w) { border_right_ = {c, w}; border_right_set_ = true; border_right_color_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_bottom(Color c, float w) { border_bottom_ = {c, w}; border_bottom_set_ = true; border_bottom_color_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_left(Color c, float w) { border_left_ = {c, w}; border_left_set_ = true; border_left_color_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_top_color(Color c)    { border_top_.color = c;    border_top_color_set_ = true;    has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_right_color(Color c)  { border_right_.color = c;  border_right_color_set_ = true;  has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_bottom_color(Color c) { border_bottom_.color = c; border_bottom_color_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_left_color(Color c)   { border_left_.color = c;   border_left_color_set_ = true;   has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_top_width(float w)    { border_top_.width = w;    border_top_set_ = true;    has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_right_width(float w)  { border_right_.width = w;  border_right_set_ = true;  has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_bottom_width(float w) { border_bottom_.width = w; border_bottom_set_ = true; has_border_sides_ = true; invalidate_subtree_caches_up(); }
    void set_border_left_width(float w)   { border_left_.width = w;   border_left_set_ = true;   has_border_sides_ = true; invalidate_subtree_caches_up(); }
    Color border_top_color() const { return border_top_.color; }
    float border_top_width() const { return border_top_.width; }
    Color border_right_color() const { return border_right_.color; }
    float border_right_width() const { return border_right_.width; }
    Color border_bottom_color() const { return border_bottom_.color; }
    float border_bottom_width() const { return border_bottom_.width; }
    Color border_left_color() const { return border_left_.color; }
    float border_left_width() const { return border_left_.width; }
    bool has_border_sides() const { return has_border_sides_; }
    bool has_border_top_set() const { return border_top_set_; }
    bool has_border_right_set() const { return border_right_set_; }
    bool has_border_bottom_set() const { return border_bottom_set_; }
    bool has_border_left_set() const { return border_left_set_; }
    bool has_border_top_color_set() const { return border_top_color_set_; }
    bool has_border_right_color_set() const { return border_right_color_set_; }
    bool has_border_bottom_color_set() const { return border_bottom_color_set_; }
    bool has_border_left_color_set() const { return border_left_color_set_; }

    void set_corner_radius_tl(float r) { promote_uniform_to_per_corner(); corner_radii_[0] = r; corner_radii_pct_[0] = 0; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_tr(float r) { promote_uniform_to_per_corner(); corner_radii_[1] = r; corner_radii_pct_[1] = 0; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_bl(float r) { promote_uniform_to_per_corner(); corner_radii_[2] = r; corner_radii_pct_[2] = 0; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_br(float r) { promote_uniform_to_per_corner(); corner_radii_[3] = r; corner_radii_pct_[3] = 0; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_tl_pct(float pct) { promote_uniform_to_per_corner(); corner_radii_pct_[0] = pct; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_tr_pct(float pct) { promote_uniform_to_per_corner(); corner_radii_pct_[1] = pct; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_bl_pct(float pct) { promote_uniform_to_per_corner(); corner_radii_pct_[2] = pct; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    void set_corner_radius_br_pct(float pct) { promote_uniform_to_per_corner(); corner_radii_pct_[3] = pct; has_corner_radii_ = true; invalidate_subtree_caches_up(); }
    float corner_radius_tl_pct() const { return corner_radii_pct_[0]; }
    float corner_radius_tr_pct() const { return corner_radii_pct_[1]; }
    float corner_radius_bl_pct() const { return corner_radii_pct_[2]; }
    float corner_radius_br_pct() const { return corner_radii_pct_[3]; }
    float effective_corner_radius_tl(float w, float h) const { return corner_radii_pct_[0] > 0 ? corner_radii_pct_[0] * 0.01f * std::min(w,h) : corner_radii_[0]; }
    float effective_corner_radius_tr(float w, float h) const { return corner_radii_pct_[1] > 0 ? corner_radii_pct_[1] * 0.01f * std::min(w,h) : corner_radii_[1]; }
    float effective_corner_radius_bl(float w, float h) const { return corner_radii_pct_[2] > 0 ? corner_radii_pct_[2] * 0.01f * std::min(w,h) : corner_radii_[2]; }
    float effective_corner_radius_br(float w, float h) const { return corner_radii_pct_[3] > 0 ? corner_radii_pct_[3] * 0.01f * std::min(w,h) : corner_radii_[3]; }
    bool has_corner_radii() const { return has_corner_radii_; }
    float corner_radius_tl() const { return corner_radii_[0]; }
    float corner_radius_tr() const { return corner_radii_[1]; }
    float corner_radius_bl() const { return corner_radii_[2]; }
    float corner_radius_br() const { return corner_radii_[3]; }

    struct BoxShadow {
        float offset_x = 0, offset_y = 2;
        float blur = 4;
        float spread = 0;
        Color color{0, 0, 0, 80};
        bool inset = false;
    };

    void set_box_shadow(float ox, float oy, float blur, float spread, Color c,
                        bool inset = false) {
        shadows_.assign(1, BoxShadow{ox, oy, blur, spread, c, inset});
        invalidate_subtree_caches_up();
    }

    void add_box_shadow(float ox, float oy, float blur, float spread, Color c,
                        bool inset = false) {
        shadows_.push_back(BoxShadow{ox, oy, blur, spread, c, inset});
        invalidate_subtree_caches_up();
    }
    void clear_box_shadow() { shadows_.clear(); invalidate_subtree_caches_up(); }
    bool has_box_shadow() const { return !shadows_.empty(); }
    const BoxShadow& box_shadow() const {
        static const BoxShadow kEmpty{};
        return shadows_.empty() ? kEmpty : shadows_.front();
    }

    const std::vector<BoxShadow>& box_shadows() const { return shadows_; }

    void set_box_shadow_color(Color c) {
        first_box_shadow().color = c;
        invalidate_subtree_caches_up();
    }
    void set_box_shadow_offset(float ox, float oy) {
        auto& s = first_box_shadow(); s.offset_x = ox; s.offset_y = oy;
        invalidate_subtree_caches_up();
    }
    void set_box_shadow_opacity(float a) {
        // RN's shadowOpacity is 0..1; overwrite the shadow color's normalized
        // alpha channel while preserving the existing RGB channels.
        first_box_shadow().color.a = a;
        invalidate_subtree_caches_up();
    }
    void set_box_shadow_radius(float r) {
        first_box_shadow().blur = r;
        invalidate_subtree_caches_up();
    }

    std::function<void()> on_click;
    std::function<void(const MouseEvent&)> on_pointer_event;   
    std::function<void(const MouseEvent&, bool)> on_dom_pointer_event;  
    std::function<void(const MouseEvent&, bool)> on_dom_pointer_move_event;
    std::function<void(const MouseEvent&, bool is_dom_origin)> on_dom_wheel_event;
    std::function<void(Point)> on_drag;   
    std::function<void(const MouseEvent&)> on_pointer_move;
    std::function<void(const GestureEvent&)> on_gesture_cb;    
    std::function<void(Point position)> on_context_menu;

    std::function<void(const std::string& type, const std::string& data, float x, float y)> on_drop;

    std::function<void()> on_hover_enter;
    std::function<void()> on_hover_leave;
 
    // ── Overlay painting ────────────────────────────────────────────────
    struct OverlayRequest {
        std::function<void(canvas::Canvas&)> paint_fn;
        View* owner = nullptr;
    };
    static std::vector<OverlayRequest>& overlay_queue();
    static void paint_overlays(canvas::Canvas& canvas, View* painting_root = nullptr);

    static void set_inspector_paint_hook(
        std::function<void(canvas::Canvas&, View* painting_root)> hook);
    static void set_inspector_key_hook(std::function<bool(const KeyEvent&)> hook);
    static bool call_inspector_key_hook(const KeyEvent& e);

    static void set_inspector_mouse_hook(
        std::function<bool(const MouseEvent&, View* event_root)> hook);
    static bool call_inspector_mouse_hook(const MouseEvent& e,
                                          View* event_root = nullptr);

    static void set_inspector_text_hook(
        std::function<bool(const TextInputEvent&, View* event_root)> hook);
    static bool call_inspector_text_hook(const TextInputEvent& e,
                                         View* event_root = nullptr);

    static void set_inspector_cursor_hook(
        std::function<int(const MouseEvent&, View* event_root)> hook);
    static int call_inspector_cursor_hook(const MouseEvent& e,
                                          View* event_root = nullptr);
 
    // ── Generalized overlay-click routing ────────────────────────────────
    //
    // ComboBox already uses a `static ComboBox* active_popup_` pointer so
    // the platform window-host layer can short-circuit hit-testing for
    // paint-only overlays (the dropdown items render OUTSIDE the
    // ComboBox's hit_test bounds). React popovers built from
    // `<View position="absolute">` + nested buttons hit the same problem
    // but have no widget-specific shortcut, so clicks fall through to
    // whatever sibling/ancestor pixel is under the overlay.
    //
    // `active_overlay_` is the per-View opt-in equivalent: any View can
    // claim itself as the global click-eligible overlay. The window host
    // checks this AFTER `ComboBox::active_popup_` (so the ComboBox path
    // stays exact-as-was) and BEFORE the regular tree hit_test. If the
    // click falls inside the overlay's window-rect, it routes to the
    // overlay; otherwise the overlay is auto-released and the click
    // continues to the tree.
    //
    // The @pulp/react host config calls `claim_overlay()` from a JSX
    // `<View overlay>` mount and `release_overlay()` from its unmount.
    //
    // ── Per-root interaction state (pulp #6223 S11) ───────────────────────
    //
    // focused_input, active_overlay, the overlay paint queue, and (migrated in
    // ui_components.hpp) the ComboBox popup slot were process-wide statics. Two
    // Pulp editors in one host process — the documented shared-AUHostingService
    // case — then shared ONE focus and ONE open popup: focusing a field in
    // editor B stole editor A's keyboard, and opening a dropdown in one closed
    // the other's. The in-tree drag source already solved this by hanging its
    // in-flight record off the ROOT View (see `active_drag_`); this mirrors that
    // precedent so each editor's tree owns its own interaction slots.
    //
    // Reached via `interaction()`: walk to `tree_root()` and lazily allocate the
    // struct on the root. Two DISTINCT parented roots never share. A DETACHED
    // widget (no parent AND no children — e.g. a bare headless widget) has no
    // root of its own, so it resolves to one process-global FALLBACK slot; that
    // fallback is the documented shim preserving the historical single-focus /
    // single-popup behavior for unhosted widgets. See view.cpp `interaction()`.
    struct RootInteractionState {
        View* focused_input = nullptr;
        View* active_overlay = nullptr;
        ComboBox* active_popup = nullptr;   // wired from ui_components (migrated last)
        std::vector<OverlayRequest> overlay_queue;
        std::vector<View*> overlay_stack;
        std::uint64_t pending_overlay_opener = 0;
    };

    RootInteractionState& interaction();
    const RootInteractionState& interaction() const;
    RootInteractionState* existing_interaction();
 
    // The historical statics are retained as process-global SHIM MIRRORS,
    // written through on every claim/release so the platform hosts that read
    // them directly (and already scope the read to their own root — see
    // plugin_view_host_mac.mm `pulp_focus_under_root`) keep working unchanged.
    // `active_overlay_` / `focused_input_` reflect the most-recently-acted slot
    // process-wide; `interaction()` is the per-root source of truth.
    static View* active_overlay_;
    static View* focused_input_;
    void claim_input_focus();
    void claim_overlay(const View* stacks_on = nullptr);
    std::size_t overlay_depth() const;
    void set_overlay_consumes_outside_click(bool consume) {
        overlay_consumes_outside_click_ = consume;
    }
    bool overlay_consumes_outside_click() const {
        return overlay_consumes_outside_click_;
    }

    bool overlay_nests_on(const View* below) const { return below && overlay_nested_on_ == below; }
    void set_overlay_trigger(bool is_trigger) { overlay_trigger_ = is_trigger; }
    bool overlay_trigger() const { return overlay_trigger_; }
    void set_overlay_anchor(const View* anchor);
    std::uint64_t overlay_anchor_id() const { return overlay_anchor_id_; }
    bool overlay_anchored_at(const View* candidate) const;
    void release_input_focus();
    void release_overlay();
    void dismiss_claimed_overlay();
    static void dismiss_active_overlay();
    static void dismiss_active_overlay(View& scope);
    std::function<void()> on_overlay_dismissed;
    bool overlay_contains(Point window_pt) const;

    std::function<void(const std::string& id, uint16_t modifiers)> on_global_click;

    std::function<bool(const KeyEvent&)> on_global_key;
    std::function<bool(const KeyEvent&)> on_navigation_key;

    enum class Position { static_, relative, absolute, fixed, sticky };
    // Position and the four edge offsets feed the Yoga pass, so a change here
    // changes what a geometry query returns and must move the layout
    // generation — geometry readers (the script bridge, the host paint path)
    // lay out only when that generation moved, and would otherwise answer from
    // the pre-move box. Guarded on equality because the design-import replay
    // re-applies captured position metadata on every commit; dirtying the tree
    // for a write that changed nothing would force a whole-tree pass per
    // re-applied binding.
    void set_position(Position p) {
        if (position_ == p) return;
        position_ = p;
        invalidate_layout();
    }
    Position position() const { return position_; }
 
    // top/right/bottom/left accept either a px value (the single-arg setter) or
    // a percent value (the two-arg setter that records the unit). The Yoga
    // adapter dispatches on `top_unit_` / etc. and routes percent values through
    // YGNodeStyleSetPositionPercent, mirroring the FlexStyle::dim_width pattern
    // for the View positional fields.
    void set_top(float v) { set_top(v, DimensionUnit::px); }
    void set_right(float v) { set_right(v, DimensionUnit::px); }
    void set_bottom(float v) { set_bottom(v, DimensionUnit::px); }
    void set_left(float v) { set_left(v, DimensionUnit::px); }
    void set_top(float v, DimensionUnit unit) {
        if (has_top_ && top_ == v && top_unit_ == unit) return;
        top_ = v; has_top_ = true; top_unit_ = unit;
        invalidate_layout();
    }
    void set_right(float v, DimensionUnit unit) {
        if (has_right_ && right_ == v && right_unit_ == unit) return;
        right_ = v; has_right_ = true; right_unit_ = unit;
        invalidate_layout();
    }
    void set_bottom(float v, DimensionUnit unit) {
        if (has_bottom_ && bottom_ == v && bottom_unit_ == unit) return;
        bottom_ = v; has_bottom_ = true; bottom_unit_ = unit;
        invalidate_layout();
    }
    void set_left(float v, DimensionUnit unit) {
        if (has_left_ && left_ == v && left_unit_ == unit) return;
        left_ = v; has_left_ = true; left_unit_ = unit;
        invalidate_layout();
    }
    float top() const { return top_; }
    float right() const { return right_; }
    float bottom() const { return bottom_; }
    float left() const { return left_; }
    DimensionUnit top_unit() const { return top_unit_; }
    DimensionUnit right_unit() const { return right_unit_; }
    DimensionUnit bottom_unit() const { return bottom_unit_; }
    DimensionUnit left_unit() const { return left_unit_; }
    bool has_top() const { return has_top_; }
    bool has_right() const { return has_right_; }
    bool has_bottom() const { return has_bottom_; }
    bool has_left() const { return has_left_; }
    void set_z_index(int z) {
        z_index_ = z;
        invalidate_subtree_caches_up();
    }
    int z_index() const { return z_index_; }

    std::vector<View*> sorted_children_by_z_index() const;
    bool children_in_z_order() const;

    enum class Overflow { hidden, visible, scroll };
    void set_overflow(Overflow o) {
        overflow_ = o;
        // A box that no longer scrolls has no scroll position (CSS collapses
        // scrollTop to 0 too); a stale offset would keep translating children
        // after the clip that justified it was removed.
        if (o != Overflow::scroll) {
            scroll_offset_x_ = 0.0f;
            scroll_offset_y_ = 0.0f;
        }
    }
    Overflow overflow() const { return overflow_; }
 
    // ── Scrollable overflow (`overflow: scroll`, CSS `auto`) ─────────────
    //
    // A plain View with `Overflow::scroll` is a scroll container: it clips to
    // its box, offsets its children by `-scroll_offset`, and consumes the
    // wheel. `ScrollView` is the richer widget over the same notion (animated
    // offset, scrollbar chrome, drag) and overrides these so one query serves
    // either. ONE function backs paint and hit-testing —
    // `child_paint_offset()` — so they cannot disagree about where a child is
    // (see its doc below).

    virtual bool is_scroll_container() const {
        return overflow_ == Overflow::scroll;
    }

    virtual float scroll_offset_x() const {
        return scroll_offset_x_;
    }
    virtual float scroll_offset_y() const {
        return scroll_offset_y_;
    }

    Size scroll_content_size() const;

    float max_scroll_offset_x() const;
    float max_scroll_offset_y() const;

    virtual bool set_scroll_offset(float x, float y);
    bool scroll_offset_by(float dx, float dy) {
        return set_scroll_offset(scroll_offset_x() + dx, scroll_offset_y() + dy);
    }

    void set_clip_marker_tolerance(bool on) { clip_marker_tolerance_ = on; }
    bool clip_marker_tolerance() const { return clip_marker_tolerance_; }

    void set_scale(float s) {
        if (scale_ == s) return;
        scale_ = s; invalidate_subtree_caches_up();
    }
    float scale() const { return scale_; }
 
    void set_translate(float x, float y) {
        if (translate_x_ == x && translate_y_ == y) return;
        translate_x_ = x; translate_y_ = y; invalidate_subtree_caches_up();
    }
    float translate_x() const { return translate_x_; }
    float translate_y() const { return translate_y_; }
 
    void set_rotation(float deg) {
        if (rotation_deg_ == deg) return;
        rotation_deg_ = deg; invalidate_subtree_caches_up();
    }
    float rotation() const { return rotation_deg_; }
 
    void set_skew(float x_deg, float y_deg) {
        if (skew_x_ == x_deg && skew_y_ == y_deg) return;
        skew_x_ = x_deg; skew_y_ = y_deg; invalidate_subtree_caches_up();
    }

    void set_transform_origin(float x, float y) {
        if (origin_explicit_ && origin_x_ == x && origin_y_ == y) return;
        origin_x_ = x; origin_y_ = y; origin_explicit_ = true;
        invalidate_subtree_caches_up();
    }
    float transform_origin_x() const { return origin_x_; }
    float transform_origin_y() const { return origin_y_; }
    bool transform_origin_explicit() const { return origin_explicit_; }

    void set_transform_matrix(float a, float b, float c,
                              float d, float e, float f) {
        if (has_transform_matrix_ && transform_matrix_a_ == a
            && transform_matrix_b_ == b && transform_matrix_c_ == c
            && transform_matrix_d_ == d && transform_matrix_e_ == e
            && transform_matrix_f_ == f)
            return;
        transform_matrix_a_ = a;
        transform_matrix_b_ = b;
        transform_matrix_c_ = c;
        transform_matrix_d_ = d;
        transform_matrix_e_ = e;
        transform_matrix_f_ = f;
        has_transform_matrix_ = true;
        invalidate_subtree_caches_up();
    }
    void clear_transform_matrix() {
        if (!has_transform_matrix_) return;
        has_transform_matrix_ = false;
        invalidate_subtree_caches_up();
    }
    bool has_transform_matrix() const { return has_transform_matrix_; }

    bool has_render_transform() const {
        return has_transform_matrix_ || scale_ != 1.0f || rotation_deg_ != 0.0f ||
               translate_x_ != 0.0f || translate_y_ != 0.0f ||
               skew_x_ != 0.0f || skew_y_ != 0.0f;
    }

    bool has_filter_effect() const {
        return has_filter_chain() || filter_blur_ > 0.0f;
    }

    virtual bool applies_child_paint_offset() const {
        return scroll_offset_x_ != 0.0f || scroll_offset_y_ != 0.0f;
    }

    virtual Point child_paint_offset(const View& child) const {
        if (scroll_offset_x_ == 0.0f && scroll_offset_y_ == 0.0f)
            return Point{0.0f, 0.0f};
        // A `position: sticky` child stays pinned vertically while the content
        // scrolls beneath it — same rule ScrollView applies.
        if (child.position() == Position::sticky)
            return Point{-scroll_offset_x_, 0.0f};
        return Point{-scroll_offset_x_, -scroll_offset_y_};
    }

    void get_transform_matrix(float& a, float& b, float& c,
                              float& d, float& e, float& f) const {
        a = transform_matrix_a_; b = transform_matrix_b_; c = transform_matrix_c_;
        d = transform_matrix_d_; e = transform_matrix_e_; f = transform_matrix_f_;
    }

    void set_filter_blur(float radius) { filter_blur_ = radius; }
    float filter_blur() const { return filter_blur_; }

    struct FilterOp {
        enum class Kind {
            blur,
            brightness,
            contrast,
            grayscale,
            hue_rotate,
            invert,
            opacity,
            saturate,
            sepia,
            drop_shadow,
        };
        Kind kind = Kind::blur;
        float amount = 0.0f;       
        float angle_deg = 0.0f;    
        // drop-shadow extras
        float ds_offset_x = 0.0f;
        float ds_offset_y = 0.0f;
        float ds_blur = 0.0f;
        Color ds_color{};
    };
    void set_filter_chain(std::vector<FilterOp> chain) { filter_chain_ = std::move(chain); }
    void clear_filter_chain() { filter_chain_.clear(); }
    const std::vector<FilterOp>& filter_chain() const { return filter_chain_; }
    bool has_filter_chain() const { return !filter_chain_.empty(); }

    void set_transitions(std::vector<TransitionSpec> ts) { transitions_ = std::move(ts); }
    void clear_transitions() { transitions_.clear(); }
    const std::vector<TransitionSpec>& transitions() const { return transitions_; }
    bool has_transitions() const { return !transitions_.empty(); }

    const TransitionSpec* find_transition_for(const std::string& property) const {
        const TransitionSpec* match = nullptr;
        for (const auto& t : transitions_) {
            if (t.property_name == "all") match = &t;
            if (t.property_name == property) { match = &t; }
        }
        return match;
    }

    std::vector<CssAnimation>& active_animations() { return active_animations_; }
    const std::vector<CssAnimation>& active_animations() const { return active_animations_; }

    int tick_animations(float dt) {
        if (animation_play_state_ == "paused") return 0;
        int finished = 0;
        for (auto& a : active_animations_) {
            if (!a.active) continue;
            const bool was_active = a.active;
            a.tick(dt);
            if (was_active && !a.active) ++finished;
        }
        return finished;
    }

    struct StagedAnimation {
        std::string name;
        float duration_seconds = 0.0f;
        float delay_seconds = 0.0f;
        CssEasing easing{};
        float iterations = 1.0f;
        std::string direction = "normal";
        std::string fill_mode;
    };
    StagedAnimation& staged_animation() { return style_extras().staged_animation; }
    const StagedAnimation& staged_animation() const {
        static const StagedAnimation kEmpty;
        return style_extras_ ? style_extras_->staged_animation : kEmpty;
    }

    void set_backdrop_blur(float radius) { style_extras().backdrop_blur = radius; }
    float backdrop_blur() const { return style_extras_ ? style_extras_->backdrop_blur : 0.0f; }

    void set_backdrop_filter_chain(std::vector<FilterOp> chain) {
        style_extras().backdrop_filter_chain = std::move(chain);
    }
    const std::vector<FilterOp>& backdrop_filter_chain() const {
        static const std::vector<FilterOp> kEmpty;
        return style_extras_ ? style_extras_->backdrop_filter_chain : kEmpty;
    }

    void set_ancestor_clip_rect(Rect r) { style_extras().ancestor_clip = r; }
    const std::optional<Rect>& ancestor_clip_rect() const {
        static const std::optional<Rect> kNone;
        return style_extras_ ? style_extras_->ancestor_clip : kNone;
    }

    void set_ancestor_clip_radii(float tl, float tr, float br, float bl) {
        style_extras().ancestor_clip_radii = {tl, tr, br, bl};
    }
    const std::array<float, 4>& ancestor_clip_radii() const {
        static const std::array<float, 4> kNone{0.0f, 0.0f, 0.0f, 0.0f};
        return style_extras_ ? style_extras_->ancestor_clip_radii : kNone;
    }
 
    void set_clip_path(const std::string& svg_path_d) { style_extras().clip_path = svg_path_d; }
    const std::string& clip_path() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->clip_path : kEmpty;
    }
    bool has_clip_path() const { return style_extras_ && !style_extras_->clip_path.empty(); }

    void set_mask_image(const std::string& value) { style_extras().mask_image = value; }
    const std::string& mask_image() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->mask_image : kEmpty;
    }

    void set_mask(const std::string& value) { style_extras().mask = value; }
    const std::string& mask() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->mask : kEmpty;
    }

    void set_mask_size(const std::string& value) { style_extras().mask_size = value; }
    const std::string& mask_size() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->mask_size : kEmpty;
    }

    void set_appearance(const std::string& value) { style_extras().appearance = value; }
    const std::string& appearance() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->appearance : kEmpty;
    }

    void set_object_fit(const std::string& value) { style_extras().object_fit = value; }
    const std::string& object_fit() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->object_fit : kEmpty;
    }

    void set_object_position(const std::string& value) { style_extras().object_position = value; }
    const std::string& object_position() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->object_position : kEmpty;
    }

    void set_background_attachment(std::string kw) { style_extras().background_attachment = std::move(kw); }
    const std::string& background_attachment() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->background_attachment : kEmpty;
    }
    void set_background_clip(std::string kw)       { style_extras().background_clip = std::move(kw); }
    const std::string& background_clip() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->background_clip : kEmpty;
    }
    void set_background_origin(std::string kw)     { style_extras().background_origin = std::move(kw); }
    const std::string& background_origin() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->background_origin : kEmpty;
    }

    void set_background_position(std::string kw)   { style_extras().background_position = std::move(kw); }
    const std::string& background_position() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->background_position : kEmpty;
    }
    void set_background_size(std::string kw)       { style_extras().background_size = std::move(kw); }
    const std::string& background_size() const {
        static const std::string kEmpty;
        return style_extras_ ? style_extras_->background_size : kEmpty;
    }
 
    // Storage-only slots for CSS properties that the bridge accepts but View
    // does not fully consume. Each slot is round-trippable so harness tests can
    // verify the bridge accepts the value, and so a paint path can honor it
    // later without a JS-side change. Catalog status documents the
    // implementation depth (`partial` / `noop` / `wontfix`).
    void set_text_indent(float v)                  { text_indent_ = v; }
    float text_indent() const                      { return text_indent_; }
    void set_word_break(std::string kw)            { word_break_ = std::move(kw); }
    const std::string& word_break() const          { return word_break_; }

    void set_scroll_behavior(std::string kw)       { scroll_behavior_ = std::move(kw); }
    const std::string& scroll_behavior() const     { return scroll_behavior_; }
    void set_overscroll_behavior(std::string kw)   { overscroll_behavior_ = std::move(kw); }
    const std::string& overscroll_behavior() const { return overscroll_behavior_; }

    void set_include_font_padding(bool v) { include_font_padding_ = v; }
    bool include_font_padding() const     { return include_font_padding_; }
 
    void set_font_variant(std::string kw)          { font_variant_ = std::move(kw); }
    const std::string& font_variant() const        { return font_variant_; }
    void set_writing_mode(std::string kw)          { writing_mode_ = std::move(kw); }
    const std::string& writing_mode() const        { return writing_mode_; }
    void set_isolation(std::string kw)             { isolation_ = std::move(kw); }
    const std::string& isolation() const           { return isolation_; }
    void set_resize(std::string kw)                { resize_ = std::move(kw); }
    const std::string& resize() const              { return resize_; }
    void set_animation_play_state(std::string kw)  { animation_play_state_ = std::move(kw); }
    const std::string& animation_play_state() const { return animation_play_state_; }

    void set_continuous_repaint(bool on) { wants_continuous_repaint_ = on; }
    bool wants_continuous_repaint() const { return wants_continuous_repaint_; }
 
    RuntimeViewKind runtime_view_kind() const noexcept { return runtime_view_kind_; }
 
protected:
    void mark_runtime_view_kind(RuntimeViewKind kind) { runtime_view_kind_ = kind; }
 
public:
    void set_text_shadow_color(std::string c)      { text_shadow_color_ = std::move(c); }
    const std::string& text_shadow_color() const   { return text_shadow_color_; }
    void set_text_shadow_offset(float dx, float dy){ text_shadow_dx_ = dx; text_shadow_dy_ = dy; }
    float text_shadow_offset_x() const             { return text_shadow_dx_; }
    float text_shadow_offset_y() const             { return text_shadow_dy_; }
    void set_text_shadow_radius(float r)           { text_shadow_radius_ = r; }
    float text_shadow_radius() const               { return text_shadow_radius_; }
 

    void set_needs_layer(bool v) { needs_layer_ = v; }
    bool needs_layer() const { return needs_layer_; }

    void set_subtree_cached(bool v);
    bool subtree_cached() const { return subtree_cached_; }

    void set_raster_cached(bool enabled);

    void set_effect(std::shared_ptr<canvas::ViewEffect> effect) { effect_ = std::move(effect); }
    const std::shared_ptr<canvas::ViewEffect>& effect() const { return effect_; }

    virtual void set_window_host(WindowHost* host);
    WindowHost* window_host() const { return window_host_; }

    virtual void set_plugin_view_host(PluginViewHost* host);
    PluginViewHost* plugin_view_host() const { return plugin_view_host_; }

    virtual bool accepts_navigation_input() const {
        return scripted_navigation_input_;
    }

    void set_host_params(HostParamSurface* surface);
    HostParamSurface* host_params() const { return host_params_; }

    void set_host_actions(HostActionSurface* surface);
    HostActionSurface* host_actions() const { return host_actions_; }

    struct BackgroundGradient {
        int type = 0;  // 0=none, 1=linear, 2=radial, 3=conic
        // Index in the AUTHOR'S background-image list.  `none` entries do
        // not paint and are intentionally absent from bg_gradients_, but they
        // still consume a background-size/repeat/position list slot.
        std::size_t css_image_layer_index = 0;
        float x0 = 0, y0 = 0, x1 = 0, y1 = 1;
        float radius = 0.7071f;     // radial: fraction of max(w,h)
        float angle = 0.0f;         // conic: start angle in radians
        float sweep_turns = 1.0f;   // conic: turns the stop list spans
        std::vector<Color> colors;
        std::vector<float> positions;
 
        // ── Geometry only a laid-out box can resolve ────────────────────
        //
        // CSS gradient geometry is a function of the box: an angle's endpoints
        // depend on the aspect ratio, and a radial's radii are percentages of
        // the width and height. Style is applied BEFORE the box is sized —
        // the design importer runs the whole style pass ahead of Yoga — so
        // anything resolved when the CSS is parsed is resolved against a
        // degenerate 1x1 box, which silently turns every angled gradient the
        // wrong way and gives every radial the wrong radius. These slots carry
        // the CSS intent forward instead, and the painter resolves them
        // against the real bounds.

        enum class LinearFrom { endpoints, angle, corner };
        LinearFrom linear_from = LinearFrom::endpoints;
        float linear_angle = 0.0f;
        float corner_x = 1.0f, corner_y = 1.0f;

        float linear_repeat = 0.0f;
        enum class RepeatUnit { px, line_fraction };
        RepeatUnit linear_repeat_unit = RepeatUnit::px;

        bool positions_in_px = false;

        enum class RadialSize {
            max_side, farthest_corner, farthest_side, closest_corner,
            closest_side, explicit_radii,
        };
        RadialSize radial_size = RadialSize::max_side;
        bool radial_circle = false;
        float radial_rx = 0.0f, radial_ry = 0.0f;
        float radial_rx_px = 0.0f, radial_ry_px = 0.0f;
        canvas::GradientInterpolation interpolation; 
    };

    struct ResolvedRadial { float cx, cy, rx, ry; };

    static ResolvedRadial resolve_radial(const BackgroundGradient& g,
                                         float w, float h);

    void set_background_gradient_layers(std::vector<BackgroundGradient> layers) {
        bg_gradients_ = std::move(layers);
        invalidate_subtree_caches_up();
    }
    const std::vector<BackgroundGradient>& background_gradient_layers() const {
        return bg_gradients_;
    }

    void set_background_gradient_linear(float x0, float y0, float x1, float y1,
                                         const std::vector<Color>& colors,
                                         const std::vector<float>& positions) {
        BackgroundGradient g;
        g.type = 1;  // linear
        g.x0 = x0; g.y0 = y0; g.x1 = x1; g.y1 = y1;
        g.colors = colors;
        g.positions = positions;
        set_background_gradient_layers({std::move(g)});
    }

    void set_background_gradient_radial(float cx, float cy, float radius_frac,
                                         const std::vector<Color>& colors,
                                         const std::vector<float>& positions) {
        BackgroundGradient g;
        g.type = 2;  // radial
        g.x0 = cx; g.y0 = cy;
        g.radius = radius_frac;
        g.colors = colors;
        g.positions = positions;
        set_background_gradient_layers({std::move(g)});
    }

    void set_background_gradient_conic(float cx, float cy, float start_angle,
                                        const std::vector<Color>& colors,
                                        const std::vector<float>& positions,
                                        float sweep_turns = 1.0f) {
        BackgroundGradient g;
        g.type = 3;  // conic / sweep
        g.x0 = cx; g.y0 = cy;
        g.angle = start_angle;
        g.sweep_turns = sweep_turns;
        g.colors = colors;
        g.positions = positions;
        set_background_gradient_layers({std::move(g)});
    }
    // The queries below report the TOP layer — the one CSS lists first. They
    // predate layering and every caller means "the gradient this view shows".
    float background_gradient_sweep_turns() const {
        return bg_gradients_.empty() ? 1.0f : bg_gradients_.front().sweep_turns;
    }
    void clear_background_gradient() {
        bg_gradients_.clear();
        invalidate_subtree_caches_up();
    }
    bool has_background_gradient() const { return !bg_gradients_.empty(); }
    int background_gradient_type() const {
        return bg_gradients_.empty() ? 0 : bg_gradients_.front().type;
    }

    float background_gradient_radius() const {
        return bg_gradients_.empty() ? 0.7071f : bg_gradients_.front().radius;
    }

    void set_text_overflow_ellipsis(bool e) { text_ellipsis_ = e; }
    bool text_overflow_ellipsis() const { return text_ellipsis_; }

    enum class WritingDirection { ltr, rtl, auto_ };
    void set_direction(WritingDirection d) { direction_ = d; }
    WritingDirection direction() const { return direction_; }
    WritingDirection resolved_direction() const {
        return direction_ == WritingDirection::auto_ ? WritingDirection::ltr : direction_;
    }

    // Full CSS `white-space` enum. Replaces the nowrap-only bool with the
    // spec's 6 keywords. Per CSS Text
    // Module Level 3 §3:
    //   normal       collapse  drop_nl   wrap
    //   nowrap       collapse  drop_nl   nowrap
    //   pre          preserve  preserve  nowrap
    //   pre_wrap     preserve  preserve  wrap
    //   pre_line     collapse  preserve  wrap
    //   break_spaces preserve  preserve  wrap (extra break opps)
    enum class WhiteSpaceMode {
        normal, nowrap, pre, pre_wrap, pre_line, break_spaces
    };
    // set_white_space_nowrap() also keeps the WhiteSpaceMode enum in sync so
    // callers using the legacy setter don't leave white_space_mode() stale.
    // The enum is pinned to nowrap (true) or normal (false); we can't infer
    // pre/pre-wrap/etc. from a bool, so the legacy setter only ever produces
    // these two modes.
    void set_white_space_nowrap(bool n) {
        white_space_nowrap_ = n;
        white_space_mode_ = n ? WhiteSpaceMode::nowrap : WhiteSpaceMode::normal;
    }
    bool white_space_nowrap() const { return white_space_nowrap_; }
 
    void set_white_space_mode(WhiteSpaceMode m) {
        white_space_mode_ = m;
        // `pre` also pins nowrap: it preserves newlines and spaces while
        // disabling soft wrapping.
        white_space_nowrap_ = (m == WhiteSpaceMode::nowrap || m == WhiteSpaceMode::pre);
    }
    WhiteSpaceMode white_space_mode() const { return white_space_mode_; }

    void set_mix_blend_mode(canvas::Canvas::BlendMode m) { mix_blend_mode_ = m; }
    canvas::Canvas::BlendMode mix_blend_mode() const { return mix_blend_mode_; }
    bool has_non_default_blend_mode() const {
        return mix_blend_mode_ != canvas::Canvas::BlendMode::normal;
    }

    enum class CursorStyle {
        default_, pointer, crosshair, text, grab, grabbing, not_allowed,
        invisible,                
        horizontal_resize,        
        vertical_resize,          
        top_left_resize,          
        top_right_resize,         
        bottom_left_resize,       
        bottom_right_resize,      
        multi_directional_resize, 
        // CSS cursor keywords with native macOS NSCursor mappings. Other CSS
        // keywords without dedicated visuals (wait / help / progress / cell)
        // stay catalog-unsupported because no native cursor exists on macOS.
        alias,                    
        copy,                     
        zoom_in,                  
        zoom_out,                 
        context_menu              
    };
    void set_cursor(CursorStyle c) { cursor_ = c; }
    CursorStyle cursor() const { return cursor_; }

    enum class UserSelect { auto_, none, text, all, contain };
    void set_user_select(UserSelect s) { user_select_ = s; }
    UserSelect user_select() const { return user_select_; }
 
private:
    static std::uint32_t overlay_claims_live_;
    static bool detach_overlay(RootInteractionState& state, View* victim);
    static void republish_overlay(RootInteractionState& state);
    bool is_overlay_descendant_of(const View* ancestor) const;
    bool paint_children_overlay_last(canvas::Canvas& canvas);
    friend class WidgetBridge;
    friend class ViewCapture;
    friend class ScrollView;
    friend class DispatchLease;
    friend Point point_to_local(Point root_pos, View* target, View* root);
 
    void note_layout_mutation() noexcept;

    void drain_retired() noexcept;
    void deliver_frame_clock_hooks() noexcept;
    void walk_frame_clock(std::uint64_t epoch, std::uint64_t sequence) noexcept;

    bool inverse_scale_transform(Point& point) const noexcept;
 
    void begin_visibility_quarantine() noexcept {
        if (visibility_quarantine_count_++ == 0)
            visible_after_quarantine_ = visible_;
        set_visible_from_quarantine(false);
    }
    void refresh_visibility_quarantine() noexcept {
        set_visible_from_quarantine(false);
    }
    void end_visibility_quarantine() {
        if (visibility_quarantine_count_ == 0)
            return;
        --visibility_quarantine_count_;
        if (visibility_quarantine_count_ == 0)
            set_visible(visible_after_quarantine_);
    }
    void set_visible_from_quarantine(bool visible) noexcept {
        visible_ = visible;
        invalidate_subtree_caches_up();
    }
    static void set_subtree_detaching(View& view, bool detaching) noexcept;
    void publish_structure_change() noexcept;
    std::vector<GestureRecognizer*> collect_realm_reset_gestures() const;
    void prepare_children_for_realm_reset(
        const std::vector<GestureRecognizer*>& removed_recognizers) noexcept;
    void disconnect_frame_clock_for_realm_reset() noexcept;
    void finish_realm_reset_detach() noexcept;
    void retire_interaction_state_for_realm_reset(
        std::unique_ptr<ActiveDrag>& retired_drag,
        std::unique_ptr<RootInteractionState>& retired_interaction) noexcept;
    std::unique_ptr<View> extract_child_for_realm_reset(View* child) noexcept;
    void adopt_child_for_realm_reset(std::unique_ptr<View> child) noexcept;
    void retire_children_for_realm_reset(
        std::vector<std::unique_ptr<View>>& retired) noexcept;

    void notify_frame_clock_changed() noexcept;

    void sync_value_bindings();

    void register_value_binding(FrameClockBinding* b);
    void unregister_value_binding(FrameClockBinding* b);
    friend class FrameClockBinding;

    void promote_uniform_to_per_corner() {
        if (!has_corner_radii_ && corner_radius_ > 0.0f) {
            corner_radii_[0] = corner_radius_;
            corner_radii_[1] = corner_radius_;
            corner_radii_[2] = corner_radius_;
            corner_radii_[3] = corner_radius_;
        }
    }
 
    // ── paint_all decomposition (behavior-preserving) ─────────────────────
    // paint_all() is an orchestrator over these private helpers. The one
    // load-bearing invariant is the compositing-layer imbalance: every helper
    // enters and leaves the canvas at the SAME save depth it does today,
    // EXCEPT push_effect_layers / pop_effect_layers, which own the imbalance by
    // contract — push returns the exact count/flag it opened and pop consumes
    // it, so the push/pop pair is auditable in isolation. Splitting the monolith
    // this way also gives FU-3's subtree cache a clean "content" seam
    // (paint_content) that excludes the effect/opacity layer wrappers.
    struct EffectLayerState {
        int  layers_pushed   = 0;      
        bool backdrop_pushed = false;  
    };
    void apply_canvas_transforms(canvas::Canvas& canvas);
    EffectLayerState push_effect_layers(canvas::Canvas& canvas);
    void pop_effect_layers(canvas::Canvas& canvas, const EffectLayerState& layers);
    // The FU-3 cache-capture unit: everything painted INSIDE the effect layers
    // (shadows, clip, background/border, paint(), children, decorations).
    // children_ns receives the recursive child-paint time for self-time attrib.
    void paint_content(canvas::Canvas& canvas, const EffectLayerState& layers,
                       std::int64_t& children_ns);
    // FU-3 wrapper around paint_content: replays the cached scene when caching
    // is on, the backend supports it, and the cache is valid; otherwise records
    // (on a miss) or paints directly. Called from the paint_all orchestrator in
    // place of paint_content so the effect/opacity layers stay outside the cache.
    void paint_content_maybe_cached(canvas::Canvas& canvas,
                                    const EffectLayerState& layers,
                                    std::int64_t& children_ns);
    // Clear the scene cache on this view and every ancestor that has caching
    // enabled (a mutation anywhere in a cached subtree stales that subtree's
    // recording). Walks parent_ links; O(depth), and skipped entirely via a
    // process-global counter when no view anywhere has caching enabled.
    void invalidate_subtree_caches_up();
    void paint_outset_shadows(canvas::Canvas& canvas);
    void apply_overflow_clip(canvas::Canvas& canvas);
    void apply_clip_path(canvas::Canvas& canvas);
    void paint_background_and_border(canvas::Canvas& canvas);
    using CornerPathBuilder =
        std::function<void(float w, float h, float tl, float tr,
                           float bl, float br)>;
    void paint_border(canvas::Canvas& canvas, float paint_w, float paint_h,
                      bool use_per_corner,
                      const CornerPathBuilder& build_corner_path,
                      float eff_r, float eff_tl, float eff_tr,
                      float eff_bl, float eff_br);
    void paint_children_in_order(canvas::Canvas& canvas);
    void paint_post_decorations(canvas::Canvas& canvas, const EffectLayerState& layers);
 
    Rect bounds_{};
    FlexStyle flex_{};
    GridStyle grid_{};
    LayoutMode layout_mode_ = LayoutMode::flex;
    bool subpixel_layout_ = false;
    bool captured_frame_root_ = false;
    Theme theme_;
    std::shared_ptr<WidgetPainter> painter_;
    std::shared_ptr<WidgetMetrics> metrics_;
    std::unique_ptr<ActiveDrag> active_drag_;
    std::unique_ptr<RootInteractionState> interaction_state_;
    // Only the root's value is observed and bumped. Atomic prevents a native
    // provider's incidental read from racing the owner-thread detach publish.
    std::atomic<std::uint64_t> structure_generation_{1};
    // Set across an entire subtree before the first virtual detach callback.
    // ViewCapture treats this as already absent even while on_detached() still
    // needs the old parent link to release parent-owned resources.
    std::atomic<bool> detaching_{false};
    // ── Mutation/lifetime gate (view_lifecycle.hpp) ──────────────────────
    // Number of DispatchLeases open anywhere on this tree. Only the ROOT's
    // copy is raised; retirement drains when it falls back to zero.
    std::uint32_t lease_depth_ = 0;
    // Leases naming THIS view specifically. Non-zero means a callback on it is
    // executing, so destroying it now would free a live frame.
    std::uint16_t dispatch_depth_ = 0;
    // Set for the duration of ~View so a child destroyed as part of its
    // parent's teardown does not trip the "destroyed while attached" assert.
    bool destroying_ = false;
    // True while a frame-clock walk is in flight on this ROOT. Children added
    // during a walk are stamped as already-visited so they wait for the next
    // pass instead of being visited mid-mutation.
    bool clock_walk_active_ = false;
    // Root-only. Set when a hook requests propagation during an active walk;
    // the outermost caller runs one more bounded pass to service it.
    bool clock_walk_pending_ = false;
    // Root-only, and meaningful only while a walk is in flight: the traversal
    // token of the pass currently running, published so a mid-pass attach can
    // stamp the incoming subtree as belonging to it.
    std::uint64_t clock_epoch_ = 0;
    // Per view. The traversal stamp makes a pass visit each node at most once
    // even while hooks mutate children_; the delivery stamp makes the whole
    // call notify each node at most once across all of its passes. They are
    // separate because a later pass must be free to walk THROUGH an
    // already-notified node to reach a descendant attached mid-pass.
    //
    // Both hold PROCESS-GLOBAL monotonic tokens, never per-root counters. A
    // view outlives its root — remove_child hands a detached subtree its own
    // root and notifies it immediately — so a stamp must mean the same thing in
    // every tree. See next_clock_walk_token() in view.cpp.
    std::uint64_t clock_walk_epoch_ = 0;
    std::uint64_t clock_delivery_sequence_ = 0;
    // Intrusive owning retirement chain. Root-only head; each retired view
    // carries the link to the next, so parking one allocates nothing.
    std::unique_ptr<View> retired_head_;
    std::unique_ptr<View> retired_next_;
    View* parent_ = nullptr;
    std::vector<std::unique_ptr<View>> children_;
    std::string id_;
    // Design-import anchor identity. Empty for views not constructed from an
    // imported tree. See set_anchor_id().
    std::string anchor_id_;
    std::uint64_t import_binding_instance_id_ = 0;
    std::shared_ptr<const std::uint64_t> import_binding_lifetime_token_;
    // Authored-source location (JSX file:line:col) from the React reconciler's
    // `__source` prop. Unset for non-imported views.
    std::optional<SourceLocation> source_loc_;
    // Last-paint-cycle timing. Both 0 until paint_all() has executed at least
    // once.
    std::uint32_t last_paint_self_ns_ = 0;
    std::uint32_t last_paint_with_children_ns_ = 0;
    AccessRole access_role_ = AccessRole::none;
    AccessRole implicit_access_role_ = AccessRole::none;
    RuntimeViewKind runtime_view_kind_ = RuntimeViewKind::generic;
    std::string access_label_;          // author-set (aria-label) — wins
    std::string derived_access_label_;  // content-derived (visible text)
    std::string access_value_;
    // ARIA state attributes (tri-state per spec).
    std::string access_pressed_;
    std::string access_checked_;
    std::string access_disabled_;
    std::string access_hidden_;
    bool visible_ = true;
    std::size_t visibility_quarantine_count_ = 0;
    bool visible_after_quarantine_ = true;
    bool focusable_ = false;
    bool enabled_ = true;
    bool layout_dirty_ = false;
    std::uint64_t applied_layout_generation_ = 0;
    std::uint64_t tree_layout_generation_ = 1;
    static std::atomic<std::uint64_t> layout_generation_;
    static std::atomic<std::uint64_t> layout_pass_count_;
    static std::atomic<std::uint64_t> damage_request_count_;
    static std::atomic<std::uint64_t> unmarked_paint_mutation_count_;
    static std::atomic<std::uint64_t> constructed_count_;
    static std::atomic<std::uint64_t> destroyed_count_;
    void stale_subtree_caches_up();
    bool has_focus_ = false;
    // WidgetBridge may lend the root focus slot to a materialized document
    // while that document has an explicit, bounded navigation interaction.
    // This is intentionally private: ordinary roots must never become general
    // keyboard sinks, and the bridge clears the capability on release/teardown.
    bool scripted_navigation_input_ = false;
    bool hovered_ = false;
    bool default_hover_feedback_ = false;
    bool hit_testable_ = true;
    bool text_selection_region_ = false;
    HitSlop hit_slop_{};
    PointerEvents pointer_events_ = PointerEvents::auto_;
    bool backface_visible_ = true;
    bool requires_gpu_host_ = false;
    bool contains_native_overlay_ = false;
    bool overlay_consumes_outside_click_ = false;
    const View* overlay_nested_on_ = nullptr;  // compared only; see claim_overlay
    bool overlay_trigger_ = false;
    bool overlay_anchor_explicit_ = false;
    std::uint64_t overlay_anchor_id_ = 0;  // instance id; see set_overlay_anchor
    FrameClock* frame_clock_ = nullptr;
    // Lazily allocated on the first set_meter_source / set_scalar_source, so a
    // view that shows no live value costs one null pointer.
    std::unique_ptr<ViewValueBindings> value_bindings_;
    // Head of the intrusive list of every FrameClockBinding owned by this view —
    // the two above plus any a subclass holds (DesignFrameView's per-element
    // scalars). Intrusive so enrolling a binding never allocates.
    FrameClockBinding* value_binding_head_ = nullptr;
 
    // Visual properties
    float opacity_ = 1.0f;
    Color bg_color_{};
    bool has_bg_ = false;
    Color border_color_{};
    float border_width_ = 0;
    float corner_radius_ = 0;
    // borderRadius % support. When > 0, paint code resolves
    // effective radius as `corner_radius_pct_ * 0.01 * min(width, height)`.
    // 0 means "use plain corner_radius_ in px". Same pattern for the
    // per-corner radii_pct_ slots below.
    float corner_radius_pct_ = 0;
    // RN `borderCurve` corner shape.
    BorderCurve border_curve_ = BorderCurve::circular;
    bool has_border_ = false;
    BorderStyle border_style_ = BorderStyle::solid;
    // list-style cluster slots. Stored verbatim; paint-
    // time marker rendering is deferred. Defaults match CSS spec
    // (`disc` for the type, `outside` for the position, empty image).
    ListStyleType list_style_type_ = ListStyleType::disc;
    std::string list_style_image_{};
    ListStylePosition list_style_position_ = ListStylePosition::outside;
    // CSS / RN outline cluster. Defaults: outline_style_
    // is `none` so paint short-circuits unless JS opts in via
    // setOutlineStyle. width=0 also short-circuits as a belt-and-braces
    // guard. Color defaults to fully-transparent black; bridge writes
    // the parsed setter value before paint.
    Color outline_color_{};
    float outline_offset_ = 0.0f;
    float outline_width_ = 0.0f;
    BorderStyle outline_style_ = BorderStyle::none;
    // Per-side borders
    struct BorderSide { Color color{}; float width = 0; };
    BorderSide border_top_{}, border_right_{}, border_bottom_{}, border_left_{};
    bool has_border_sides_ = false;
    // Per-edge "explicitly set" flags, parallel to has_top_
    // / has_right_ / etc. for inset edges. Required so an explicit
    // borderTopWidth=0 overrides the uniform borderWidth=10 shorthand
    // (CSS / RN semantics). Plain `width == 0` is ambiguous because the
    // BorderSide default-initializes to 0.
    bool border_top_set_ = false;
    bool border_right_set_ = false;
    bool border_bottom_set_ = false;
    bool border_left_set_ = false;
    // Parallel flags for the per-edge COLOR longhands. Separate from the width
    // flags because CSS treats them as independent: `border-top-color` alone
    // must not make the top edge's width explicit.
    bool border_top_color_set_ = false;
    bool border_right_color_set_ = false;
    bool border_bottom_color_set_ = false;
    bool border_left_color_set_ = false;
    // Per-corner radii
    float corner_radii_[4] = {0, 0, 0, 0}; // TL, TR, BL, BR
    // % support paired with corner_radii_. >0 means use pct
    // resolution, 0 means use the px slot above. Sized 4 (TL, TR, BL, BR).
    float corner_radii_pct_[4] = {0, 0, 0, 0};
    bool has_corner_radii_ = false;
    Position position_ = Position::static_;
    float top_ = 0, right_ = 0, bottom_ = 0, left_ = 0;
    bool has_top_ = false, has_right_ = false, has_bottom_ = false, has_left_ = false;
    // Per-edge inset unit. `px` is the default; `percent` flows through to
    // YGNodeStyleSetPositionPercent in yoga_layout.cpp. Other DimensionUnit
    // values (vw/vh/etc.) round down to px at the bridge boundary today.
    DimensionUnit top_unit_ = DimensionUnit::px;
    DimensionUnit right_unit_ = DimensionUnit::px;
    DimensionUnit bottom_unit_ = DimensionUnit::px;
    DimensionUnit left_unit_ = DimensionUnit::px;
    int z_index_ = 0;
    // Default is `visible` to match CSS. Pulp previously
    // defaulted to `hidden`, which clipped absolutely-positioned children
    // (popovers, dropdowns, tooltips) to the parent's content bounds and
    // made them invisible whenever they extended outside. Plugins that
    // intentionally need clipping must call set_overflow(Overflow::hidden)
    // explicitly — same opt-in as `overflow:hidden` in CSS.
    Overflow overflow_ = Overflow::visible;
    float scroll_offset_x_ = 0.0f, scroll_offset_y_ = 0.0f;
    bool clip_marker_tolerance_ = false;
    std::vector<BoxShadow> shadows_;
    BoxShadow& first_box_shadow() {
        if (shadows_.empty()) shadows_.emplace_back();
        return shadows_.front();
    }
    float scale_ = 1.0f;
    float translate_x_ = 0, translate_y_ = 0;
    float rotation_deg_ = 0;
    float skew_x_ = 0, skew_y_ = 0;
    float origin_x_ = 0.5f, origin_y_ = 0.5f;  // transform-origin (normalized)
    bool origin_explicit_ = false;  // has set_transform_origin been called?
    // Full 2D affine matrix. Identity by default; only applied
    // when has_transform_matrix_ is true. Stored in CanvasRenderingContext2D
    // (a,b,c,d,e,f) order:  [a c e / b d f / 0 0 1].
    float transform_matrix_a_ = 1.0f, transform_matrix_b_ = 0.0f,
          transform_matrix_c_ = 0.0f, transform_matrix_d_ = 1.0f,
          transform_matrix_e_ = 0.0f, transform_matrix_f_ = 0.0f;
    bool has_transform_matrix_ = false;
    float filter_blur_ = 0;
    std::vector<FilterOp> filter_chain_{};
    // CSS-compat storage-only style slots, lazily allocated. Native View
    // trees never set these, so keeping them behind a pointer avoids ~14
    // empty std::strings + floats per View instance. Allocated on first
    // write via style_extras(); readers fall back to defaults when null.
    // Paint-time consumption: clip_path via Canvas::clip_path_svg
    // (SkPath::FromSVGString on Skia, no-op fallback elsewhere); mask_image /
    // mask via mask-capable backends; the rest round-trip through storage.
    struct ViewStyleExtras {
        StagedAnimation staged_animation{};
        float backdrop_blur = 0.0f;
        std::vector<FilterOp> backdrop_filter_chain;
        // Import-resolved clip on this view's OWN ink; see
        // set_ancestor_clip_rect for why it does not descend.
        std::optional<Rect> ancestor_clip;
        // Corner radii of that clip, clockwise from top-left; see
        // set_ancestor_clip_radii.
        std::array<float, 4> ancestor_clip_radii{0.0f, 0.0f, 0.0f, 0.0f};
        std::string clip_path;
        std::string mask_image;
        std::string mask;
        std::string mask_size;     // CSS mask-size paired with mask_image
        std::string appearance;    // CSS appearance — storage-only no-op for Pulp custom widgets
        std::string object_fit;      // CSS object-fit consumed by ImageView paint
        std::string object_position; // CSS object-position paired with object-fit
        std::string background_attachment;  // noop today
        std::string background_clip;        // partial (text deferred)
        std::string background_origin;      // gradient tile box; content-box partial
        std::string background_position;    // repeating gradient tile phase; raster bg deferred
        std::string background_size;        // storage-only (raster bg deferred)
    };
    std::unique_ptr<ViewStyleExtras> style_extras_;
    ViewStyleExtras& style_extras() {
        if (!style_extras_) style_extras_ = std::make_unique<ViewStyleExtras>();
        return *style_extras_;
    }
    std::vector<TransitionSpec> transitions_{};
    std::vector<CssAnimation> active_animations_{};
 
    // Storage-only catalog slots.
    float       text_indent_ = 0.0f;       // partial (paint deferred)
    std::string word_break_;               // partial (HarfBuzz feature deferred)
    std::string scroll_behavior_;          // ScrollView consumes
    std::string overscroll_behavior_;      // ScrollView clamp consumes
    bool        include_font_padding_ = true;  // Android legacy round-trip slot (paint ignores)
    std::string font_variant_;             // partial (HarfBuzz feature deferred)
    std::string writing_mode_;             // noop (Pulp horizontal-only)
    std::string isolation_;                // wontfix (no z-buffer)
    std::string resize_;                   // noop (no resize handles)
    std::string animation_play_state_;     // partial (tick_animations consumes)
    bool wants_continuous_repaint_ = false; // opt-in per-vsync repaint
    // RN textShadow* per-attribute storage slots. SkPaint shadow integration
    // deferred; storage path is round-trippable.
    std::string text_shadow_color_;
    float       text_shadow_dx_ = 0.0f;
    float       text_shadow_dy_ = 0.0f;
    float       text_shadow_radius_ = 0.0f;
    bool needs_layer_ = false;
    // FU-3 subtree scene cache. `subtree_cached_` is the opt-in flag;
    // `scene_cache_` holds the recorded scene (shared_ptr so it survives across
    // frames until invalidated); `scene_cache_valid_` gates replay vs re-record.
    bool subtree_cached_ = false;
    bool scene_cache_valid_ = false;
    std::shared_ptr<canvas::SceneRecording> scene_cache_;
    WindowHost* window_host_ = nullptr;
    PluginViewHost* plugin_view_host_ = nullptr;
    HostParamSurface* host_params_ = nullptr;
    HostActionSurface* host_actions_ = nullptr;
 
    // Running animate() tweens: our returned id is the FrameClock subscription
    // id; `tag` supports self-cancelling animations. Unsubscribed in ~View.
    // `clock` is cached at subscribe time so ~View can unsubscribe even after
    // this view is detached (frame_clock() walks parent_, which a removed child
    // has cleared to null — see the detached-child UAF the cache fixes).
    struct RunningAnimation { int clock_id = -1; std::string tag; FrameClock* clock = nullptr; };
    std::vector<RunningAnimation> animations_;
    std::shared_ptr<canvas::ViewEffect> effect_;
    // Background-image layers, first on top (CSS paint order).
    std::vector<BackgroundGradient> bg_gradients_;
    std::string background_repeat_;  
    float captured_box_paint_left_ = 0.0f;
    float captured_box_paint_top_ = 0.0f;
    float captured_box_paint_right_ = 0.0f;
    float captured_box_paint_bottom_ = 0.0f;
    float captured_box_paint_scale_ = 0.0f;
    bool text_ellipsis_ = false;
    bool white_space_nowrap_ = false;
    WhiteSpaceMode white_space_mode_ = WhiteSpaceMode::normal;
    CursorStyle cursor_ = CursorStyle::default_;
    UserSelect user_select_ = UserSelect::auto_;
    WritingDirection direction_ = WritingDirection::auto_;
    // CSS / RN mix-blend-mode. Default kSrcOver (canvas
    // BlendMode::normal) is a paint-time no-op; any non-default value
    // forces a saveLayer() at paint time so the subtree composites back
    // through the requested blend mode.
    canvas::Canvas::BlendMode mix_blend_mode_ = canvas::Canvas::BlendMode::normal;
 
    // Pointer capture: pointer_id → this view receives all events for that pointer
    std::vector<int> captured_pointers_;
    std::vector<std::unique_ptr<GestureRecognizer>> gesture_recognizers_; std::unique_ptr<GestureArbiter> gesture_arbiter_;
 
    // CSS-style typography inheritance. Unset by default; only
    // populated when the bridge / app calls a set_inheritable_* setter.
    // These do not affect the View's own paint — only descendant Labels
    // (and other text widgets) consult them.
    std::optional<Color> inh_text_color_;
    std::optional<float> inh_font_size_;
    std::optional<float> inh_letter_spacing_;
    std::optional<int>   inh_font_weight_;
    std::optional<int>   inh_text_align_;
    std::optional<std::string> inh_font_family_;
};
 
// Expand min/max window-coord extents to cover `v` and every transitive
// descendant reachable through an unbroken chain of `overflow:visible` views —
// i.e. the true painted bounding box, since an `overflow:hidden` ancestor
// clips whatever is below it. `parent_abs_x/y` are the absolute window-coord
// origin of `v`'s parent. Shared by View::overlay_contains and
// ScrollView::hit_test so both size an overflow:visible child's interactive
// area from its actual painted extent rather than a blanket margin.
void accumulate_overflow_extent(const View* v,
                                float parent_abs_x,
                                float parent_abs_y,
                                float& min_x,
                                float& min_y,
                                float& max_x,
                                float& max_y);
 
// Expand `right` / `bottom` to cover every visible laid-out descendant box of
// `parent`, in `parent`'s coordinate space offset by `parent_x/y`. Sets
// `found` when it measured at least one child, so a childless container is
// distinguishable from one whose content genuinely ends at the origin.
//
// The walk STOPS at a nested `is_scroll_container()` child: that child owns
// its own private overflow and clips it, so the outer container measures the
// nested viewport box rather than content the inner one already scrolls.
//
// Single implementation shared by `View::scroll_content_size()` and
// `ScrollView::update_automatic_content_size()` — two content measurements
// that disagreed would clamp the two scrollers to different ranges.
void accumulate_scroll_content_extent(const View& parent, float parent_x, float parent_y,
                                      float& right, float& bottom, bool& found);
 
// ── Accessibility exposure gate ──────────────────────────────────────────────
//
// See is_accessibility_element() in <pulp/view/accessibility.hpp> — the single
// predicate every platform bridge calls. It lives there because it has to look
// for the value/text interfaces, which are declared there. This file only
// classifies the ROLES.

constexpr bool is_structural_access_role(View::AccessRole role) {
    switch (role) {
        case View::AccessRole::group:
        case View::AccessRole::dialog:
        case View::AccessRole::list:
        case View::AccessRole::table:
        case View::AccessRole::row:
        case View::AccessRole::menu:
        case View::AccessRole::tab_list:
            return true;
        default:
            return false;
    }
}
 
} // namespace pulp::view