@perspective-dev/viewer 4.5.2 → 5.1.0

package/src/rust/tasks/apply_global_filters.rs

@@ -0,0 +1,89 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 perspective_client::config::ViewConfigUpdate;
+
+use super::apply_and_render;
+use crate::session::Session;
+use crate::utils::spawn_owned;
+use crate::workspace::{PanelId, Workspace};
+
+/// Stamp `session`'s transient global-filter overlay from the
+/// [`Workspace`]'s current set — EMPTY for master (filter-source) panels,
+/// the full set for details. Master immunity is enforced here and only
+/// here. Returns whether the overlay changed.
+///
+/// Synchronous, so panel-creation paths can stamp BEFORE the panel's first
+/// locked bind — the initial render then picks the overlay up via its
+/// `ConfigSnapshot.effective`, with no second render and no unfiltered
+/// first paint.
+pub fn stamp_global_overlay(workspace: &Workspace, id: &PanelId, session: &Session) -> bool {
+    let filters = if workspace.is_master(id) {
+        Vec::new()
+    } else {
+        workspace.global_filters()
+    };
+
+    session.set_global_filter(filters)
+}
+
+/// Re-stamp every panel's overlay and re-render those whose overlay CHANGED
+/// (details are usually non-active, so they need an explicit re-render
+/// rather than relying on a subscription; unchanged panels aren't touched
+/// at all).
+pub fn apply_global_filters(workspace: &Workspace) {
+    for pid in workspace.panel_ids() {
+        if let Some(panel) = workspace.panel(&pid)
+            && stamp_global_overlay(workspace, &pid, &panel.session)
+        {
+            let effect = workspace.effects().guard();
+            let session = panel.session.clone();
+            let renderer = panel.renderer.clone();
+            spawn_owned("apply-global-filters", async move {
+                let _effect = effect;
+                apply_and_render(&session, &renderer, ViewConfigUpdate::default())?.await?;
+                Ok(())
+            });
+        }
+    }
+}
+
+/// Clear the ORIGINATING master panels' visible selection state (row
+/// highlights, pinned tooltips) after their contributed clauses are removed
+/// from the `GlobalFilterBar` (chip × / "Clear") — a selection visual must
+/// not outlive the filter it produced. The plugin's OPTIONAL `deselect()` is
+/// SILENT (no selection events), so no `MasterSelect` echo can re-mutate the
+/// filter set; plugins without one (e.g. `Debug`) no-op. Each call runs
+/// under its panel's draw lock — implementations may redraw (see the
+/// call-discipline contract on `js/plugin.rs`). A closed panel's id is
+/// skipped.
+pub fn clear_master_selections(workspace: &Workspace, origins: Vec<PanelId>) {
+    for id in origins {
+        if let Some(panel) = workspace.panel(&id) {
+            let renderer = panel.renderer.clone();
+            spawn_owned("clear-master-selection", async move {
+                let r = renderer.clone();
+                renderer
+                    .render_task(|_guard| async move {
+                        // Pure query: a never-drawn panel has no plugin and
+                        // no selection to clear.
+                        if let Some(plugin) = r.active_plugin() {
+                            plugin.deselect().await?;
+                        }
+
+                        Ok(())
+                    })
+                    .await
+            });
+        }
+    }
+}

package/src/rust/tasks/auto_pause.rs

