@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/renderer.rs

@@ -142,19 +142,14 @@ pub struct RendererData {
     /// coexist there.
     slot_name: RefCell<Option<String>>,
 
-    /// This panel's selected theme name (per-panel theming), or `None` to
-    /// inherit the element-level (active) theme.
+    /// 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>>,
 
-    /// The registry default theme name (first registered), cached here so
-    /// LOCKED draw paths can resolve this panel's EFFECTIVE theme
-    /// synchronously (`Presentation::get_default_theme_name` is async — it
-    /// awaits theme discovery). Seeded by every content-load path before its
-    /// first locked draw (`restore_and_render`, `load()`, the
-    /// resize-observer's deferred first render) and kept fresh by the root's
-    /// `UpdatePresentation` default-theme fan-out and `resetThemes`.
-    default_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
@@ -276,7 +271,6 @@ impl Renderer {
             on_render_limits_changed: Default::default(),
             slot_name: Default::default(),
             theme: Default::default(),
-            default_theme: Default::default(),
             has_drawn: Cell::new(false),
             captured_theme: Default::default(),
             cached_context: Default::default(),
@@ -299,45 +293,24 @@ impl Renderer {
         self.0.slot_name.borrow().clone()
     }
 
-    /// Set this panel's theme name (`None` = inherit the element-level theme).
+    /// 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;
     }
 
-    /// This panel's selected theme name, if any (per-panel theming).
+    /// This panel's theme name.
     pub fn theme(&self) -> Option<String> {
         self.0.theme.borrow().clone()
     }
 
-    /// [`Self::set_theme`] plus a synchronous [`Self::stamp_theme`] when the
-    /// effective theme is resolvable now (a named theme needs no registry; a
-    /// reset stamps only from a warm default cache — a cold one would stamp
-    /// attribute-removal). The shared "stamp-with-commit" head of every
-    /// per-panel theme mutation site.
+    /// [`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>) {
-        let stamp = theme.is_some() || self.default_theme().is_some();
         self.set_theme(theme);
-        if stamp {
-            self.stamp_theme(None);
-        }
-    }
-
-    /// Set the cached registry default theme name (see the field docs on
-    /// [`RendererData`]).
-    pub fn set_default_theme(&self, name: Option<String>) {
-        *self.0.default_theme.borrow_mut() = name;
-    }
-
-    /// The cached registry default theme name.
-    pub fn default_theme(&self) -> Option<String> {
-        self.0.default_theme.borrow().clone()
-    }
-
-    /// This panel's EFFECTIVE theme: its own ([`Self::theme`]), else the
-    /// cached registry default ([`Self::default_theme`]) — the value
-    /// [`Self::stamp_theme`] stamps.
-    pub fn effective_theme(&self) -> Option<String> {
-        self.theme().or_else(|| self.default_theme())
+        self.stamp_theme(None);
     }
 
     /// Whether the active plugin's captured `--psp-*` CSS is STALE — the
