@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/renderer/props.rs

@@ -15,6 +15,7 @@ use std::rc::Rc;
 use crate::config::PluginStaticConfig;
 use crate::renderer::limits::RenderLimits;
 use crate::renderer::plugin_config::ColumnConfigMap;
+use crate::renderer::state::RenderError;
 use crate::utils::PtrEqRc;
 
 /// Value-semantic snapshot of the renderer state read by components.
@@ -55,6 +56,9 @@ pub struct RendererProps {
     /// 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>,
+
+    /// The failure of the last draw, which stands until the next commit.
+    pub render_error: Option<RenderError>,
 }
 
 impl RendererProps {

package/src/rust/renderer/registry.rs

@@ -43,7 +43,8 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
                 let mut elements = vec![];
                 for plugin in plugins.borrow().iter() {
                     let element = create_plugin(&plugin.tag_name);
-                    // let style = element.unchecked_ref::<HtmlElement>().style();
+                    // let style =
+                    // element.unchecked_ref::<HtmlElement>().style();
                     // style.set_property("position", "absolute")?;
                     // style.set_property("top", "0")?;
                     // style.set_property("right", "0")?;
@@ -147,11 +148,6 @@ pub impl LocalKey<Rc<RefCell<Vec<PluginRecord>>>> {
             });
         });
     }
