@perspective-dev/viewer 4.5.0 → 4.5.1

package/src/css/viewer.css

@@ -16,10 +16,88 @@
     --psp--color: #ff0000;
 }
 
+/* Shift-key affordance: while the user holds Shift, any mask-image icon
+ * tagged `.shift-alt-icon` recolors to advertise that a Shift-modified
+ * action is available on the underlying control. `!important` is required
+ * to beat per-icon ID-scoped `background-color` rules. */
+:host(.shift-active) .shift-alt-icon {
+    background-color: var(
+        --shift-active--color,
+        var(--psp-datagrid--pos-cell--color, #1078d1)
+    ) !important;
+}
+
+:host(.shift-active) {
+    #sub-columns {
+        .is_column_active.toggle-mode {
+            -webkit-mask-image: var(--psp-icon--radio-off--mask-image);
+            mask-image: var(--psp-icon--radio-off--mask-image);
+
+            &:before {
+                content: var(--psp-icon--radio-off--mask-image);
+            }
+
+            &:hover {
+                -webkit-mask-image: var(--psp-icon--radio-hover--mask-image);
+                mask-image: var(--psp-icon--radio-hover--mask-image);
+            }
+        }
+
+        .is_column_active.select-mode {
+            -webkit-mask-image: var(--psp-icon--checkbox-off--mask-image);
+            mask-image: var(--psp-icon--checkbox-off--mask-image);
+
+            &:before {
+                content: var(--psp-icon--checkbox-off--mask-image);
+            }
+
+            &:hover {
+                -webkit-mask-image: var(--psp-icon--checkbox-hover--mask-image);
+                mask-image: var(--psp-icon--checkbox-hover--mask-image);
+            }
+        }
+    }
+
+    #active-columns {
+        .is_column_active.toggle-mode {
+            -webkit-mask-image: var(--psp-icon--radio-on--mask-image);
+            mask-image: var(--psp-icon--radio-on--mask-image);
+
+            &:before {
+                content: var(--psp-icon--radio-on--mask-image);
+            }
+
+            &:not(.required):hover {
+                -webkit-mask-image: var(--psp-icon--radio-hover--mask-image);
+                mask-image: var(--psp-icon--radio-hover--mask-image);
+            }
+        }
+
+        .is_column_active.select-mode {
+            -webkit-mask-image: var(--psp-icon--checkbox-on--mask-image);
+            mask-image: var(--psp-icon--checkbox-on--mask-image);
+
+            &:before {
+                content: var(--psp-icon--checkbox-on--mask-image);
+            }
+
+            &:not(.required):hover {
+                -webkit-mask-image: var(--psp-icon--checkbox-hover--mask-image);
+                mask-image: var(--psp-icon--checkbox-hover--mask-image);
+            }
+        }
+    }
+}
+
 ::slotted(*) {
     pointer-events: var(--override-content-pointer-events);
 }
 
