@perspective-dev/viewer 5.3.1 → 5.5.0

package/src/rust/renderer/dispatch.rs

@@ -19,6 +19,7 @@ use std::future::Future;
 use std::rc::Rc;
 
 use perspective_client::View;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::{ApiResult, ResultTApiErrorExt};
 use wasm_bindgen::prelude::*;
 use web_sys::*;
@@ -44,25 +45,27 @@ impl Renderer {
         let _ = el.class_list().toggle_with_force("multi", !is_solo);
     }
 
-    /// Stamp this panel's effective `theme` attribute.
     pub fn stamp_theme(&self, plugin: Option<&JsPerspectiveViewerPlugin>) {
+        let theme = self.theme();
         let active_plugin = self.active_plugin();
         if let Some(plugin) = plugin.or(active_plugin.as_ref()) {
-            let theme_elem = plugin.unchecked_ref::<HtmlElement>();
-            match self.theme() {
-                Some(theme)
-                    if theme_elem.get_attribute("theme").as_deref() != Some(theme.as_str()) =>
-                {
-                    let _ = theme_elem.set_attribute("theme", &theme);
-                },
-                Some(_) => {},
-                None => {
-                    let _ = theme_elem.remove_attribute("theme");
-                },
-            }
+            stamp_theme_attr(plugin.unchecked_ref::<Element>(), theme.as_deref());
+        }
+
+        if let Some(tab) = self.tab_host() {
+            stamp_theme_attr(&tab, theme.as_deref());
         }
     }
 