-
-    #[cfg(test)]
-    fn reset(&'static self) {
-        self.with(|plugins| plugins.borrow_mut().clear());
-    }
 }
 
 fn register_default() {

package/src/rust/renderer/state.rs

@@ -0,0 +1,205 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use perspective_js::utils::ApiError;
+
+use super::plugin_config::PluginScopedConfig;
+use crate::config::{ColumnConfigFieldUpdate, PluginStaticConfig};
+
+/// How a panel is drawn, as one immutable value replaced whole.
+#[derive(Clone, Default)]
+pub struct RendererState {
+    /// The selected plugin, or `None` until the first run selects one.
+    pub plugin: Option<PluginRef>,
+
+    /// Every plugin's own `plugin_config` and `columns_config`, keyed by
+    /// plugin name.
+    pub buckets: Rc<HashMap<String, PluginScopedConfig>>,
+
+    /// This panel's concrete theme name.
+    pub theme: Option<String>,
+}
+
+/// A plugin selection: its index in the plugin store and its static config.
+#[derive(Clone)]
+pub struct PluginRef {
+    pub idx: usize,
+    pub static_config: Rc<PluginStaticConfig>,
+}
+
+impl RendererState {
+    pub fn with_theme(&self, theme: Option<String>) -> Self {
+        Self {
+            theme,
+            ..self.clone()
+        }
+    }
+
+    pub fn with_plugin(&self, plugin: PluginRef) -> Self {
+        Self {
+            plugin: Some(plugin),
+            ..self.clone()
+        }
+    }
+
+    /// This state with no plugin selected and every bucket forgotten.
+    pub fn without_plugins(&self) -> Self {
+        Self {
+            plugin: None,
+            buckets: Rc::default(),
+            ..self.clone()
+        }
+    }
+
+    /// The named plugin's bucket, empty when it has never been written.
+    pub fn bucket(&self, name: &str) -> PluginScopedConfig {
+        self.buckets.get(name).cloned().unwrap_or_default()
+    }
+
+    /// This state with the named plugin's bucket replaced.
+    pub fn with_bucket(&self, name: &str, bucket: PluginScopedConfig) -> Self {
+        let mut buckets = (*self.buckets).clone();
+        buckets.insert(name.to_owned(), bucket);
+        Self {
+            buckets: Rc::new(buckets),
+            ..self.clone()
+        }
+    }
+}
+
+/// A failure to draw a valid committed state.
+#[derive(Clone)]
+pub struct RenderError(pub ApiError);
+
+impl PartialEq for RenderError {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_string() == other.0.to_string()
+    }
+}
+
+impl std::fmt::Debug for RenderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("RenderError")
+            .field(&self.0.to_string())
+            .finish()
+    }
+}
+
+/// How the last draw of the committed state went, which any commit resets.
+#[derive(Clone, Default)]
+pub enum RenderOutcome {
+    #[default]
+    Never,
+    Ok,
+    Failed(RenderError),
+}
+
+/// A UI edit of the renderer's state that is queued but not yet committed.
+#[derive(Clone)]
+pub enum StagedEdit {
+    /// One plugin-level settings field of the selected plugin.
+    PluginField(ColumnConfigFieldUpdate),
+
+    /// One style field of one column, for the selected plugin.
+    ColumnField {
+        column: String,
+        update: ColumnConfigFieldUpdate,
+    },
+
+    /// Keys merged into the selected plugin's `plugin_config`.
+    PluginConfig(serde_json::Map<String, serde_json::Value>),
+    Theme(Option<String>),
+}
+
+/// The renderer's staged edits, in the order they were made.
+#[derive(Default)]
+pub(super) struct StagedEdits {
+    next_id: std::cell::Cell<u64>,
+    edits: RefCell<Vec<(u64, StagedEdit)>>,
+}
+
+impl StagedEdits {
+    pub fn stage(self: &Rc<Self>, edit: StagedEdit) -> Staged {
+        let id = self.next_id.get();
+        self.next_id.set(id + 1);
+        self.edits.borrow_mut().push((id, edit));
+        Staged {
+            id,
+            edits: Rc::downgrade(self),
+        }
+    }
+
+    pub fn pending(&self) -> Vec<StagedEdit> {
+        self.edits.borrow().iter().map(|x| x.1.clone()).collect()
+    }
+}
+
+/// Keeps one [`StagedEdit`] visible to the UI until its op leaves the queue.
+pub struct Staged {
+    id: u64,
+    edits: std::rc::Weak<StagedEdits>,
+}
+
+impl Drop for Staged {
+    fn drop(&mut self) {
+        if let Some(edits) = self.edits.upgrade() {
+            edits.edits.borrow_mut().retain(|x| x.0 != self.id);
+        }
+    }
+}
+
+/// `bucket` with every pending bucket edit applied, in the order made.
+pub(super) fn project_bucket(
+    mut bucket: PluginScopedConfig,
+    pending: Vec<StagedEdit>,
+) -> PluginScopedConfig {
+    for edit in pending {
+        match edit {
+            StagedEdit::PluginField(update) => {
+                for key in &update.keys {
+                    match update.value.get(key) {
+                        Some(value) => {
+                            bucket.plugin.insert(key.clone(), value.clone());
+                        },
+                        None => {
+                            bucket.plugin.remove(key);
+                        },
+                    }
+                }
+            },
+            StagedEdit::ColumnField { column, update } => {
+                let entry = bucket.columns.entry(column.clone()).or_default();
+                for key in &update.keys {
+                    entry.remove(key);
+                }
+
+                for (key, value) in update.value {
+                    if update.keys.contains(&key) {
+                        entry.insert(key, value);
+                    }
+                }
+
+                if entry.is_empty() {
+                    bucket.columns.remove(&column);
+                }
+            },
+            StagedEdit::PluginConfig(map) => bucket.plugin.extend(map),
+            StagedEdit::Theme(_) => {},
+        }
+    }
+
+    bucket
+}

package/src/rust/renderer.rs

@@ -25,6 +25,7 @@ mod plugin_store;
 mod props;
 mod registry;
 mod render_timer;
+mod state;
 
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
@@ -32,7 +33,7 @@ use std::ops::Deref;
 use std::rc::Rc;
 
 use perspective_client::ViewWindow;
-use perspective_js::utils::{ApiFuture, ApiResult, JsValueSerdeExt};
+use perspective_js::utils::{ApiError, ApiFuture, ApiResult, JsValueSerdeExt};
 use wasm_bindgen::prelude::*;
 use web_sys::*;
 use yew::html::ImplicitClone;
@@ -40,11 +41,16 @@ use yew::prelude::*;
 
 use self::activate::*;
 pub use self::limits::RenderLimits;
-pub use self::plugin_config::{ColumnConfigMap, PluginScopedConfig};
+pub use self::plugin_config::{
+    ColumnConfigMap, ColumnRole, PluginScopedConfig, PreparedRenderer, ValidatedColumnsConfig,
+    ValidatedPluginConfig,
+};
 use self::plugin_store::*;
 pub use self::props::RendererProps;
 pub use self::registry::*;
 use self::render_timer::*;