@@ -0,0 +1,171 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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::Cell;
+use std::rc::Rc;
+
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use web_sys::*;
+
+use crate::config::ViewerConfigUpdate;
+use crate::js::*;
+use crate::presentation::Presentation;
+use crate::renderer::*;
+use crate::session::Session;
+use crate::utils::*;
+use crate::workspace::Workspace;
+use crate::*;
+
+/// The `auto-pause` driver: pauses every panel's [`Session`] (deleting its
+/// `ViewSubscription`, which stops `table_updated` at the source) whenever
+/// the host element cannot be seen, and resumes with a re-render when it
+/// can again. "Cannot be seen" is the conjunction of TWO independent
+/// signals, either of which alone would miss real cases:
+///
+///   - An `IntersectionObserver` on the host element (scrolled out of the
+///     viewport, `display: none`, disconnected). This CANNOT observe
+///     browser-tab backgrounding — intersection entries are only generated
+///     during the document's rendering steps, which are suspended while hidden,
+///     and the element's viewport intersection doesn't change on a tab switch
+///     anyway.
+///   - A `document` `visibilitychange` listener (tab backgrounded, window
+///     minimized/occluded). Without it, a fast-updating table kept dispatching
+///     update-redraws whose draws hang on the suspended rAF — the
+///     background-tab reactivation stall.
+pub struct AutoPauseHandle {
+    elem: HtmlElement,
+    observer: IntersectionObserver,
+    _callback: Closure<dyn FnMut(js_sys::Array)>,
+    _visibility: Closure<dyn Fn(JsValue)>,
+}
+
+impl AutoPauseHandle {
+    pub fn new(elem: &HtmlElement, presentation: &Presentation, workspace: &Workspace) -> Self {
+        let state = Rc::new(AutoPauseState {
+            intersecting: Cell::new(true),
+            doc_visible: Cell::new(!global::document().hidden()),
+            presentation: presentation.clone(),
+            workspace: workspace.clone(),
+        });
+
+        let _callback = Closure::new({
+            clone!(state);
+            move |xs: js_sys::Array| {
+                let intersect = xs
+                    .pop()
+                    .unchecked_into::<IntersectionObserverEntry>()
+                    .is_intersecting();
+
+                state.intersecting.set(intersect);
+                state.apply();
+            }
+        });
+
+        let func = _callback.as_ref().unchecked_ref::<js_sys::Function>();
+        let observer = IntersectionObserver::new(func);
+        observer.observe(elem);
+
+        let _visibility = Closure::new({
+            clone!(state);
+            move |_: JsValue| {
+                state.doc_visible.set(!global::document().hidden());
+                state.apply();
+            }
+        });
+
+        global::document()
+            .add_event_listener_with_callback(
+                "visibilitychange",
+                _visibility.as_ref().unchecked_ref(),
+            )
+            .unwrap();
+
+        Self {
+            elem: elem.clone(),
+            observer,
+            _callback,
+            _visibility,
+        }
+    }
+}
+
+impl Drop for AutoPauseHandle {
+    fn drop(&mut self) {
+        self.observer.unobserve(&self.elem);
+        let _ = global::document().remove_event_listener_with_callback(
+            "visibilitychange",
+            self._visibility.as_ref().unchecked_ref(),
+        );
+    }
+}
+
+struct AutoPauseState {
+    intersecting: Cell<bool>,
+    doc_visible: Cell<bool>,
+    presentation: Presentation,
+    workspace: Workspace,
+}
+
+impl AutoPauseState {
+    fn apply(self: &Rc<Self>) {
+        let visible = self.intersecting.get() && self.doc_visible.get();
+        clone!(self.workspace, self.presentation);
+        ApiFuture::spawn(async move {
+            let panels = workspace.panels();
+            futures::future::join_all(panels.iter().map(|panel| {
+                let presentation = presentation.clone();
+                async move {
+                    set_panel_paused(&panel.session, &panel.renderer, &presentation, visible).await
+                }
+            }))
+            .await
+            .into_iter()
+            .collect::<ApiResult<Vec<_>>>()?;
+
+            Ok(())
+        });
+    }
+}
+
+/// Apply one panel's pause/resume transition. Shared by the
+/// [`AutoPauseState`] fan-out and `setAutoPause(false)`'s force-resume.
+pub(crate) async fn set_panel_paused(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    visible: bool,
+) -> ApiResult<()> {
+    if visible {
+        if session.set_pause(false) {
+            let result = super::restore_and_render(
+                session,
+                renderer,
+                presentation,
+                super::RunOrigin::Internal,
+                ViewerConfigUpdate::default(),
+                async move { Ok(()) },
+            )
+            .await;
+
+            if let Err(e) = result.ignore_view_delete() {
+                session.set_run_error(e.clone()).await?;
+                return Err(e);
+            }
+        }
+    } else {
+        session.set_pause(true);
+    };
+
+    Ok(())
+}

package/src/rust/tasks/copy_export.rs

@@ -66,34 +66,44 @@ pub async fn html_as_jsvalue(
 }
 
 /// Render the current view as a `.png` `Blob` via the active plugin's