+:host input[type="number"]::-webkit-inner-spin-button {
+    transform: scale(1.5); /* Makes the arrows 50% larger */
+    filter: invert(1);
+}
+
 :host .sidebar_close_button {
     position: absolute;
     top: 0;
@@ -398,13 +476,13 @@
             cursor: pointer;
             padding: 6px 8px;
             font-size: var(--label--font-size, 0.75em);
+            text-transform: uppercase;
             flex: 0 1 100px;
             background-color: #00000020;
             border-bottom: 1px solid var(--psp-inactive--color);
             color: var(--psp-inactive--color);
             margin-left: -1px;
             border-left: 1px solid var(--psp-inactive--color);
-
             &:hover {
                 color: inherit;
             }

package/src/rust/components/column_selector/active_column.rs

@@ -355,6 +355,9 @@ impl Component for ActiveColumn {
                 if is_required {
                     class.push("required");
                 };
+                if !is_required {
+                    class.push("shift-alt-icon");
+                }
                 html! {
                     <div
                         class={outer_classes}

package/src/rust/components/column_selector/inactive_column.rs

@@ -149,7 +149,8 @@ impl Component for InactiveColumn {
 
         let is_expression = ctx.props().is_expression;
 
-        let is_active_class = ctx.props().renderer.metadata().select_mode.css();
+        let mut is_active_class = ctx.props().renderer.metadata().select_mode.css();
+        is_active_class.push("shift-alt-icon");
         let mut class = classes!("column-selector-column");
         if !ctx.props().visible {
             class.push("column-selector-column-hidden");

package/src/rust/components/column_settings_sidebar/style_tab/primitive_field.rs

@@ -160,6 +160,7 @@ pub fn BoolField(props: &BoolFieldProps) -> Html {
                 <div class="bool-field-container">
                     <input
                         type="checkbox"
+                        class="alternate"
                         id={format!("{}-checkbox", props.field_key)}
                         checked={current}
                         {oninput}

package/src/rust/components/column_settings_sidebar.rs

@@ -264,6 +264,7 @@ impl Component for ColumnSettingsPanel {
                     ctx.props().selected_tab,
                     Some(ColumnSettingsTab::Attributes)
                 ),
+            update_on_input: true,
             icon_type: self
                 .maybe_ty
                 .map(|ty| ty.into())

package/src/rust/components/containers/dragdrop_list.rs

@@ -193,6 +193,12 @@ where
             }
         });
 
+        // Held by per-row `ondragenter` closures below so they can re-arm
+        // the `safaridragleave` flag on the container element when the
+        // row stops dragenter from bubbling. See the comment inside the
+        // closure for why this matters.
+        let container_noderef = drag_container.noderef.clone();
+
         let invalid_drag: bool;
         let mut valid_duplicate_drag = false;
 
@@ -253,9 +259,30 @@ where
                     let close = ctx.props().parent.callback(move |_| V::close(idx));
                     let dragenter = ctx.props().parent.callback({
                         let link = ctx.link().clone();
+                        let container_noderef = container_noderef.clone();
                         move |event: DragEvent| {
                             event.stop_propagation();
                             event.prevent_default();
+                            // Safari: `relatedTarget` is always null on
+                            // dragleave, so `dragleave_helper` uses a
+                            // `data-safaridragleave` flag set by the
+                            // container's own dragenter to distinguish
+                            // child-crossing leaves (consume the flag)
+                            // from real leaves (no flag → fire callback).
+                            // The `stop_propagation` above blocks the
+                            // container's dragenter, so the flag would
+                            // never be re-armed after the first consume —
+                            // any further internal boundary crossing
+                            // would demote the state out of
+                            // `DragOverInProgress` and the next drop
+                            // would be silently rejected. Set the flag
+                            // here so each row-targeted dragenter
+                            // refills the pool.
+                            if event.related_target().is_none()
+                                && let Some(elem) = container_noderef.cast::<HtmlElement>()
+                            {
+                                let _ = elem.dataset().set("safaridragleave", "true");
+                            }
                             link.send_message(DragDropListMsg::Freeze(true));
                             V::dragenter(idx)
                         }

package/src/rust/components/editable_header.rs

@@ -28,9 +28,13 @@ pub struct EditableHeaderProps {
     pub initial_value: Option<String>,
     pub placeholder: Rc<String>,
 
+    // TODO remove this pattern
     #[prop_or_default]
     pub reset_count: u8,
 
+    #[prop_or_default]
+    pub update_on_input: bool,
+
     /// Session metadata snapshot — threaded from `SessionProps`.
     pub metadata: SessionMetadataRc,
 
@@ -163,6 +167,16 @@ impl Component for EditableHeader {
             EditableHeaderMsg::SetNewValue(value)
         });
 
+        let update_on_input = ctx.props().update_on_input;
+        let oninput = ctx.link().batch_callback(move |e: yew::InputEvent| {
+            if update_on_input {
+                let value = e.target_unchecked_into::<HtmlInputElement>().value();
+                vec![EditableHeaderMsg::SetNewValue(value)]
+            } else {
+                vec![]
+            }
+        });
+
         html! {
             <div class={classes} onclick={ctx.link().callback(|_| EditableHeaderMsg::OnClick(()))}>
                 if let Some(icon) = ctx.props().icon_type { <TypeIcon ty={icon} /> }
@@ -173,6 +187,7 @@ impl Component for EditableHeader {
                     disabled={!ctx.props().editable}
                     {onblur}
                     {onkeyup}
+                    {oninput}
                     value={self.value.clone()}
                     placeholder={self.placeholder.clone()}
                 />

package/src/rust/components/status_bar.rs

@@ -377,7 +377,7 @@ impl Component for StatusBar {
                                 <div id="plugin-settings"><slot name="statusbar-extra" /></div>
                                 <span class="hover-target">
                                     <span id="reset" class="button" onmousedown={&onreset}>
-                                        <span class="icon" />
+                                        <span class="icon shift-alt-icon" />
                                         <span class="icon-label" />
                                     </span>
                                 </span>

package/src/rust/components/viewer.rs

@@ -14,7 +14,9 @@ use std::rc::Rc;
 
 use futures::channel::oneshot::*;
 use perspective_js::utils::*;
+use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
+use web_sys::{FocusEvent, KeyboardEvent};
 use yew::prelude::*;
 
 use super::containers::split_panel::SplitPanel;
@@ -121,6 +123,70 @@ pub struct PerspectiveViewer {
     /// Counts in-flight renders (incremented on `view_config_changed`,
     /// decremented on `view_created`). Threaded to `StatusIndicator`.
     update_count: u32,
+
+    /// Window listeners that toggle the `.shift-active` class on the host
+    /// element while the Shift key is held, making Shift-modified affordances
+    /// (e.g. inactive column add, active column remove, status-bar reset)
+    /// visually discoverable. Stored so the closures outlive `create`.
+    _shift_listeners: ShiftListeners,
+}
+
+struct ShiftListeners {
+    elem: web_sys::HtmlElement,
+    keydown: Closure<dyn FnMut(KeyboardEvent)>,
+    keyup: Closure<dyn FnMut(KeyboardEvent)>,
+    blur: Closure<dyn FnMut(FocusEvent)>,
+}
+
+impl Drop for ShiftListeners {
+    fn drop(&mut self) {
+        let win = global::window();
+        let _ = win
+            .remove_event_listener_with_callback("keydown", self.keydown.as_ref().unchecked_ref());
+        let _ =
+            win.remove_event_listener_with_callback("keyup", self.keyup.as_ref().unchecked_ref());
+        let _ = win.remove_event_listener_with_callback("blur", self.blur.as_ref().unchecked_ref());
+        let _ = self.elem.class_list().remove_1("shift-active");
+    }
+}
+
+fn install_shift_listeners(elem: web_sys::HtmlElement) -> ShiftListeners {
+    let keydown = {
+        let elem = elem.clone();
+        Closure::wrap(Box::new(move |event: KeyboardEvent| {
+            if event.key() == "Shift" {
+                let _ = elem.class_list().add_1("shift-active");
+            }
+        }) as Box<dyn FnMut(KeyboardEvent)>)
+    };
+
+    let keyup = {
+        let elem = elem.clone();
+        Closure::wrap(Box::new(move |event: KeyboardEvent| {
+            if event.key() == "Shift" {
+                let _ = elem.class_list().remove_1("shift-active");
+            }
+        }) as Box<dyn FnMut(KeyboardEvent)>)
+    };
+
+    let blur = {
+        let elem = elem.clone();
+        Closure::wrap(Box::new(move |_: FocusEvent| {
+            let _ = elem.class_list().remove_1("shift-active");
+        }) as Box<dyn FnMut(FocusEvent)>)
+    };
+
+    let win = global::window();
+    let _ = win.add_event_listener_with_callback("keydown", keydown.as_ref().unchecked_ref());
+    let _ = win.add_event_listener_with_callback("keyup", keyup.as_ref().unchecked_ref());
+    let _ = win.add_event_listener_with_callback("blur", blur.as_ref().unchecked_ref());
+
+    ShiftListeners {
+        elem,
+        keydown,
+        keyup,
+        blur,
+    }
 }
 
 impl Component for PerspectiveViewer {
@@ -160,6 +226,8 @@ impl Component for PerspectiveViewer {
             });
         }
 
+        let shift_listeners = install_shift_listeners(elem);
+
         Self {
             _subscriptions: subscriptions,
             column_settings_panel_width_override: None,
@@ -178,6 +246,7 @@ impl Component for PerspectiveViewer {
             presentation_props,
             dragdrop_props: DragDropProps::default(),
             update_count: 0,
+            _shift_listeners: shift_listeners,
         }
     }
 
@@ -548,8 +617,15 @@ impl Component for PerspectiveViewer {
                             skip_empty=true
                             initial_size={self.settings_panel_width_override}
                             on_reset={ctx.link().callback(|_| SettingsPanelSizeUpdate(None))}
-                            on_resize={on_split_panel_resize.clone()}
-                            on_resize_finished={render_callback(&ctx.props().session, &ctx.props().renderer)}
+                            on_resize={{
+                                let size_cb = on_split_panel_resize.clone();
+                                let resize_cb = resize_callback(&ctx.props().session, &ctx.props().renderer);
+                                move |x| {
+                                    size_cb.emit(x);
+                                    resize_cb.emit(());
+                                }
+                            }}
+                            on_resize_finished={resize_callback(&ctx.props().session, &ctx.props().renderer)}
                         >
                             { settings_panel }
                             <div id="main_column_container">

package/src/rust/renderer.rs

@@ -31,11 +31,10 @@ use std::ops::Deref;
 use std::pin::Pin;
 use std::rc::Rc;
 
-use futures::future::select_all;
+use futures::future::{join_all, select_all};
 use perspective_client::config::ViewConfig;
 use perspective_client::utils::*;
 use perspective_client::{View, ViewWindow};
-use perspective_js::json;
 use perspective_js::utils::{ApiResult, JsValueSerdeExt, ResultTApiErrorExt};
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
@@ -52,6 +51,7 @@ pub use self::registry::*;
 use self::render_timer::*;
 use crate::config::*;
 use crate::js::plugin::*;
+use crate::queries::resolve_abs_max;
 use crate::session::Session;
 use crate::utils::*;
 
@@ -169,15 +169,6 @@ impl Renderer {
         }))
     }
 
-    pub async fn reset(&self, columns_config: Option<&ColumnConfigMap>) -> ApiResult<()> {
-        self.0.borrow_mut().plugins_idx = None;
-        if let Ok(plugin) = self.get_active_plugin() {
-            plugin.restore(&json!({}), columns_config)?;
-        }
-
-        Ok(())
-    }
-
     pub fn delete(&self) -> ApiResult<()> {
         self.get_active_plugin().map(|x| x.delete()).unwrap_or_log();
         self.plugin_data.borrow().viewer_elem.set_inner_text("");
@@ -239,12 +230,69 @@ impl Renderer {
     /// `include` fields off other fields (e.g. Datagrid's
     /// `fg_gradient` revealed when `number_fg_mode = "bar"`) will
     /// reach the plugin without their default value populated.
-    pub fn all_columns_configs_materialized(
+    ///
+    /// `async` because per-column stats (e.g. `abs_max` for Datagrid's
+    /// `fg_gradient`) may need to be fetched before the schema's
+    /// `default` is meaningful. Pass 1 sync-scans the schema for any
+    /// column whose `include: true` Number key is missing from its
+    /// entry AND has no cached stats — `view_config_changed` clears the
+    /// stats cache, so "missing in cache" subsumes "stale". Pass 2
+    /// blocks on a parallel `resolve_abs_max` for that set, then runs
+    /// the materialize loop with the now-warm cache. Columns never
+    /// touched in a stats-dependent mode never trigger a fetch.
+    pub async fn all_columns_configs_materialized(
         &self,
         view_config: &ViewConfig,
         session: &Session,
     ) -> ColumnConfigMap {
         let mut configs = self.all_columns_configs();
+
+        // Pass 1: identify columns whose schema demands an `include:
+        // true` Number default we don't have stats for.
+        let mut to_warm: Vec<String> = vec![];
+        for (col, entry) in &configs {
+            if session
+                .get_column_stats(col)
+                .and_then(|s| s.abs_max)
+                .is_some()
+            {
+                continue;
+            }
+            let Ok(schema) =
+                self.query_column_config_schema(view_config, session, col, Some(entry))
+            else {
+                continue;
+            };
+            let needs_warm = schema.fields.iter().any(|f| {
+                matches!(
+                    f,
+                    ControlSpec::Number {
+                        key,
+                        include: Some(true),
+                        ..
+                    } if !entry.contains_key(key)
+                )
+            });
+            if needs_warm {
+                to_warm.push(col.clone());
+            }
+        }
+
+        // Block on the (typically tiny) warm set. Clone the metadata
+        // and resolve the view ref *before* the .await — `metadata()`
+        // returns a live `Ref<>` guard that must not cross an await
+        // boundary.
+        if !to_warm.is_empty() {
+            let metadata = session.metadata().clone();
+            let view = session.get_view();
+            let futs = to_warm
+                .iter()
+                .map(|c| resolve_abs_max(session, &metadata, view.as_ref(), c.as_str()));
+            join_all(futs).await;
+        }
+
+        // Pass 2: materialize. With stats now in cache, the schema
+        // returns a real `default` instead of the placeholder `0`.
         for (col, entry) in &mut configs {
             let Ok(schema) =
                 self.query_column_config_schema(view_config, session, col, Some(entry))
@@ -345,6 +393,8 @@ impl Renderer {
                         if let Ok(schema) =
                             self.query_column_config_schema(view_config, session, &col, Some(&cfg))
                         {
+                            let active = schema.active_keys();
+                            cfg.retain(|k, _| active.contains(k));
                             strip_default_values(&schema, &mut cfg);
                         }
 
@@ -468,13 +518,15 @@ impl Renderer {
     /// the columns-config write paths (strip-on-write) and the
     /// restore-prep snapshot (materialize-on-read).
     ///
-    /// Reads the cached `ColumnStats` (populated by the StyleTab's
-    /// `fetch_column_abs_max` task and cleared on `view_config_changed`)
+    /// Reads the cached `ColumnStats` (cleared on `view_config_changed`)
     /// so plugins emit gradient defaults against the column's current
-    /// `abs_max` instead of falling back to `0`. Cache cold ⇒ stats
-    /// pass through as missing and the plugin uses its `?? 0` fallback;
-    /// `include: true` fields are still preserved via
-    /// [`matches_declared_default`]'s short-circuit.
+    /// `abs_max` instead of falling back to `0`.
+    /// [`Self::all_columns_configs_materialized`] warms the cache on
+    /// demand before materializing `include: true` Number fields, so
+    /// the restore path always observes a real default; sync callers
+    /// (column-config strip-on-write) may still see a missing stats
+    /// pass-through and the plugin's `?? 0` fallback, but those writes
+    /// re-strip on the next render cycle.
     fn query_column_config_schema(
         &self,
         view_config: &ViewConfig,
@@ -549,6 +601,8 @@ impl Renderer {
             OptionalUpdate::Update(mut map) => {
                 let mut changed = false;
                 if let Some(s) = &schema {
+                    let active = s.active_keys();
+                    map.retain(|k, _| active.contains(k));
                     // Default-valued entries in a restore payload
                     // semantically reset the key — strip from the
                     // map AND clear any existing override in the

package/src/rust/tasks/reset_all.rs

@@ -11,13 +11,17 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 //! Cross-engine reset orchestration: reset session config, optionally clear
-//! presentation columns config / theme, reset the renderer plugin state, and
-//! redraw.
+//! presentation columns config / theme, then delegate to `restore_and_render`
+//! to switch back to the default plugin and redraw.
 
 use futures::channel::oneshot;
 use perspective_client::clone;
 use perspective_js::utils::ApiFuture;
 
+use super::restore_and_render;
+use crate::config::{
+    ColumnConfigUpdate, OptionalUpdate, PluginConfigUpdate, PluginUpdate, ViewerConfigUpdate,
+};
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
 use crate::session::{ResetOptions, Session};
@@ -30,6 +34,12 @@ use crate::session::{ResetOptions, Session};
 ///
 /// Optionally signals `sender` once the reset+redraw round-trip completes,
 /// then emits `renderer.reset_changed`.
+///
+/// Delegates plugin selection + draw to [`restore_and_render`], whose
+/// two-pass restore guarantees the default plugin sees materialized
+/// `columns_config` / `plugin_config` on its first draw — fixing a race
+/// where the raw post-reset bucket would reach the plugin before
+/// stats-dependent `include: true` defaults were resolved.
 pub fn reset_all(
     session: &Session,
     renderer: &Renderer,
@@ -47,32 +57,42 @@ pub fn reset_all(
                 ..ResetOptions::default()
             })
             .await?;
-        let columns_config = if all {
-            renderer.reset_columns_configs();
-            renderer.reset_plugin_config();
-            // Mirror the per-plugin bucket clear on the event bus so
-            // `PluginTab` re-pulls (its props are interior-mutable
-            // handles whose identity doesn't change on the reset).
-            renderer
-                .plugin_config_changed
-                .emit(renderer.get_plugin_config());
-            None
-        } else {
-            Some(renderer.all_columns_configs())
-        };
 
-        renderer.reset(columns_config.as_ref()).await?;
         presentation.reset_available_themes(None).await;
         if all {
             presentation.reset_theme().await?;
         }
 
-        let result = renderer.draw(session.validate().await?.create_view()).await;
+        // For `all = true`, route the bucket clears through `restore_and_render`'s
+        // `update_*` paths as `SetDefault`. This guarantees the materialized
+        // restore fires even when the user is already on the default plugin
+        // (no plugin_swap signal), since `SetDefault` reports the bucket as
+        // `changed` when it was non-empty. The per-plugin bucket model means
+        // only the (post-swap) default plugin's bucket is cleared; other
+        // plugins' buckets persist with their per-plugin state.
+        let (columns_config, plugin_config) = if all {
+            (
+                ColumnConfigUpdate::SetDefault,
+                PluginConfigUpdate::SetDefault,
+            )
+        } else {
+            (OptionalUpdate::Missing, OptionalUpdate::Missing)
+        };
+
+        let update = ViewerConfigUpdate {
+            plugin: PluginUpdate::SetDefault,
+            plugin_config,
+            columns_config,
+            ..Default::default()
+        };
+
+        restore_and_render(&session, &renderer, &presentation, update, async { Ok(()) }).await?;
+
         if let Some(sender) = sender {
             sender.send(()).unwrap();
         }
 
         renderer.reset_changed.emit(());
-        result
+        Ok(())
     })
 }

package/src/rust/tasks/restore_and_render.rs

@@ -86,6 +86,22 @@ pub fn restore_and_render(
             let plugin_swapped = renderer.apply_pending_plugin()?;
             let plugin = renderer.get_active_plugin()?;
 
+            // The previous call which acquired the lock errored, so skip this render
+            if let Some(error) = session.get_error() {
+                return Err(error);
+            }
+
+            // Validate + create the view BEFORE applying
+            // columns_config / plugin_config updates, so the
+            // strip-on-write and materialize passes see fresh
+            // `expression_schema` and `view_schema`, and the
+            // materialize warm step can call `View::get_min_max`
+            // against a view that knows about any new expression
+            // columns. Previously this happened after the strip,
+            // which silently dropped any `columns_config` entry
+            // keyed by a new expression column.
+            let view = session.validate().await?.create_view().await?;
+
             // Apply incoming updates into the now-active plugin's
             // bucket on `Renderer`. Per-plugin storage means no
             // schema filter is needed before restore — foreign keys
@@ -96,9 +112,9 @@ pub fn restore_and_render(
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
                 renderer.update_plugin_config(&view_config_snapshot, plugin_config);
-
-            let changed = plugin_config_changed
-                || renderer.update_columns_configs(&view_config_snapshot, &session, columns_config);
+            let columns_config_changed =
+                renderer.update_columns_configs(&view_config_snapshot, &session, columns_config);
+            let changed = plugin_config_changed || columns_config_changed;
 
             // Force a materialized restore when the plugin just
             // swapped — `commit_plugin_idx` already restored from the
@@ -109,24 +125,19 @@ pub fn restore_and_render(
                 let plugin_config_snapshot = renderer.get_plugin_config();
                 let plugin_update =
                     wasm_bindgen::JsValue::from_serde_ext(&plugin_config_snapshot).unwrap();
-                let columns_config =
-                    renderer.all_columns_configs_materialized(&view_config_snapshot, &session);
+                let columns_config = renderer
+                    .all_columns_configs_materialized(&view_config_snapshot, &session)
+                    .await;
                 plugin.restore(&plugin_update, Some(&columns_config))?;
                 if plugin_config_changed {
                     renderer.plugin_config_changed.emit(plugin_config_snapshot);
                 }
             }
 
-            // The previous call which acquired the lock errored, so skip this render
-            if let Some(error) = session.get_error() {
-                return Err(error);
-            }
-
-            let view = session.validate().await?.create_view().await;
             if !presentation.is_visible() {
                 Ok(None)
             } else {
-                view
+                Ok(view)
             }
         });
 

package/src/rust/tasks/send_column_config.rs

@@ -38,8 +38,9 @@ pub fn send_column_config(
     clone!(session, renderer);
     ApiFuture::spawn(async move {
         let view_config_snapshot = session.get_view_config().clone();
-        let columns_configs =
-            renderer.all_columns_configs_materialized(&view_config_snapshot, &session);
+        let columns_configs = renderer
+            .all_columns_configs_materialized(&view_config_snapshot, &session)
+            .await;
         let plugin_token =
             wasm_bindgen::JsValue::from_serde_ext(&renderer.get_plugin_config()).unwrap();
         renderer