+pub use self::state::{PluginRef, RenderError, RendererState, Staged, StagedEdit};
+use self::state::{RenderOutcome, StagedEdits, project_bucket};
 use crate::config::*;
 use crate::js::plugin::*;
 use crate::utils::*;
@@ -97,6 +103,13 @@ impl Drop for ContextPin {
 
 /// Immutable state
 pub struct RendererData {
+    state: RefCell<Rc<RendererState>>,
+    outcome: RefCell<RenderOutcome>,
+
+    /// Injected callback from the root component, fired when a render failure
+    /// is raised or cleared.
+    pub on_render_failure_changed: RefCell<Option<Callback<()>>>,
+    staged: Rc<StagedEdits>,
     plugin_data: RefCell<RendererMutData>,
     draw_lock: DebounceMutex,
     pub plugin_changed: PubSub<JsPerspectiveViewerPlugin>,
@@ -151,20 +164,12 @@ pub struct RendererData {
     /// coexist there.
     slot_name: RefCell<Option<String>>,
 
-    /// This panel's theme name — CONCRETE, resolved once at creation from
-    /// the config's `theme`, else the host's, else the registry default.
-    /// There is no "unthemed panel" that resolves against live element
-    /// state at draw time: a registry re-ordering must never repaint a
-    /// panel, so nothing but an explicit write may change this. `None` only
-    /// while no themes exist at all.
-    theme: RefCell<Option<String>>,
-
     /// Whether the active plugin has completed a draw. An EXPLICIT flag —
     /// not inferred from DOM connectedness — because plugin elements may be
     /// mounted eagerly (at panel creation / draw start, before the view
     /// query resolves), so "in the DOM" no longer implies "has rendered".
     /// Set by a successful `draw_view`; cleared on plugin swap
-    /// (`commit_plugin_idx`), `dispose` and `delete`.
+    /// (`activate_committed_plugin`), `dispose` and `delete`.
     has_drawn: Cell<bool>,
 
     /// The effective theme stamped at the active plugin's last `--psp-*`
@@ -210,12 +215,9 @@ pub struct RendererData {
 /// Mutable state
 pub struct RendererMutData {
     viewer_elem: HtmlElement,
-    metadata: Rc<PluginStaticConfig>,
     plugin_store: PluginStore,
-    plugins_idx: Option<usize>,
     timer: MovingWindowRenderTimer,
     selection: Option<ViewWindow>,
-    plugin_states: HashMap<String, PluginScopedConfig>,
 }
 
 /// The state object responsible for the active [`JsPerspectiveViewerPlugin`].
@@ -250,14 +252,15 @@ impl Renderer {
     pub fn new(viewer_elem: &HtmlElement) -> Self {
         let draw_lock = DebounceMutex::default();
         Self(Rc::new(RendererData {
+            state: RefCell::default(),
+            outcome: RefCell::default(),
+            on_render_failure_changed: RefCell::default(),
+            staged: Rc::default(),
             plugin_data: RefCell::new(RendererMutData {
                 viewer_elem: viewer_elem.clone(),
-                metadata: Rc::new(PluginStaticConfig::default()),
                 plugin_store: PluginStore::default(),
-                plugins_idx: None,
                 selection: None,
                 timer: MovingWindowRenderTimer::default(),
-                plugin_states: HashMap::default(),
             }),
             geometry_slot: draw_lock.slot(),
             geometry_cmd: Cell::new(None),
@@ -274,7 +277,6 @@ impl Renderer {
             presized_box: Cell::new(None),
             on_render_limits_changed: Default::default(),
             slot_name: Default::default(),
-            theme: Default::default(),
             has_drawn: Cell::new(false),
             captured_theme: Default::default(),
             cached_context: Default::default(),
@@ -297,26 +299,83 @@ impl Renderer {
         self.0.slot_name.borrow().clone()
     }
 
-    /// Set this panel's theme name. Callers must pass a CONCRETE name —
-    /// resolve "the default" through `Presentation` before calling, never by
-    /// leaving this empty.
-    pub fn set_theme(&self, name: Option<String>) {
-        *self.0.theme.borrow_mut() = name;
+    /// Write this panel's concrete theme name.
+    pub fn commit_theme(&self, name: Option<String>) {
+        self.swap(self.state().with_theme(name));
     }
 
-    /// This panel's theme name.
-    pub fn theme(&self) -> Option<String> {
-        self.0.theme.borrow().clone()
+    /// The committed state, which is what a running step reads.
+    pub fn state(&self) -> Rc<RendererState> {
+        self.0.state.borrow().clone()
+    }
+
+    pub(crate) fn swap(&self, next: RendererState) {
+        *self.0.state.borrow_mut() = Rc::new(next);
+        self.set_outcome(RenderOutcome::Never);
+    }
+
+    /// The failure of the last draw, which stands until the next commit.
+    pub fn failure(&self) -> Option<RenderError> {
+        match &*self.0.outcome.borrow() {
+            RenderOutcome::Failed(error) => Some(error.clone()),
+            _ => None,
+        }
+    }
+
+    /// Record that the draw of the committed state failed.
+    pub fn fail(&self, error: ApiError) -> ApiResult<()> {
+        self.set_outcome(RenderOutcome::Failed(RenderError(error.clone())));
+        Err(error)
+    }
+
+    /// Record that the draw of the committed state landed.
+    pub fn landed(&self) {
+        self.set_outcome(RenderOutcome::Ok);
+    }
+
+    fn set_outcome(&self, next: RenderOutcome) {
+        let was_failed = self.failure().is_some();
+        let is_failed = matches!(next, RenderOutcome::Failed(_));
+        *self.0.outcome.borrow_mut() = next;
+        if was_failed != is_failed
+            && let Some(cb) = self.0.on_render_failure_changed.borrow().as_ref()
+        {
+            cb.emit(());
+        }
+    }
+
+    /// Show `edit` to the UI until the returned guard is dropped.
+    pub fn stage(&self, edit: StagedEdit) -> Staged {
+        self.0.staged.stage(edit)
+    }
+
+    fn projected_bucket(&self, name: &str) -> PluginScopedConfig {
+        project_bucket(self.state().bucket(name), self.0.staged.pending())
     }
 
-    /// [`Self::set_theme`] plus a synchronous [`Self::stamp_theme`] — the
-    /// shared "stamp-with-commit" head of every per-panel theme mutation
-    /// site.
-    pub fn set_theme_stamped(&self, theme: Option<String>) {
-        self.set_theme(theme);
+    /// [`Self::commit_theme`] plus a synchronous [`Self::stamp_theme`].
+    pub fn commit_theme_stamped(&self, theme: Option<String>) {
+        self.commit_theme(theme);
         self.stamp_theme(None);
     }
 
+    /// This panel's theme name, as the UI sees it: the committed theme, or the
+    /// latest pending pick.
+    pub fn theme(&self) -> Option<String> {
+        let pending = self
+            .0
+            .staged
+            .pending()
+            .into_iter()
+            .filter_map(|edit| match edit {
+                StagedEdit::Theme(theme) => Some(theme),
+                _ => None,
+            })
+            .next_back();
+
+        pending.unwrap_or_else(|| self.state().theme.clone())
+    }
+
     /// Whether the active plugin's captured `--psp-*` CSS is STALE — the
     /// effective theme differs from the one stamped at the plugin's last
     /// CSS capture (first paint / last restyle).
@@ -376,17 +435,24 @@ impl Renderer {
             plugin.delete();
         }
         self.plugin_data.borrow().viewer_elem.set_inner_text("");
-        let new_state = Self::new(&self.plugin_data.borrow().viewer_elem);
-        std::mem::swap(
-            &mut *self.plugin_data.borrow_mut(),
-            &mut *new_state.plugin_data.borrow_mut(),
-        );
+        let viewer_elem = self.plugin_data.borrow().viewer_elem.clone();
+        *self.plugin_data.borrow_mut() = RendererMutData {
+            viewer_elem,
+            plugin_store: PluginStore::default(),
+            selection: None,
+            timer: MovingWindowRenderTimer::default(),
+        };
 
+        self.swap(self.state().without_plugins());
         Ok(())
     }
 
     pub fn metadata(&self) -> Rc<PluginStaticConfig> {
-        self.borrow().metadata.clone()
+        self.state()
+            .plugin
+            .as_ref()
+            .map(|plugin| plugin.static_config.clone())
+            .unwrap_or_default()
     }
 
     pub fn is_chart(&self) -> bool {
@@ -438,9 +504,9 @@ impl Renderer {
     /// permanently pins the per-renderer store to the built-in `Debug`
     /// (init-order race, surfaces on Safari).
     pub fn active_plugin(&self) -> Option<JsPerspectiveViewerPlugin> {
-        // Bail on `plugins_idx` BEFORE touching `plugin_store`, so an unselected
-        // renderer never snapshots the registry.
-        let idx = self.0.borrow().plugins_idx?;
+        // Bail on `plugins_idx` BEFORE touching `plugin_store`, so an
+        // unselected renderer never snapshots the registry.
+        let idx = self.selected_idx()?;
         self.0.borrow_mut().plugin_store.plugins().get(idx).cloned()
     }
 
@@ -488,6 +554,30 @@ impl Renderer {
     /// empty panel frame. NOTE eager mounting is exactly why
     /// [`Self::is_plugin_activated`] must be an explicit has-drawn flag, not
     /// DOM-connectedness.
+    /// Rename this renderer's slot (and its mounted light-DOM elements'
+    /// `slot` attributes) ahead of an eject whose slot name a replacement
+    /// panel reuses, so the async [`Self::dispose`] sweep cannot remove the
+    /// successor's elements.
+    pub fn retire_slot(&self) {
+        let Some(slot) = self.slot_name() else {
+            return;
+        };
+
+        let viewer = self.0.borrow().viewer_elem.clone();
+        let slots = [slot.clone(), format!("statusbar-extra-{slot}")];
+        let children = viewer.children();
+        for idx in 0..children.length() {
+            if let Some(el) = children.item(idx)
+                && let Some(s) = el.get_attribute("slot")
+                && slots.contains(&s)
+            {
+                let _ = el.set_attribute("slot", &format!("{s}-retired"));
+            }
+        }
+
+        self.set_slot_name(&format!("{slot}-retired"));
+    }
+
     pub fn mount_active_plugin(&self) -> ApiResult<()> {
         if let Some(plugin) = self.active_plugin() {
             let viewer_elem = self.0.borrow().viewer_elem.clone();
@@ -556,7 +646,7 @@ impl Renderer {
 
         let idx = self.find_plugin_idx(name)?;
         let changed = !matches!(
-            self.0.borrow().plugins_idx,
+            self.selected_idx(),
             Some(selected_idx) if selected_idx == idx
         );
 
@@ -574,6 +664,24 @@ impl Renderer {
         }
     }
 
+    /// Reject a [`PluginUpdate`] naming a plugin that is not registered.
+    pub fn check_plugin_update(&self, update: &PluginUpdate) -> ApiResult<()> {
+        if let PluginUpdate::Update(name) = update
+            && self.find_plugin_idx(name).is_none()
+        {
+            let known = self
+                .get_all_plugin_configs()
+                .iter()
+                .map(|c| format!("\"{}\"", c.name))
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            return Err(format!("Unknown plugin \"{name}\"; expected one of {known}").into());
+        }
+
+        Ok(())
+    }
+
     /// Commit a plugin selection previously resolved by
     /// [`Self::resolve_plugin_update`]. COMMAND — call only from inside a
     /// locked draw task, so the swap lands atomically with the view rebuild
@@ -586,7 +694,7 @@ impl Renderer {
         let idx = match idx {
             Some(idx) => idx,
             None => {
-                if self.0.borrow().plugins_idx.is_none() {
+                if self.selected_idx().is_none() {
                     let name = PLUGIN_REGISTRY.default_plugin_name();
                     let idx = self
                         .find_plugin_idx(&name)
@@ -600,7 +708,7 @@ impl Renderer {
         };
 
         let changed = !matches!(
-            self.0.borrow().plugins_idx,
+            self.selected_idx(),
             Some(selected_idx) if selected_idx == idx
         );
 
@@ -616,12 +724,6 @@ impl Renderer {
     /// reset the per-plugin render-warning flag, and fire
     /// `plugin_changed`.
     fn commit_plugin_idx(&self, idx: usize) -> ApiResult<()> {
-        // The newly-selected plugin element has not drawn (a swap keeps the
-        // OLD plugin mounted until the new one's draw lands) — and has
-        // captured no CSS.
-        self.0.has_drawn.set(false);
-        self.0.captured_theme.borrow_mut().take();
-        self.borrow_mut().plugins_idx = Some(idx);
         let config = self
             .0
             .borrow_mut()
@@ -631,22 +733,46 @@ impl Renderer {
             .cloned()
             .ok_or("No Plugin")?;
 
-        self.borrow_mut().metadata = config.clone();
+        self.swap(self.state().with_plugin(PluginRef {
+            idx,
+            static_config: config,
+        }));
+
+        self.activate_committed_plugin()
+    }
+
+    /// The `static_config` of the plugin at store index `idx`, for a
+    /// [`PluginRef`] committed by a transaction rather than by
+    /// [`Self::commit_plugin`].
+    pub fn plugin_ref(&self, idx: usize) -> ApiResult<PluginRef> {
+        let static_config = self
+            .0
+            .borrow_mut()
+            .plugin_store
+            .plugin_configs()
+            .get(idx)
+            .cloned()
+            .ok_or("No Plugin")?;
+
+        Ok(PluginRef { idx, static_config })
+    }
+
+    /// Bring the plugin ELEMENT in line with a just-committed selection: the
+    /// newly-selected element has drawn nothing and captured no CSS, takes its
+    /// own stored bucket, and is announced.
+    pub fn activate_committed_plugin(&self) -> ApiResult<()> {
+        // The newly-selected plugin element has not drawn (a swap keeps the
+        // OLD plugin mounted until the new one's draw lands) — and has
+        // captured no CSS.
+        self.0.has_drawn.set(false);
+        self.0.captured_theme.borrow_mut().take();
         self.0.render_warning.set(true);
-        // `commit_plugin_idx` is called *by* the selection path, so it must use
-        // the pure query (never `ensure_plugin_selected`, which would recurse
-        // through `commit_plugin`). `plugins_idx` was just set above.
         let plugin: JsPerspectiveViewerPlugin = self.active_plugin().ok_or("No Plugin")?;
 
         // Push the newly-activated plugin's stored bucket through
         // `plugin.restore` so the swap immediately reflects any
         // viewer-owned per-column and plugin-level config.
-        let bucket = self
-            .borrow()
-            .plugin_states
-            .get(&config.name)
-            .cloned()
-            .unwrap_or_default();
+        let bucket = self.state().bucket(&self.metadata().name);
         let token = JsValue::from_serde_ext(&bucket.plugin).unwrap_or(JsValue::NULL);
         if let Err(e) = plugin.restore(&token, Some(&bucket.columns)) {
             tracing::warn!("plugin.restore on swap failed: {:?}", e);
@@ -656,6 +782,20 @@ impl Renderer {
         Ok(())
     }
 
+    /// The committed plugin selection's index into the plugin store.
+    pub fn committed_plugin_idx(&self) -> Option<usize> {
+        self.selected_idx()
+    }
+
+    /// The COMMITTED panel theme, pending theme edits excluded.
+    pub fn committed_theme(&self) -> Option<String> {
+        self.state().theme.clone()
+    }
+
+    fn selected_idx(&self) -> Option<usize> {
+        self.state().plugin.as_ref().map(|plugin| plugin.idx)
+    }
+
     pub fn render_timer(&self) -> MovingWindowRenderTimer {
         self.0.borrow().timer.clone()
     }
@@ -710,6 +850,7 @@ impl Renderer {
                 is_chart,
                 plugin_config,
                 columns_config,
+                render_error: self.failure(),
             }
         } else {
             RendererProps {
@@ -720,6 +861,7 @@ impl Renderer {
                 is_chart: false,
                 plugin_config: PtrEqRc::default(),
                 columns_config: PtrEqRc::default(),
+                render_error: self.failure(),
             }
         }
     }