-/// `render` method (typically only available for chart plugins).
+/// `render` method (typically only available for chart plugins). Chart
+/// plugins implement `render` as a full internal `draw` + snapshot, so the
+/// call must hold the renderer's draw lock like any other draw (see
+/// [`crate::js::plugin`]) or it would interleave with a concurrent
+/// `table_updated` redraw.
 pub async fn png_as_jsvalue(session: &Session, renderer: &Renderer) -> ApiResult<web_sys::Blob> {
-    let plugin = renderer.get_active_plugin()?;
-    let view: perspective_client::View = session
-        .get_view()
-        .ok_or(ApiError::from(ApiErrorType::NoTableError))?;
-
-    let png = plugin.render(view.into(), None).await?;
-    Ok(png)
+    renderer
+        .clone()
+        .render_task(|_guard| async move {
+            let plugin = renderer.ensure_plugin_selected()?;
+            let view: perspective_client::View = session
+                .get_view()
+                .ok_or(ApiError::from(ApiErrorType::NoTableError))?;
+
+            plugin.render(view.into(), None).await
+        })
+        .await
 }
 
 /// Render the current view as a `.txt` `Blob` via the active plugin's
-/// `render` method (typically used for the datagrid).
+/// `render` method (typically used for the datagrid). Locked for the same
+/// reason as [`png_as_jsvalue`].
 pub async fn txt_as_jsvalue(
     session: &Session,
     renderer: &Renderer,
     viewport: Option<ViewWindow>,
 ) -> ApiResult<web_sys::Blob> {
-    let plugin = renderer.get_active_plugin()?;
-    let view: perspective_client::View = session
-        .get_view()
-        .ok_or(ApiError::from(ApiErrorType::NoTableError))?;
-
-    let txt = plugin
-        .render(view.into(), viewport.map(|x| x.into()))
-        .await?;
-
-    Ok(txt)
+    renderer
+        .clone()
+        .render_task(|_guard| async move {
+            let plugin = renderer.ensure_plugin_selected()?;
+            let view: perspective_client::View = session
+                .get_view()
+                .ok_or(ApiError::from(ApiErrorType::NoTableError))?;
+
+            plugin.render(view.into(), viewport.map(|x| x.into())).await
+        })
+        .await
 }
 
 /// Generate a result `Blob` for all types of [`ExportMethod`].

package/src/rust/tasks/create_panel.rs

