@perspective-dev/viewer 4.5.0 → 4.5.2

package/src/rust/components/type_icon.rs

@@ -14,9 +14,6 @@ use perspective_client::config::ColumnType;
 use yew::html::IntoPropValue;
 use yew::{Properties, classes, function_component, html};
 
-use crate::components::style::LocalStyle;
-use crate::css;
-
 #[derive(PartialEq, Debug, Clone, Copy)]
 pub enum TypeIconType {
     Type(ColumnType),
@@ -31,7 +28,7 @@ pub struct TypeIconProps {
 #[function_component(TypeIcon)]
 pub fn type_icon(p: &TypeIconProps) -> yew::Html {
     let class = classes!(p.ty.to_string(), "type-icon");
-    html! { <><LocalStyle href={css!("type-icon")} /><span {class} /></> }
+    html! { <><span {class} /></> }
 }
 
 impl From<ColumnType> for TypeIconType {

package/src/rust/components/viewer.rs

@@ -14,17 +14,18 @@ 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;
 use super::font_loader::{FontLoader, FontLoaderProps, FontLoaderStatus};
-use super::style::{LocalStyle, StyleProvider};
+use super::style::StyleProvider;
 use crate::components::column_settings_sidebar::ColumnSettingsPanel;
 use crate::components::main_panel::MainPanel;
 use crate::components::settings_panel::{SelectedTab, SettingsPanel};
 use crate::config::*;
-use crate::css;
 use crate::js::JsPerspectiveViewerPlugin;
 use crate::presentation::{
     ColumnLocator, ColumnSettingsTab, DragDropProps, Presentation, PresentationProps,
@@ -121,6 +122,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 +225,8 @@ impl Component for PerspectiveViewer {
             });
         }
 
+        let shift_listeners = install_shift_listeners(elem);
+
         Self {
             _subscriptions: subscriptions,
             column_settings_panel_width_override: None,
@@ -178,6 +245,7 @@ impl Component for PerspectiveViewer {
             presentation_props,
             dragdrop_props: DragDropProps::default(),
             update_count: 0,
+            _shift_listeners: shift_listeners,
         }
     }
 
@@ -539,7 +607,6 @@ impl Component for PerspectiveViewer {
 
         html! {
             <StyleProvider root={ctx.props().elem.clone()}>
-                <LocalStyle href={css!("viewer")} />
                 <div id="component_container">
                     if is_settings_open {
                         <SplitPanel
@@ -548,8 +615,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/custom_elements/copy_dropdown.rs

@@ -22,7 +22,7 @@ use yew::prelude::*;
 use super::viewer::PerspectiveViewerElement;
 use crate::components::copy_dropdown::CopyDropDownMenu;
 use crate::components::portal::PortalModal;
-use crate::components::style::StyleProvider;
+use crate::components::style::{StyleProvider, StyleSurface};
 use crate::config::*;
 use crate::js::*;
 use crate::presentation::Presentation;
@@ -77,9 +77,13 @@ impl Component for CopyDropDownWrapper {
     fn view(&self, ctx: &Context<Self>) -> Html {
         let on_close = ctx.link().callback(|_| CopyDropDownWrapperMsg::Close);
         html! {
-            <StyleProvider root={ctx.props().custom_element.clone()}>
+            <StyleProvider
+                root={ctx.props().custom_element.clone()}
+                surface={StyleSurface::DropdownMenu}
+            >
                 <PortalModal
                     tag_name="perspective-copy-menu"
+                    surface={StyleSurface::DropdownMenu}
                     target={self.target.clone()}
                     own_focus=true
                     {on_close}

package/src/rust/custom_elements/export_dropdown.rs

@@ -22,7 +22,7 @@ use yew::prelude::*;
 use super::viewer::PerspectiveViewerElement;
 use crate::components::export_dropdown::ExportDropDownMenu;
 use crate::components::portal::PortalModal;
-use crate::components::style::StyleProvider;
+use crate::components::style::{StyleProvider, StyleSurface};
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::*;
@@ -77,9 +77,13 @@ impl Component for ExportDropDownWrapper {
     fn view(&self, ctx: &Context<Self>) -> Html {
         let on_close = ctx.link().callback(|_| ExportDropDownWrapperMsg::Close);
         html! {
-            <StyleProvider root={ctx.props().custom_element.clone()}>
+            <StyleProvider
+                root={ctx.props().custom_element.clone()}
+                surface={StyleSurface::DropdownMenu}
+            >
                 <PortalModal
                     tag_name="perspective-export-menu"
+                    surface={StyleSurface::DropdownMenu}
                     target={self.target.clone()}
                     own_focus=true
                     {on_close}

package/src/rust/lib.rs

@@ -20,7 +20,6 @@
 #![feature(stmt_expr_attributes)]
 #![feature(try_blocks)]
 #![allow(async_fn_in_trait)]
-#![feature(more_qualified_paths)]
 #![warn(
     clippy::all,
     clippy::panic_in_result_fn,

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,
@@ -492,6 +544,16 @@ impl Renderer {
             .and_then(|idx| names.get(idx))
             .map(|s| s.as_str());
 
+        // If the view schema itself hasn't been built yet (e.g. restore
+        // landed before `create_view` populated `view_schema`), refuse
+        // to answer rather than returning an empty schema. The strip
+        // pass in `update_columns_configs` treats `Err` as "leave the
+        // incoming cfg untouched"; an empty schema, by contrast, would
+        // cause `cfg.retain(|k, _| active.contains(k))` to drop every
+        // key and zero out user-supplied column config.
+        if !session.metadata().has_view_schema() {
+            return Err(JsValue::from("view_schema not initialized").into());
+        }
         let Some(view_type) = session.metadata().get_column_view_type(column_name) else {
             return Ok(ColumnConfigSchema { fields: vec![] });
         };
@@ -549,6 +611,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
@@ -986,7 +1050,7 @@ impl Renderer {
             }),
         ];
 
-        let (x, _, y) = select_all(tasks.into_iter()).await;
+        let (x, _, y) = select_all(tasks).await;
         x.ok_or_else(|| y.into_iter().next().unwrap())
     }
 
@@ -994,8 +1058,8 @@ impl Renderer {
     async fn resize_with_explicit_dimensions(&self) -> TaskResult {
         let plugin = self.get_active_plugin()?;
         let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
-        let new_width = format!("{}px", &self.0.borrow().viewer_elem.client_width());
-        let new_height = format!("{}px", &self.0.borrow().viewer_elem.client_height());
+        let new_width = format!("{}px", self.0.borrow().viewer_elem.client_width());
+        let new_height = format!("{}px", self.0.borrow().viewer_elem.client_height());
         main_panel.style().set_property("width", &new_width)?;
         main_panel.style().set_property("height", &new_height)?;
         let result = plugin.resize().await;

package/src/rust/session/metadata.rs

@@ -95,6 +95,16 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// Whether `view_schema` has been populated by a prior successful
+    /// `create_view`. Used by `Session::create_view` to force a full
+    /// build on first run even when `is_clean` happens to be true, so
+    /// that downstream consumers (`query_column_config_schema`,
+    /// strip-on-write in `update_columns_configs`) always see a real
+    /// view schema rather than `None`.
+    pub fn has_view_schema(&self) -> bool {
+        self.as_ref().and_then(|s| s.view_schema.as_ref()).is_some()
+    }
+
     pub(super) fn update_expressions(
         &mut self,
         valid_recs: &perspective_client::ExprValidationResult,
@@ -302,7 +312,7 @@ impl SessionMetadata {
                     Some(
                         self.get_expression_columns()
                             .cloned()
-                            .chain(self.get_table_columns()?.clone().into_iter())
+                            .chain(self.get_table_columns()?.clone())
                             .map(move |name| {
                                 self.get_column_table_type(&name)
                                     .map(|coltype| (name, coltype))

package/src/rust/session.rs

@@ -760,7 +760,20 @@ impl ValidSession<'_> {
     /// `update()` subscription, consuming this `ValidSession<'_>` and returning
     /// the original `&Session`.
     pub async fn create_view(&self) -> Result<Option<View>, ApiError> {
-        if !self.0.reset_clean() && !self.0.borrow().is_paused {
+        // Always consume `is_clean` to preserve the "mark up-to-date"
+        // contract of `reset_clean`. Force a full build if no view
+        // schema has been built yet — `query_column_config_schema` (and
+        // downstream `update_columns_configs`) needs a populated
+        // `view_schema` to avoid destructively stripping every key from
+        // incoming `columns_config` payloads. Without this fallback, a
+        // first restore that lands with `is_clean = true` (e.g., when a
+        // prior validate already consumed the flag) would skip the
+        // view-schema-building inner block, leaving the schema empty
+        // and causing strip-on-write to silently zero out
+        // user-supplied column config.
+        let was_clean = self.0.reset_clean();
+        let needs_schema = !self.0.metadata().has_view_schema();
+        if (!was_clean && !self.0.borrow().is_paused) || needs_schema {
             if !self.1 {
                 let config = self.0.borrow().config.clone();
                 if let Some(sub) = &mut self.0.borrow_mut().view_sub.as_mut() {

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

package/src/rust/tasks/send_plugin_config.rs

@@ -36,8 +36,9 @@ pub fn send_plugin_config(session: &Session, renderer: &Renderer, update: Column
             let plugin_config = renderer.get_plugin_config();
             let plugin_token = wasm_bindgen::JsValue::from_serde_ext(&plugin_config).unwrap();
             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;
             renderer
                 .get_active_plugin()?
                 .restore(&plugin_token, Some(&columns_configs))?;

package/src/rust/tasks/update_and_render.rs

@@ -78,6 +78,13 @@ async fn update_and_render_inner(session: Session, renderer: Renderer) -> ApiRes
     }
 
     let plugin_swapped = renderer.apply_pending_plugin()?;
+
+    // Validate + create the view BEFORE the plugin-swap materialize
+    // so the schema query sees fresh `expression_schema` /
+    // `view_schema` and `resolve_abs_max` has a bound view that
+    // knows about any new expression columns.
+    let view = session.validate().await?.create_view().await?;
+
     if plugin_swapped {
         // `commit_plugin_idx` already restored the new plugin from its
         // raw bucket; re-run with the materialized snapshot so any
@@ -91,13 +98,13 @@ async fn update_and_render_inner(session: Session, renderer: Renderer) -> ApiRes
         let view_config_snapshot = session.get_view_config().clone();
         let plugin_token = wasm_bindgen::JsValue::from_serde_ext(&renderer.get_plugin_config())
             .unwrap_or(wasm_bindgen::JsValue::NULL);
-        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;
         renderer
             .get_active_plugin()?
             .restore(&plugin_token, Some(&columns_config))?;
     }
 
-    let view = session.validate().await?;
-    renderer.draw(view.create_view()).await
+    renderer.draw(async { Ok(view) }).await
 }

package/src/svg/checkbox-checked-icon.svg

@@ -2,6 +2,6 @@
     <defs></defs>
     <path
         d="M 2 0 L 12 0 C 13.105 0 14 0.895 14 2 L 14 12 C 14 13.105 13.105 14 12 14 L 2 14 C 0.895 14 0 13.105 0 12 L 0 2 C 0 0.895 0.895 0 2 0 Z M 3.646 7.354 L 5.646 9.354 L 6 9.707 L 6.354 9.354 L 10.854 4.854 L 10.146 4.146 L 6 8.293 L 4.354 6.646 Z"
-        fill="#FFFFFF"></path>
+        fill="#000000"></path>
     <path d="M4 7L6 9L10.5 4.5" style="visibility: hidden;"></path>
 </svg>