+    fn tab_host(&self) -> Option<Element> {
+        let slot = format!("tab-{}", self.slot_name()?);
+        let viewer = self.plugin_data.borrow().viewer_elem.clone();
+        let children = viewer.children();
+        (0..children.length())
+            .filter_map(|i| children.item(i))
+            .find(|el| el.get_attribute("slot").as_deref() == Some(slot.as_str()))
+    }
+
     /// Restyle the active plugin and re-draw.
     pub async fn restyle_all(&self) -> ApiResult<JsValue> {
         self.render_task(|guard| async move {
@@ -78,8 +81,14 @@ impl Renderer {
             self.stamp_active(&plugin);
             plugin.restyle();
             *self.0.captured_theme.borrow_mut() = Some(stamped_theme);
-            let mut limits =
-                get_row_and_col_limits(&ctx.view, &meta, self.is_render_warning_enabled()).await?;
+            let dimensions = ctx.view.dimensions().await?;
+            let mut limits = get_row_and_col_limits(
+                &dimensions,
+                &ctx.view,
+                &meta,
+                self.is_render_warning_enabled(),
+            )
+            .await?;
 
             limits.is_update = true;
             plugin
@@ -215,6 +224,7 @@ impl Renderer {
                         };
 
                         self.stamp_active(&jsplugin);
+                        self.0.presized_box.set(None);
                         jsplugin.resize().await?;
                         Ok(None)
                     },
@@ -241,7 +251,33 @@ impl Renderer {
         self.stamp_active(&plugin);
         self.clear_presize()?;
         if plugin.capabilities().presize {
-            return plugin.presize(width, height).await;
+            let Some(present) = plugin.presize(width, height).await? else {
+                return Ok(None);
+            };
+
+            self.0.presized_box.set(Some((width, height)));
+            let inline = js_sys::Reflect::get(&present, &"inline".into())
+                .ok()
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+
+            if inline {
+                self.0.presized_box.set(None);
+            }
+
+            let renderer = self.clone();
+            let wrapped = Closure::once_into_js(move || {
+                let filled = present
+                    .call0(&JsValue::NULL)
+                    .map(|v| v.as_bool() != Some(false))
+                    .unwrap_or(false);
+
+                if !filled {
+                    renderer.0.presized_box.set(None);
+                }
+            });
+
+            return Ok(Some(wrapped.unchecked_into::<js_sys::Function>()));
         }
 
         let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
@@ -278,6 +314,7 @@ impl Renderer {
             }
 
             result?;
+            self.0.presized_box.set(Some((width, height)));
         }
 
         Ok(None)
@@ -307,14 +344,16 @@ impl Renderer {
     pub async fn draw_fresh(&self, guard: &RenderGuard, view: FreshView) -> ApiResult<()> {
         let timer = self.render_timer();
         timer
-            .capture_time(self.draw_view(guard, view.view(), false))
+            .capture_time(self.draw_view(guard, view.view(), false, None))
             .await
     }
 
     /// Repaint the ALREADY-BOUND `view` on the active plugin.
     pub async fn update_bound(&self, guard: &RenderGuard, view: &View) -> ApiResult<()> {
         let timer = self.render_timer();
-        timer.capture_time(self.draw_view(guard, view, true)).await
+        timer
+            .capture_time(self.draw_view(guard, view, true, None))
+            .await
     }
 
     /// Mint the [`FreshView`] full-draw witness for a plugin that has never
@@ -363,7 +402,7 @@ impl Renderer {
     /// Redraw an already-bound view, debounced.
     pub async fn update_lazy(
         &self,
-        view: impl Future<Output = ApiResult<Option<View>>>,
+        view: impl Future<Output = ApiResult<Option<(View, Option<ViewDimensionsResp>)>>>,
     ) -> ApiResult<()> {
         let timer = self.render_timer();
         self.draw_lock()
@@ -382,14 +421,14 @@ impl Renderer {
                 }
 
                 self.mount_active_plugin()?;
-                if let Some(view) = view.await? {
+                if let Some((view, dimensions)) = view.await? {
                     let _pin = self
                         .cached_context()
                         .map(|ctx| self.pin_context(&guard, ctx));
 
                     let timer = self.render_timer();
                     timer
-                        .capture_time(self.draw_view(&guard, &view, true))
+                        .capture_time(self.draw_view(&guard, &view, true, dimensions))
                         .await
                 } else {
                     tracing::debug!("Render skipped, no `View` attached");
@@ -399,11 +438,14 @@ impl Renderer {
             .await
     }
 
+    /// `dimensions` is the caller's already-fetched view dimensions, or
+    /// `None` to fetch here.
     async fn draw_view(
         &self,
         _guard: &RenderGuard,
         view: &perspective_client::View,
         is_update: bool,
+        dimensions: Option<ViewDimensionsResp>,
     ) -> ApiResult<()> {
         debug_assert!(
             !is_update || self.cached_context().is_none() || self.render_context().is_some(),
@@ -420,8 +462,14 @@ impl Renderer {
         };
 
         let meta = self.metadata();
+        let dimensions = match dimensions {
+            Some(dimensions) => dimensions,
+            None => view.dimensions().await?,
+        };
+
         let mut limits =
-            get_row_and_col_limits(view, &meta, self.is_render_warning_enabled()).await?;
+            get_row_and_col_limits(&dimensions, view, &meta, self.is_render_warning_enabled())
+                .await?;
 
         limits.is_update = is_update;
         if let Some(cb) = self.0.on_render_limits_changed.borrow().as_ref() {
@@ -440,6 +488,7 @@ impl Renderer {
         }
 
         self.0.data_stale.set(false);
+        self.0.presized_box.set(None);
         let result = if is_update {
             let task = plugin.update(view.clone().into(), limits.max_cols, limits.max_rows, false);
             activate_plugin(_guard, &viewer_elem, &plugin, slot.as_deref(), task).await
@@ -499,3 +548,15 @@ impl Drop for PresizePendingGuard {
         cell.set(cell.get() - 1);
     }
 }
+
+fn stamp_theme_attr(el: &Element, theme: Option<&str>) {
+    match theme {
+        Some(theme) if el.get_attribute("theme").as_deref() != Some(theme) => {
+            let _ = el.set_attribute("theme", theme);
+        },
+        Some(_) => {},
+        None => {
+            let _ = el.remove_attribute("theme");
+        },
+    }
+}

package/src/rust/renderer/limits.rs

@@ -10,6 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::ApiError;
 
 use crate::config::PluginStaticConfig;
@@ -31,16 +32,34 @@ pub struct RenderLimits {
     pub max_rows: Option<usize>,
 }
 
-/// Compute the row/column caps for `view` against the plugin's static
-/// limits. `render_warning` is the renderer-state flag controlling
-/// whether the warning is currently armed; when `false`, an oversized
-/// view renders uncapped (the user has dismissed the warning).
+impl RenderLimits {
+    /// The column cap is in effect (fewer columns render than the view has).
+    pub fn is_col_capped(&self) -> bool {
+        self.max_cols.is_some_and(|x| x < self.num_cols)
+    }
+
+    /// The row cap is in effect (fewer rows render than the view has).
+    pub fn is_row_capped(&self) -> bool {
+        self.max_rows.is_some_and(|x| x < self.num_rows)
+    }
+
+    /// Either cap is in effect — exactly when the render warning shows.
+    pub fn is_capped(&self) -> bool {
+        self.is_col_capped() || self.is_row_capped()
+    }
+}
+
+/// Compute the row/column caps for `view` from its already-fetched
+/// `dimensions` against the plugin's static limits. `render_warning` is the
+/// renderer-state flag controlling whether the warning is currently armed;
+/// when `false`, an oversized view renders uncapped (the user has dismissed
+/// the warning).
 pub async fn get_row_and_col_limits(
+    dimensions: &ViewDimensionsResp,
     view: &perspective_client::View,
     config: &PluginStaticConfig,
     render_warning: bool,
 ) -> Result<RenderLimits, ApiError> {
-    let dimensions = view.dimensions().await?;
     let num_cols = dimensions.num_view_columns as usize;
     let num_rows = dimensions.num_view_rows as usize;
     match (config.max_columns, render_warning) {

package/src/rust/renderer/plugin_config.rs

@@ -26,6 +26,7 @@ use super::Renderer;
 use crate::config::*;
 use crate::queries::resolve_abs_max;
 use crate::session::Session;
+use crate::utils::{CssKind, CssLiteralUse, parse_var_ref, resolve_css_refs};
 
 /// A per-column config map. Each inner [`serde_json::Map`] is a flat collection
 /// of plugin-defined JSON keys whose shape is dictated by the active plugin's
@@ -246,10 +247,16 @@ impl Renderer {
                     {
                         let active = schema.active_keys();
                         cfg.retain(|k, _| active.contains(k));
-                        let errors = normalize_css_values(&schema, &mut cfg);
+                        let errors = normalize_values(&schema, &mut cfg);
                         if let Some((key, error)) = errors.first() {
+                            let ty = session
+                                .metadata()
+                                .get_column_view_type(&col)
+                                .map(|t| format!(" for a {t} column"))
+                                .unwrap_or_default();
+
                             return Err(ApiError::from(JsValue::from_str(&format!(
-                                "Invalid `columns_config[\"{col}\"].{key}`: {error}"
+                                "Invalid `columns_config[\"{col}\"].{key}`{ty}: {error}"
                             ))));
                         }
 
@@ -304,7 +311,7 @@ impl Renderer {
             &column_name,
             current_value.as_ref(),
         ) {
-            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+            for (key, error) in normalize_values(&schema, &mut update.value) {
                 tracing::error!("Dropping `{column_name}`.`{key}`: {error}");
             }
 
@@ -328,16 +335,25 @@ impl Renderer {
             entry.clone()
         };
 
-        let active = self
+        // The schema AFTER the update decides which keys survive and, for a
+        // key whose control kind follows another key (`fg_color` reads as a
+        // color, gradient or palette depending on `fg_mode`), whether the
+        // value still parses under its new kind. A value that no longer
+        // does is dropped here, so `save()` never emits a config that
+        // `restore()` would reject.
+        let after = self
             .query_column_config_schema(view_config, session, &column_name, Some(&next))
-            .ok()
-            .map(|schema| schema.active_keys());
+            .ok();
 
         let mut st = self.borrow_mut();
         let bucket = st.plugin_states.entry(n).or_default();
         if let Some(entry) = bucket.columns.get_mut(&column_name) {
-            if let Some(active) = &active {
+            if let Some(schema) = &after {
+                let active = schema.active_keys();
                 entry.retain(|k, _| active.contains(k));
+                for (key, error) in normalize_values(schema, entry) {
+                    tracing::warn!("Dropping `{column_name}`.`{key}` after a mode change: {error}");
+                }
             }
 
             if entry.is_empty() {
@@ -370,15 +386,18 @@ impl Renderer {
         }
     }
 
-    /// Synchronously query the active plugin's
-    /// [`ColumnConfigSchema`] used to gate plugin-config strip logic.
+    /// Synchronously query the active plugin's [`ColumnConfigSchema`] as it
+    /// applies to `current_value`, the plugin-config state the schema should
+    /// describe.
     fn query_plugin_config_schema(
         &self,
         view_config: &ViewConfig,
+        current_value: Option<&serde_json::Map<String, serde_json::Value>>,
     ) -> ApiResult<ColumnConfigSchema> {
         let plugin = self.ensure_plugin_selected()?;
         let view_config_js = JsValue::from_serde_ext(view_config).unwrap_or(JsValue::NULL);
-        let raw = plugin._plugin_config_schema(&view_config_js)?;
+        let current_js = JsValue::from_serde_ext(&current_value).unwrap_or(JsValue::NULL);
+        let raw = plugin._plugin_config_schema(&view_config_js, &current_js)?;
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
             .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
@@ -433,12 +452,9 @@ impl Renderer {
             .map_err(|e| e.into())
     }
 
-    /// Wholesale update the active plugin's plugin-level config map.
-    /// Entries whose value equals the schema-declared default are
-    /// treated as "reset this key" — the corresponding bucket entry
-    /// is cleared rather than the default being stored literally.
-    /// Keys absent from the incoming map are left alone (merge
-    /// semantics for the non-default subset).
+    /// Merge an update into the active plugin's plugin-level config map,
+    /// clearing entries equal to the schema default and dropping keys the
+    /// resulting schema no longer advertises.
     pub fn update_plugin_config(
         &self,
         view_config: &ViewConfig,
@@ -448,28 +464,42 @@ impl Renderer {
             return Ok(false);
         };
 
-        let schema = self.query_plugin_config_schema(view_config).ok();
-        let mut st = self.borrow_mut();
-        let bucket = st.plugin_states.entry(n).or_default();
         match update {
             OptionalUpdate::SetDefault => {
+                let mut st = self.borrow_mut();
+                let bucket = st.plugin_states.entry(n).or_default();
                 let changed = !bucket.plugin.is_empty();
                 bucket.plugin.clear();
                 Ok(changed)
             },
             OptionalUpdate::Missing => Ok(false),
             OptionalUpdate::Update(mut map) => {
-                let mut changed = false;
+                let mut merged = self.get_plugin_config();
+                for (k, v) in &map {
+                    merged.insert(k.clone(), v.clone());
+                }
+
+                let schema = self
+                    .query_plugin_config_schema(view_config, Some(&merged))
+                    .ok();
+
+                let mut active = None;
                 if let Some(s) = &schema {
-                    let active = s.active_keys();
-                    map.retain(|k, _| active.contains(k));
-                    let errors = normalize_css_values(s, &mut map);
+                    let keys = s.active_keys();
+                    map.retain(|k, _| keys.contains(k));
+                    active = Some(keys);
+                    let errors = normalize_values(s, &mut map);
                     if let Some((key, error)) = errors.first() {
                         return Err(ApiError::from(JsValue::from_str(&format!(
                             "Invalid `plugin_config.{key}`: {error}"
                         ))));
                     }
+                }
 
+                let mut st = self.borrow_mut();
+                let bucket = st.plugin_states.entry(n).or_default();
+                let mut changed = false;
+                if let Some(s) = &schema {
                     let leaves = s.leaf_fields();
                     map.retain(|key, value| {
                         let is_default = leaves
@@ -493,12 +523,19 @@ impl Renderer {
                     }
                 }
 
+                if let Some(active) = active {
+                    let before = bucket.plugin.len();
+                    bucket.plugin.retain(|k, _| active.contains(k));
+                    changed |= bucket.plugin.len() != before;
+                }
+
                 Ok(changed)
             },
         }
     }
 
-    /// Apply a single schema-field update from the plugin-settings UI
+    /// Apply a single schema-field update from the plugin-settings UI,
+    /// dropping keys the resulting schema no longer advertises.
     pub fn update_plugin_config_field(
         &self,
         view_config: &ViewConfig,
@@ -508,12 +545,28 @@ impl Renderer {
             return false;
         };
 
-        if let Ok(schema) = self.query_plugin_config_schema(view_config) {
-            for (key, error) in normalize_css_values(&schema, &mut update.value) {
+        let mut next = self.get_plugin_config();
+        for k in &update.keys {
+            match update.value.get(k) {
+                Some(v) => {
+                    next.insert(k.clone(), v.clone());
+                },
+                None => {
+                    next.remove(k);
+                },
+            }
+        }
+
+        let schema = self
+            .query_plugin_config_schema(view_config, Some(&next))
+            .ok();
+
+        if let Some(schema) = &schema {
+            for (key, error) in normalize_values(schema, &mut update.value) {
                 tracing::error!("Dropping `plugin_config`.`{key}`: {error}");
             }
 
-            strip_default_values(&schema, &mut update.value);
+            strip_default_values(schema, &mut update.value);
         }
 
         let mut st = self.borrow_mut();
@@ -531,28 +584,48 @@ impl Renderer {
             }
         }
 
+        if let Some(schema) = &schema {
+            let active = schema.active_keys();
+            let before = bucket.plugin.len();
+            bucket.plugin.retain(|k, _| active.contains(k));
+            changed |= bucket.plugin.len() != before;
+        }
+
         changed
     }
 }
 
-fn normalize_css_values(
+/// Canonicalize every CSS-valued key of `map` and check every `Enum`-valued
+/// key against its variants, removing and reporting the keys that fail.
+/// The schema is the one queried for `map`'s own values, so an `Enum`'s
+/// variants are exactly the values the column's type accepts.
+fn normalize_values(
     schema: &ColumnConfigSchema,
     map: &mut serde_json::Map<String, serde_json::Value>,
 ) -> Vec<(String, String)> {
     let mut errors = vec![];
     for (key, value) in map.iter_mut() {
-        let Some(kind) = schema.css_kind_of(key) else {
-            continue;
-        };
-
-        let canonical = match value.as_str() {
-            Some(src) => kind.canonicalize(src),
-            None => Err(format!("expected a CSS string, got `{value}`")),
-        };
+        if let Some(kind) = schema.css_kind_of(key) {
+            let canonical = match value.as_str() {
+                Some(src) => kind.canonicalize(src),
+                None => Err(format!("expected a CSS string, got `{value}`")),
+            };
 
-        match canonical {
-            Ok(canonical) => *value = Value::String(canonical),
-            Err(error) => errors.push((key.clone(), error)),
+            match canonical {
+                Ok(canonical) => *value = Value::String(canonical),
+                Err(error) => errors.push((key.clone(), error)),
+            }
+        } else if let Some(variants) = schema.enum_variants_of(key) {
+            let accepted = variants.iter().any(|v| value.as_str() == Some(&v.value));
+            if !accepted {
+                let expected = variants
+                    .iter()
+                    .map(|v| format!("`{}`", v.value))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                errors.push((key.clone(), format!("{value} is not one of {expected}")));
+            }
         }
     }
 
@@ -579,6 +652,21 @@ fn matches_declared_default(spec: &ControlSpec, key: &str, value: &Value) -> boo
     match spec {
         ControlSpec::Enum {
             key: k, default, ..
+        }
+        | ControlSpec::Font {
+            key: k, default, ..
+        } if k == key => value.as_str() == Some(default.as_str()),
+        ControlSpec::Font {
+            size: Some(size), ..
+        } if size.key == key => value.as_f64() == Some(size.default),
+        ControlSpec::Font { bold, italic, .. } => [bold, italic]
+            .into_iter()
+            .flatten()
+            .any(|toggle| toggle.key == key && value.as_bool() == Some(toggle.default)),
+        ControlSpec::Alignment {
+            key: k,
+            default: Some(default),
+            ..
         } if k == key => value.as_str() == Some(default.as_str()),
         ControlSpec::Bool {
             key: k, default, ..
@@ -702,6 +790,35 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn alignment_strips_only_a_declared_default() {
+        let schema = ColumnConfigSchema {
+            fields: vec![
+                ControlSpec::Alignment {
+                    key: "align".to_owned(),
+                    default: None,
+                    corners: false,
+                },
+                ControlSpec::Alignment {
+                    key: "legend_anchor".to_owned(),
+                    default: Some(Alignment::TopRight),
+                    corners: true,
+                },
+            ],
+        };
+
+        let mut map = json!({ "align": "center", "legend_anchor": "top-right" })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        strip_default_values(&schema, &mut map);
+        assert_eq!(
+            map,
+            json!({ "align": "center" }).as_object().unwrap().clone()
+        );
+    }
+
     #[test]
     fn strip_default_values_sees_through_groups() {
         let leaves = vec![
@@ -750,7 +867,50 @@ mod tests {
     }
 
     #[test]
-    fn normalize_css_values_canonicalizes_and_reports() {
+    fn normalize_values_rejects_enum_values_outside_the_variants() {
+        let schema = ColumnConfigSchema {
+            fields: vec![ControlSpec::Group {
+                key: "color".to_owned(),
+                fields: vec![ControlSpec::Enum {
+                    key: "fg_mode".to_owned(),
+                    default: "color".to_owned(),
+                    variants: vec![
+                        EnumVariant {
+                            value: "disabled".to_owned(),
+                            label: None,
+                        },
+                        EnumVariant {
+                            value: "color".to_owned(),
+                            label: None,
+                        },
+                    ],
+                }],
+            }],
+        };
+
+        let mut map = json!({ "fg_mode": "color", "other": "series" })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        assert!(normalize_values(&schema, &mut map).is_empty());
+        assert_eq!(map.len(), 2);
+
+        let mut map = json!({ "fg_mode": "series" }).as_object().unwrap().clone();
+        let errors = normalize_values(&schema, &mut map);
+        assert_eq!(errors.len(), 1);
+        assert_eq!(errors[0].0, "fg_mode");
+        assert_eq!(errors[0].1, "\"series\" is not one of `disabled`, `color`");
+        assert!(map.is_empty());
+
+        let mut map = json!({ "fg_mode": 3 }).as_object().unwrap().clone();
+        let errors = normalize_values(&schema, &mut map);
+        assert_eq!(errors.len(), 1);
+        assert!(map.is_empty());
+    }
+
+    #[test]
+    fn normalize_values_canonicalizes_and_reports() {
         let schema = ColumnConfigSchema {
             fields: vec![
                 ControlSpec::Color {
@@ -785,7 +945,7 @@ mod tests {
         .unwrap()
         .clone();
 
-        let errors = normalize_css_values(&schema, &mut map);
+        let errors = normalize_values(&schema, &mut map);
         assert_eq!(errors.len(), 1);
         assert_eq!(errors[0].0, "gradient");
         assert_eq!(

package/src/rust/renderer/plugin_store.rs

@@ -26,7 +26,8 @@ pub struct PluginStore {
 
 impl PluginStore {
     fn init_lazy(&mut self) {
-        self.plugins = Some(PLUGIN_REGISTRY.create_plugins());
+        let plugins = PLUGIN_REGISTRY.create_plugins();
+        self.plugins = Some(plugins);
         self.plugin_configs = Some(PLUGIN_REGISTRY.plugin_configs());
         self.plugin_records = Some(PLUGIN_REGISTRY.available_plugin_names_by_category());
     }

package/src/rust/renderer/props.rs

@@ -14,6 +14,7 @@ use std::rc::Rc;
 
 use crate::config::PluginStaticConfig;
 use crate::renderer::limits::RenderLimits;
+use crate::renderer::plugin_config::ColumnConfigMap;
 use crate::utils::PtrEqRc;
 
 /// Value-semantic snapshot of the renderer state read by components.
@@ -30,7 +31,8 @@ pub struct RendererProps {
     /// internal `metadata` — `Rc::ptr_eq` works.
     pub config: Rc<PluginStaticConfig>,
 
-    /// Most recently emitted render limits, if any.
+    /// The most recently emitted render limits, only while a cap is in
+    /// effect.
     pub render_limits: Option<RenderLimits>,
 
     /// Names of all registered plugins, in registration order.
@@ -49,6 +51,10 @@ pub struct RendererProps {
     /// the interior-mutable handle, no manual PubSub subscription, no
     /// race window between `plugins_idx` swap and the schema query.
     pub plugin_config: PtrEqRc<serde_json::Map<String, serde_json::Value>>,
+
+    /// Snapshot of the active plugin's `columns_config` bucket, re-read by
+    /// `Renderer::to_props` on `columns_config_changed` and `plugin_changed`.
+    pub columns_config: PtrEqRc<ColumnConfigMap>,
 }
 
 impl RendererProps {