@@ -0,0 +1,243 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 web_sys::HtmlElement;
+use yew::Callback;
+
+use crate::config::*;
+use crate::custom_events::wire_panel_events;
+use crate::presentation::*;
+use crate::renderer::*;
+use crate::session::{ResetOptions, Session};
+use crate::tasks::*;
+use crate::utils::*;
+use crate::workspace::{Panel, PanelId, Workspace};
+use crate::*;
+
+/// Build the full set of subscriptions a [`Panel`] owns for its lifetime: its
+/// redraw subscription plus its custom-event fanout ([`wire_panel_events`]).
+/// Shared by the seed (element constructor) and every [`create_panel_model`]
+/// panel, so all panels wire identically and every panel — not just the seed —
+/// dispatches its own `perspective-*` events (see C6).
+pub(crate) fn wire_panel_subs(
+    elem: &HtmlElement,
+    presentation: &Presentation,
+    session: &Session,
+    renderer: &Renderer,
+) -> Vec<Subscription> {
+    let mut subs = vec![wire_panel_render_sub(session, renderer)];
+    subs.extend(wire_panel_events(elem, session, renderer, presentation));
+    subs
+}
+
+/// Wire a panel's data-refresh subscription: when its [`Session`]'s table emits
+/// an update, redraw its [`Renderer`]. The returned [`Subscription`] must be
+/// owned for the panel's lifetime (see [`Panel`]).
+///
+/// Hidden panels (an unslotted tab-stack panel, a `display: none` host)
+/// don't redraw — a full charts dispatch per update is a fetch + render
+/// nobody can see. The dropped update is recorded on the [`Renderer`]
+/// instead, and the activation nudge (`tasks::pipeline::activation_render`)
+/// consumes the marker to catch the panel up with ONE `plugin.update`.
+fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription {
+    session.table_updated.add_listener({
+        clone!(renderer, session);
+        move |_| {
+            if renderer.is_plugin_hidden() {
+                renderer.set_data_stale();
+                return;
+            }
+
+            clone!(renderer, session);
+            ApiFuture::spawn(async move {
+                renderer
+                    .update_lazy(async move { Ok(session.get_view()) })
+                    .await
+                    .ignore_view_delete()
+                    .map(|_| ())
+            })
+        }
+    })
+}
+
+/// Create a new independent panel (own `Session` + `Renderer` + id) from a
+/// `ViewerConfigUpdate`, mount and draw it, and return its id. Shared by
+/// `addPanel`, whole-element `restore`, and `restorePanel`'s create-if-missing
+/// path. `id` is the panel's id — provided when restoring into a specific named
+/// slot, or `None` to generate a fresh one. `settings`/`theme` are stripped
+/// (element-level, not per-panel) and `client` — or the element's default
+/// client when `None` — is bound so the config's `table` resolves against it.
+pub(crate) async fn create_panel(
+    elem: &HtmlElement,
+    presentation: &Presentation,
+    workspace: &Workspace,
+    notify: &Callback<()>,
+    id: Option<PanelId>,
+    update: ViewerConfigUpdate,
+    client: Option<perspective_client::Client>,
+) -> ApiResult<PanelId> {
+    let (id, session, renderer, update) = create_panel_model(
+        elem,
+        presentation,
+        workspace,
+        id,
+        update,
+        client,
+        Placement::Placed,
+    );
+
+    stamp_global_overlay(workspace, &id, &session);
+    // STAGE the panel (model-first): `MainPanel` renders its plugin slot
+    // into a hidden pre-sized wrapper — not a layout cell — so the restore
+    // below completes its first draw invisibly at (near-)final size. The
+    // promote below then re-renders, and `MainPanel::reconcile` inserts an
+    // ALREADY-DRAWN panel: the one layout transition reveals content,
+    // never a blank frame.
+    workspace.stage_panel(&id);
+    notify.emit(());
+
+    // The staging deadline: a slow restore promotes EARLY (placed, still
+    // loading — the pre-staging progressive reveal) rather than leaving
+    // the layout without feedback. Races the completion promote below on
+    // the staged flag; only the winner re-renders.
+    {
+        clone!(workspace, id, notify);
+        ApiFuture::spawn(async move {
+            set_timeout(STAGING_DEADLINE_MS).await?;
+            if workspace.clear_staged(&id) {
+                notify.emit(());
+            }
+
+            Ok(())
+        });
+    }
+
+    // A fresh panel is never the active one, so it needs no `root` for the
+    // (active-only) settings-sidebar sequencing.
+    let result = restore_panel(
+        &session,
+        &renderer,
+        presentation,
+        workspace,
+        None,
+        RestoreMode::Fresh,
+        update,
+    )
+    .await;
+
+    // Promote on completion AND error — a failed restore's error state
+    // must become visible too.
+    if workspace.clear_staged(&id) {
+        notify.emit(());
+    }
+
+    result?;
+    Ok(id)
+}
+
+/// Where [`create_panel_model`] registers the new panel model.
+pub(crate) enum Placement {
+    /// Into the placed panel set ([`Workspace::insert_panel`]) — a live,
+    /// visible panel from the start.
+    Placed,
+
+    /// Into the reservation slot ([`Workspace::reserve_panel`]) — a pending
+    /// `load()`'s first panel, held out of the placed set until it is
+    /// claimed ([`place_reserved`]) or discarded.
+    Reserved,
+}
+
+/// The synchronous *model* half of [`create_panel`]: build and register a new
+/// panel's engine handles (own `Session` + `Renderer` + id) in the
+/// [`Workspace`] (per `placement`), apply-and-strip the element-level config
+/// fields (`settings`/`theme`), and bind `client` (falling back to the default
+/// client). `id` is the panel's id, or `None` to generate a fresh one.
+pub(crate) fn create_panel_model(
+    elem: &HtmlElement,
+    presentation: &Presentation,
+    workspace: &Workspace,
+    id: Option<PanelId>,
+    mut update: ViewerConfigUpdate,
+    client: Option<perspective_client::Client>,
+    placement: Placement,
+) -> (PanelId, Session, Renderer, ViewerConfigUpdate) {
+    // Authored-theme boot: the FIRST panel of an empty element with no explicit
+    // theme adopts the element's `theme` attribute (a one-time initial
+    // selection; the attribute is otherwise an active-panel mirror). Captured
+    // before `insert_panel` makes the workspace non-empty.
+    let boot_theme = (workspace.is_empty() && matches!(update.theme, OptionalUpdate::Missing))
+        .then(|| elem.get_attribute("theme"))
+        .flatten();
+
+    let session = Session::new();
+    let renderer = Renderer::new(elem);
+    let id = id.unwrap_or_else(|| workspace.generate_id());
+    renderer.set_slot_name(id.as_str());
+    renderer.set_default_theme(presentation.default_theme_name_sync());
+    let subs = wire_panel_subs(elem, presentation, &session, &renderer);
+    let panel = Panel::new(id.clone(), session.clone(), renderer.clone(), subs);
+    match placement {
+        Placement::Placed => workspace.insert_panel(panel),
+        Placement::Reserved => workspace.reserve_panel(panel),
+    }
+
+    update.settings = OptionalUpdate::Missing;
+    if let OptionalUpdate::Update(theme) = &update.theme {
+        renderer.set_theme(Some(theme.clone()));
+    } else if let Some(theme) = boot_theme {
+        renderer.set_theme(Some(theme));
+    }
+
+    update.theme = OptionalUpdate::Missing;
+    if let Some(client) = client.or_else(|| workspace.default_client()) {
+        workspace.register_client(client.clone());
+        session.set_client(client);
+    }
+
+    if let Some((idx, _)) = renderer.resolve_plugin_update(&update.plugin) {
+        let _ = renderer.commit_plugin(Some(idx));
+        let _ = renderer.mount_active_plugin();
+    }
+
+    (id, session, renderer, update)
+}
+
+pub(crate) fn place_reserved(workspace: &Workspace, notify: &Callback<()>) -> Option<Panel> {
+    let panel = workspace.claim_reserved()?;
+    stamp_global_overlay(workspace, &panel.id, &panel.session);
+    notify.emit(());
+    Some(panel)
+}
+
+/// Tear down a [`Panel`] already removed from the [`Workspace`]: dispose its
+/// renderer (slot-scoped plugin + light-DOM cleanup) and eject its table.
+/// Shared by the root's `ClosePanel` handler and whole-element `restore`'s
+/// batch replacement of the pre-existing panel set.
+pub(crate) fn eject_panel(panel: Panel) -> ApiFuture<()> {
+    let was_errored = panel.session.is_errored();
+    let dispose_task = panel.renderer.dispose();
+    let reset_task = panel.session.reset(ResetOptions {
+        config: true,
+        expressions: true,
+        table: Some(session::TableIntermediateState::Ejected),
+        ..ResetOptions::default()
+    });
+
+    ApiFuture::new(async move {
+        dispose_task.await?;
+        match reset_task.await.ignore_view_delete() {
+            Err(_) if was_errored => Ok(()),
+            Err(e) => Err(e),
+            Ok(_) => Ok(()),
+        }
+    })
+}