@@ -352,7 +325,7 @@ impl Renderer {
     /// paint captures fresh by construction ("stamp before draw").
     pub fn needs_restyle(&self) -> bool {
         match &*self.0.captured_theme.borrow() {
-            Some(captured) => *captured != self.effective_theme(),
+            Some(captured) => *captured != self.theme(),
             None => false,
         }
     }

package/src/rust/session/column_defaults_update.rs

@@ -20,11 +20,16 @@ use crate::config::PluginStaticConfig;
 
 #[extend::ext]
 pub impl ViewConfigUpdate {
-    /// Coerce this update's `group_rollup_mode` to one the plugin accepts
-    /// (`PluginStaticConfig::group_rollup_modes`, feature-filtered). An
-    /// absent mode counts as `Rollup` for the acceptance check, so a plugin
-    /// that only renders `flat` (Treemap / Sunburst) gets it stamped even
-    /// when the update never mentions rollup at all.
+    /// Coerce this update's `group_rollup_mode` / `split_rollup_mode` to one
+    /// the plugin accepts (`PluginStaticConfig::*_rollup_modes`,
+    /// feature-filtered). An absent mode counts as `current`'s committed mode
+    /// for the acceptance check — `ViewConfig::apply_update` KEEPS the
+    /// committed mode when the update's field is `None`, so acceptance must
+    /// be judged against the mode that will actually be in effect. A
+    /// hardcoded-default fallback here let a plugin swap silently retain a
+    /// mode the new plugin excludes (e.g. Datagrid's `split_rollup_mode:
+    /// "rollup"` surviving a `restore({plugin: "Y Bar"})` onto a flat-only
+    /// chart).
     ///
     /// Split out of [`Self::set_update_column_defaults`] so same-plugin
     /// restores can enforce the mode WITHOUT the column-defaulting below —
@@ -33,6 +38,7 @@ pub impl ViewConfigUpdate {
     fn set_update_rollup_defaults(
         &mut self,
         metadata: &SessionMetadata,
+        current: &ViewConfig,
         config_static: &PluginStaticConfig,
     ) {
         let rollup_features = metadata
@@ -44,7 +50,7 @@ pub impl ViewConfigUpdate {
         if !group_rollups.contains(
             self.group_rollup_mode
                 .as_ref()
-                .unwrap_or(&GroupRollupMode::Rollup),
+                .unwrap_or(&current.group_rollup_mode),
         ) {
             self.group_rollup_mode = group_rollups.first().cloned();
             tracing::debug!(
@@ -52,6 +58,24 @@ pub impl ViewConfigUpdate {
                 self.group_rollup_mode
             );
         }
+
+        let split_rollup_features = metadata
+            .get_features()
+            .map(|x| x.get_split_rollup_modes())
+            .unwrap_or_default();
+
+        let split_rollups = config_static.get_split_rollups(&split_rollup_features);
+        if !split_rollups.contains(
+            self.split_rollup_mode
+                .as_ref()
+                .unwrap_or(&current.split_rollup_mode),
+        ) {
+            self.split_rollup_mode = split_rollups.first().cloned();
+            tracing::debug!(
+                "Setting plugin-advised split rollup mode {:?}",
+                self.split_rollup_mode
+            );
+        }
     }
 
     /// Appends additional columns to the `columns` field of this
@@ -63,10 +87,11 @@ pub impl ViewConfigUpdate {
     fn set_update_column_defaults(
         &mut self,
         metadata: &SessionMetadata,
+        current: &ViewConfig,
         columns: &[Option<String>],
         config_static: &PluginStaticConfig,
     ) {
-        self.set_update_rollup_defaults(metadata, config_static);
+        self.set_update_rollup_defaults(metadata, current, config_static);
 
         if let (None, Some(min_cols)) = (&self.columns, config_static.min_config_columns) {
             let names_len = config_static.config_column_names.len();

package/src/rust/session/metadata.rs

@@ -98,34 +98,20 @@ impl SessionMetadata {
 
     /// Records the pre-aggregation types of the config's window columns, so
     /// `get_column_table_type` resolves them like any other derived column.
-    /// Types mirror the engine's `t_window_engine::resolve_dtype` rules from
-    /// the window's op and its source's table type - independent of any
-    /// aggregation the view may also apply.
     pub(super) fn update_windows(
         &mut self,
         windows: &perspective_client::config::Windows,
     ) -> ApiResult<()> {
-        use perspective_client::config::WindowAggregate;
         let window_schema = windows
             .iter()
             .filter_map(|(name, w)| {
                 let source = self.get_column_table_type(&w.column)?;
-                let dtype = match w.aggregate {
-                    WindowAggregate::Sum
-                    | WindowAggregate::Avg
-                    | WindowAggregate::Stddev
-                    | WindowAggregate::Var
-                    | WindowAggregate::Rate
-                    | WindowAggregate::Ema
-                    | WindowAggregate::Diff => ColumnType::Float,
-                    WindowAggregate::Count => ColumnType::Integer,
-                    WindowAggregate::Min
-                    | WindowAggregate::Max
-                    | WindowAggregate::First
-                    | WindowAggregate::Last
-                    | WindowAggregate::Lag
-                    | WindowAggregate::Lead => source,
-                };
+                let dtype = self
+                    .get_window_aggregate(source, &w.aggregate)
+                    .and_then(|spec| spec.result_type)
+                    .and_then(|ty| ColumnType::try_from(ty).ok())
+                    .unwrap_or(source);
+
                 Some((name.clone(), dtype))
             })
             .collect();
@@ -133,6 +119,18 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// The declaration for one window aggregate over a `source` column type.
+    pub fn get_window_aggregate(
+        &self,
+        source: ColumnType,
+        name: &str,
+    ) -> Option<perspective_client::proto::WindowAggregateArgs> {
+        self.get_features()?
+            .get_window_aggregates(source)
+            .into_iter()
+            .find(|x| x.name == name)
+    }
+
     /// 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
@@ -189,7 +187,7 @@ impl SessionMetadata {
     }
 
     pub fn get_expression_columns(&self) -> impl Iterator<Item = &'_ String> {
-        try {
+        let mut columns = try {
             self.as_ref()?
                 .expr_meta
                 .as_ref()?
@@ -199,6 +197,10 @@ impl SessionMetadata {
         }
         .into_iter()
         .flatten()
+        .collect::<Vec<_>>();
+
+        columns.sort_unstable();
+        columns.into_iter()
     }
 
     /// Returns the full original expression `String` for an expression alias.

package/src/rust/session/props.rs

@@ -145,6 +145,7 @@ impl SessionProps {
     ) {
         config_update.set_update_column_defaults(
             &self.metadata,
+            &self.config,
             &self.all_columns().into_iter().map(Some).collect::<Vec<_>>(),
             config_static,
         )

package/src/rust/session/replace_expression_update.rs

@@ -126,6 +126,7 @@ pub impl ViewConfig {
             filter_op: None,
             group_by_depth: None,
             group_rollup_mode: None,
+            split_rollup_mode: None,
             windows: None,
         }
     }

package/src/rust/session.rs

@@ -719,9 +719,11 @@ impl Session {
         config_static: &PluginStaticConfig,
     ) {
         use self::column_defaults_update::*;
+        let config = self.get_view_config();
         config_update.set_update_column_defaults(
             &self.metadata(),
-            &self.get_view_config().columns,
+            &config,
+            &config.columns,
             config_static,
         )
     }
@@ -737,7 +739,11 @@ impl Session {
         config_static: &PluginStaticConfig,
     ) {
         use self::column_defaults_update::*;
-        config_update.set_update_rollup_defaults(&self.metadata(), config_static)
+        config_update.set_update_rollup_defaults(
+            &self.metadata(),
+            &self.get_view_config(),
+            config_static,
+        )
     }
 
     /// Apply a `ViewConfigUpdate` to the live config — the ONLY view-config
@@ -889,7 +895,7 @@ impl Session {
             .pending_dispatches
             .set(self.0.pending_dispatches.get() + 1);
         let session = self.clone();
-        ApiFuture::spawn(async move {
+        ApiFuture::spawn_named("config-update-dispatch", async move {
             let result = fut.await;
             let remaining = session.0.pending_dispatches.get() - 1;
             session.0.pending_dispatches.set(remaining);
@@ -1165,9 +1171,6 @@ impl Session {
         let old = self.borrow_mut().view_sub.take();
         ApiFuture::spawn(old.delete());
         self.borrow_mut().view_sub = Some(sub);
-        // REBUILD: a `View` was genuinely constructed and bound — the one
-        // place `view_created` may fire, and the one place the `FreshView`
-        // full-draw witness is minted from a rebuild.
         self.view_created.emit(());
         self.commit_reconciled.emit(());
         match self.get_view() {

package/src/rust/tasks/create_panel.rs

@@ -20,7 +20,7 @@ use crate::renderer::*;
 use crate::session::{ResetOptions, Session};
 use crate::tasks::*;
 use crate::utils::*;
-use crate::workspace::{Panel, PanelId, Workspace};
+use crate::workspace::{Panel, PanelId, PanelPhase, Workspace};
 use crate::*;
 
 /// Build the full set of subscriptions a [`Panel`] owns for its lifetime: its
@@ -69,20 +69,20 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
     })
 }
 
-/// 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.
+/// Create a new independent panel (own `Session` + `Renderer` + id) and
+/// restore `config` into it. Shared by `addPanel` and `restore`'s
+/// create-if-missing upsert. `id` is the panel's id — provided when
+/// restoring into a specific named slot, or `None` to generate a fresh
+/// one. `theme` is 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,
+    config: ViewerConfigInitial,
     client: Option<perspective_client::Client>,
 ) -> ApiResult<PanelId> {
     let (id, session, renderer, update) = create_panel_model(
@@ -90,36 +90,25 @@ pub(crate) async fn create_panel(
         presentation,
         workspace,
         id,
-        update,
+        config.into(),
         client,
-        Placement::Placed,
+        Placement::Staged,
     );
 
     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.
-    {
+    ApiFuture::spawn({
         clone!(workspace, id, notify);
-        ApiFuture::spawn(async move {
+        async move {
             set_timeout(STAGING_DEADLINE_MS).await?;
-            if workspace.clear_staged(&id) {
+            if workspace.promote(&id) {
                 notify.emit(());
             }
 
             Ok(())
-        });
-    }
+        }
+    });
 
     // A fresh panel is never the active one, so it needs no `root` for the
     // (active-only) settings-sidebar sequencing.
@@ -128,15 +117,15 @@ pub(crate) async fn create_panel(
         &renderer,
         presentation,
         workspace,
-        None,
         RestoreMode::Fresh,
         update,
+        crate::tasks::RestoreErrors::Publish,
     )
     .await;
 
     // Promote on completion AND error — a failed restore's error state
     // must become visible too.
-    if workspace.clear_staged(&id) {
+    if workspace.promote(&id) {
         notify.emit(());
     }
 
@@ -146,10 +135,17 @@ pub(crate) async fn create_panel(
 
 /// 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.
+    /// Into the placed panel set at [`PanelPhase::Placed`] — a live, visible
+    /// panel from the start (`restoreWorkspace` mounts panels directly at
+    /// their saved layout positions).
     Placed,
 
+    /// Into the placed panel set at [`PanelPhase::Staging`] — withheld from
+    /// the layout while its first draw completes in the hidden staging
+    /// wrapper, then promoted ([`Workspace::promote`]) by restore completion
+    /// or the [`STAGING_DEADLINE_MS`] deadline, whichever wins.
+    Staged,
+
     /// 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.
@@ -170,32 +166,23 @@ pub(crate) fn create_panel_model(
     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::Placed => workspace.insert_panel(panel, PanelPhase::Placed),
+        Placement::Staged => workspace.insert_panel(panel, PanelPhase::Staging),
         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));
-    }
+    renderer.set_theme(match &update.theme {
+        OptionalUpdate::Update(theme) => Some(theme.clone()),
+        _ => presentation.active_theme_name_sync(),
+    });
 
     update.theme = OptionalUpdate::Missing;
     if let Some(client) = client.or_else(|| workspace.default_client()) {
@@ -211,8 +198,18 @@ pub(crate) fn create_panel_model(
     (id, session, renderer, update)
 }
 
-pub(crate) fn place_reserved(workspace: &Workspace, notify: &Callback<()>) -> Option<Panel> {
-    let panel = workspace.claim_reserved()?;
+/// Claim the pending `load()` reservation into the placed set
+/// ([`Workspace::claim_reserved`]), stamping the global-filter overlay and
+/// notifying the root. `has_table` is whether the claimant carried a
+/// `table`, recorded atomically with the claim — pass `true` when `load()`
+/// itself places its reservation (a `Table` payload, or error surfacing),
+/// which is not a restore claim and must never arm the epilogue's eviction.
+pub(crate) fn place_reserved(
+    workspace: &Workspace,
+    notify: &Callback<()>,
+    has_table: bool,
+) -> Option<Panel> {
+    let panel = workspace.claim_reserved(has_table)?;
     stamp_global_overlay(workspace, &panel.id, &panel.session);
     notify.emit(());
     Some(panel)
@@ -220,7 +217,7 @@ pub(crate) fn place_reserved(workspace: &Workspace, notify: &Callback<()>) -> Op
 
 /// 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
+/// Shared by the root's `ClosePanel` handler and `restoreWorkspace`'s
 /// batch replacement of the pre-existing panel set.
 pub(crate) fn eject_panel(panel: Panel) -> ApiFuture<()> {
     let was_errored = panel.session.is_errored();

package/src/rust/tasks/edit_expression.rs

@@ -18,14 +18,22 @@ use perspective_client::clone;
 use perspective_client::config::{Expression, ViewConfigUpdate};
 
 use super::apply_and_render;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
+use crate::presentation::{
+    ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings, Presentation,
+};
 use crate::renderer::Renderer;
 use crate::session::Session;
 use crate::*;
 
-/// Replace the expression at `old_name` with `new_expr` and re-render.  After
-/// the render completes, opens the column-settings drawer on the renamed
-/// expression.
+fn reopen(presentation: &Presentation, name: String) {
+    presentation.set_open_column_settings(Some(OpenColumnSettings {
+        target: Some(ColumnSettingsTarget::Column(name)),
+        tab: Some(ColumnSettingsTab::Attributes),
+    }));
+}
+
+/// Replace the expression at `old_name` with `new_expr` and re-render,
+/// moving the column-settings drawer onto the renamed expression.
 pub fn update_expr(
     session: &Session,
     renderer: &Renderer,
@@ -39,25 +47,21 @@ pub fn update_expr(
             .to_props()
             .create_replace_expression_update(&old_name, &new_expr);
 
-        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),
-        }));
-
+        let run = apply_and_render(&session, &renderer, update)?;
+        reopen(&presentation, new_expr.name.to_string());
+        run.await?;
         Ok(())
     });
 }
 
-/// Insert `expr` into the session's expressions and re-render.  After the
-/// render completes, opens the column-settings drawer on the new expression.
+/// Insert `expr` into the session's expressions and re-render, moving the
+/// column-settings drawer onto the new expression.
 pub fn save_expr(
     session: &Session,
     renderer: &Renderer,
     presentation: &Presentation,
     expr: Expression,
 ) -> ApiResult<()> {
-    let presentation = presentation.clone();
     let expr_name: String = expr.name.clone().into();
     let task = {
         let mut serde_exprs = session.get_view_config().expressions.clone();
@@ -68,16 +72,8 @@ pub fn save_expr(
         })
     }?;
 
-    ApiFuture::spawn(async move {
-        task.await?;
-        presentation.set_open_column_settings(Some(OpenColumnSettings {
-            locator: Some(ColumnLocator::Expression(expr_name)),
-            tab: Some(ColumnSettingsTab::Attributes),
-        }));
-
-        Ok(())
-    });
-
+    reopen(presentation, expr_name);
+    ApiFuture::spawn(task);
     Ok(())
 }
 

package/src/rust/tasks/edit_window.rs

@@ -14,14 +14,16 @@ use perspective_client::clone;
 use perspective_client::config::{Filter, ViewConfigUpdate, WindowSpec};
 
 use super::apply_and_render;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
+use crate::presentation::{
+    ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings, Presentation,
+};
 use crate::renderer::Renderer;
 use crate::session::Session;
 use crate::*;
 
 fn reopen(presentation: &Presentation, name: String) {
     presentation.set_open_column_settings(Some(OpenColumnSettings {
-        locator: Some(ColumnLocator::Window(name)),
+        target: Some(ColumnSettingsTarget::Column(name)),
         tab: Some(ColumnSettingsTab::Window),
     }));
 }
@@ -36,7 +38,6 @@ pub fn save_window(
     name: String,
     spec: WindowSpec,
 ) -> ApiResult<()> {
-    let presentation = presentation.clone();
     let task = {
         let mut windows = session.get_view_config().windows.clone();
         windows.insert(name.clone(), spec);
@@ -46,12 +47,8 @@ pub fn save_window(
         })
     }?;
 
-    ApiFuture::spawn(async move {
-        task.await?;
-        reopen(&presentation, name);
-        Ok(())
-    });
-
+    reopen(presentation, name);
+    ApiFuture::spawn(task);
     Ok(())
 }
 
@@ -93,7 +90,7 @@ pub fn update_window(
                     config
                         .columns
                         .iter()
-                        .map(|col| col.as_ref().map(&rename))
+                        .map(|col| col.as_ref().map(rename))
                         .collect(),
                 );
                 update.group_by = Some(config.group_by.iter().map(&rename).collect());
@@ -134,8 +131,9 @@ pub fn update_window(
             update
         };
 
-        apply_and_render(&session, &renderer, update)?.await?;
+        let run = apply_and_render(&session, &renderer, update)?;
         reopen(&presentation, new_name);
+        run.await?;
         Ok(())
     });
 }

package/src/rust/tasks/eject.rs

@@ -23,11 +23,14 @@ use crate::workspace::Workspace;
 /// Tear down the entire viewer: dispose EVERY panel's engines (emit
 /// `table_unloaded`, destroy the renderer under its own draw lock, eject the
 /// session), then drop the Yew root once. Fans out over all panels — not just
-/// the seed — so panels added via `addPanel` or a whole-element `restore` don't
+/// the seed — so panels added via `addPanel` or `restoreWorkspace` don't
 /// leak their `View`/`Table` + plugin when the element is deleted or ejected.
 pub fn delete_all<T: Component>(workspace: &Workspace, root: &Root<T>) -> ApiFuture<()> {
     clone!(workspace, root);
     ApiFuture::new(async move {
+        // A staged-but-unapplied `restoreWorkspace` layout tree must not
+        // outlive the panels it names.
+        workspace.take_pending_layout();
         let panels = workspace
             .take_reserved()
             .into_iter()