package/src/rust/tasks/dismiss_render_warning.rs

@@ -27,7 +27,9 @@ pub fn dismiss_render_warning_callback(session: &Session, renderer: &Renderer) -
         clone!(session, renderer);
         ApiFuture::spawn(async move {
             renderer.disable_active_plugin_render_warning();
-            renderer.update(session.get_view()).await
+            renderer
+                .update_lazy(async move { Ok(session.get_view()) })
+                .await
         });
     })
 }

package/src/rust/tasks/edit_expression.rs

@@ -17,7 +17,7 @@
 use perspective_client::clone;
 use perspective_client::config::{Expression, ViewConfigUpdate};
 
-use super::update_and_render;
+use super::apply_and_render;
 use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
 use crate::renderer::Renderer;
 use crate::session::Session;
@@ -39,7 +39,7 @@ pub fn update_expr(
             .to_props()
             .create_replace_expression_update(&old_name, &new_expr);
 
-        update_and_render(&session, &renderer, update)?.await?;
+        apply_and_render(&session, &renderer, update)?.await?;
         presentation.set_open_column_settings(Some(OpenColumnSettings {
             locator: Some(ColumnLocator::Expression(new_expr.name.to_string())),
             tab: Some(ColumnSettingsTab::Attributes),
@@ -62,7 +62,7 @@ pub fn save_expr(
     let task = {
         let mut serde_exprs = session.get_view_config().expressions.clone();
         serde_exprs.insert(&expr);
-        update_and_render(session, renderer, ViewConfigUpdate {
+        apply_and_render(session, renderer, ViewConfigUpdate {
             expressions: Some(serde_exprs),
             ..Default::default()
         })
@@ -90,7 +90,7 @@ pub fn delete_expr(session: &Session, renderer: &Renderer, expr_name: &str) -> A
         ..ViewConfigUpdate::default()
     };
 
-    let task = update_and_render(session, renderer, config)?;
+    let task = apply_and_render(session, renderer, config)?;
     ApiFuture::spawn(task);
     Ok(())
 }