@perspective-dev/viewer 5.5.0 → 5.6.0

package/src/rust/tasks/pipeline.rs

@@ -12,17 +12,17 @@
 
 use std::rc::Rc;
 
-use futures::future::LocalBoxFuture;
+use futures::FutureExt;
 use perspective_client::config::ViewConfigUpdate;
 use perspective_client::{View, clone};
 use perspective_js::utils::*;
 use wasm_bindgen::JsValue;
 use yew::prelude::*;
 
-use crate::config::{ColumnConfigUpdate, PluginConfigUpdate};
+use super::transactional_restore::{commit_edit, prepare_edit};
 use crate::presentation::Presentation;
 use crate::renderer::{RenderContext, Renderer};
-use crate::session::{BindDisposition, Session};
+use crate::session::{BindDisposition, BindingEffects, Disposal, EditDelta, OpKind, Session};
 use crate::utils::RenderGuard;
 
 /// Snapshot → validate → bind → cache + pin the [`RenderContext`]. The core
@@ -35,15 +35,6 @@ pub async fn bind_snapshot(
     session: &Session,
     renderer: &Renderer,
 ) -> ApiResult<(BindDisposition, Option<crate::renderer::ContextPin>)> {
-    // A `load()` is mid-classification (see [`Session::pending_load`]): DEFER
-    // rather than bind the incoming config against the still-bound outgoing
-    // table. Holds the last painted frame; the `load()` run performs the one
-    // reconciling bind once its payload resolves — the single visible
-    // transition, correct in whichever future (Table/Client) materializes.
-    if session.has_pending_load() {
-        return Ok((BindDisposition::Deferred, None));
-    }
-
     let snap = session.snapshot(guard);
     let validated = session.validate_snapshot(guard, snap).await?;
     let disposition = session.bind_view(guard, validated).await?;
@@ -132,34 +123,73 @@ pub fn apply_and_render(
 }
 
 /// [`apply_and_render`] plus a plugin selection (resolved via
-/// [`Renderer::resolve_plugin_update`]). The plugin swap is committed inside
-/// the locked run, atomically with the view rebind — never staged on the
-/// `Renderer` where a concurrent draw could observe it.
+/// [`Renderer::resolve_plugin_update`]), committed in the SAME swap as the
+/// view config — in the op's step, never by the detached render.
 pub fn update_plugin_and_render(
     session: &Session,
     renderer: &Renderer,
     update: ViewConfigUpdate,
     plugin_idx: Option<usize>,
 ) -> ApiResult<ApiFuture<()>> {
-    session.commit_view_config(update)?;
-    // Spinner accounting (RAII): created only when the commit succeeded,
-    // moved into the run future, settled on every exit path by `Drop`.
-    let run_token = session.begin_config_run();
-    clone!(session, renderer);
-    Ok(ApiFuture::new(async move {
-        let _run_token = run_token;
-        render_run(session, renderer, plugin_idx).await
-    }))
+    session.check_edit(&update)?;
+    let kind = OpKind::Edit {
+        delta: EditDelta::View(Box::new(update.clone())),
+        swaps_plugin: plugin_idx.is_some(),
+    };
+
+    let ticket = session.submit(kind, {
+        clone!(session, renderer);
+        move |_ctx| {
+            Box::pin(async move {
+                let prepared = prepare_edit(&session, &renderer, update, plugin_idx).await?;
+                let committed = commit_edit(&session, &renderer, prepared);
+                Ok(Some(
+                    render_run(session, renderer, RunCommit::Done(committed)).boxed_local(),
+                ))
+            })
+        }
+    });
+
+    Ok(ApiFuture::new(ticket.settle()))
 }
 
 /// Re-render from the current commit without applying an update.
 pub fn just_render(session: &Session, renderer: &Renderer) -> ApiResult<ApiFuture<()>> {
     clone!(session, renderer);
     Ok(ApiFuture::new(async move {
-        render_run(session, renderer, None).await
+        render_run(session, renderer, RunCommit::None).await
     }))
 }
 
+/// What a transactional restore committed (see
+/// [`super::transactional_restore`]): the run has to bring the plugin element
+/// and the paint in line with it.
+pub(crate) struct Committed {
+    /// A plugin selection was committed; its element must be activated.
+    pub activate: bool,
+
+    /// ...and it REPLACED an earlier selection (a first selection is not a
+    /// swap, and does not force a `plugin.restore`).
+    pub plugin_swapped: bool,
+    pub plugin_config_changed: bool,
+    pub columns_config_changed: bool,
+}
+
+/// The commit a locked run renders.
+pub(crate) enum RunCommit {
+    /// Whatever is committed (a repaint, an activation, a resize).
+    None,
+
+    /// A UI edit its op's step ALREADY committed; the plugin receives the final
+    /// buckets in ONE `plugin.restore`.
+    Done(Committed),
+
+    /// A restore's commit, run first thing under the lock — a restore may
+    /// REBIND, and under the lock no render of the outgoing state can bind a
+    /// `View` over the incoming table.
+    Deferred(Box<dyn FnOnce() -> (Committed, BindingEffects)>),
+}
+
 /// Everything that varies between locked render runs, consumed by
 /// [`locked_run`] — the ONE lock-body composition. `Default` is the
 /// host-internal UI-commit run: `Internal` origin, no plugin swap, no
@@ -168,21 +198,8 @@ pub(crate) struct RunSpec {
     /// Who initiated this run (see [`RunOrigin`]).
     pub origin: RunOrigin,
 
-    /// A plugin swap resolved by [`Renderer::resolve_plugin_update`],
-    /// committed inside the run atomically with the rebind.
-    pub plugin_idx: Option<usize>,
-
-    /// Plugin-level bucket update, applied inside the run after the bind
-    /// (so strip-on-write sees fresh schemas).
-    pub plugin_config: PluginConfigUpdate,
-
-    /// Per-column bucket update; same timing as `plugin_config`.
-    pub columns_config: ColumnConfigUpdate,
-
-    /// Pre-bind hook awaited inside the lock (table binding, resets) —
-    /// BEFORE the error guard, so a task that recovers the session (e.g.
-    /// `restorePanel`'s errored-recovery reset) unblocks its own run.
-    pub task: Option<LocalBoxFuture<'static, ApiResult<()>>>,
+    /// What this run renders — see [`RunCommit`].
+    pub commit: RunCommit,
 
     /// When set, plugin dispatch is skipped while the host element is not
     /// visible (`Presentation::is_visible`) — the `restore` family's gate
@@ -196,10 +213,7 @@ impl Default for RunSpec {
     fn default() -> Self {
         Self {
             origin: RunOrigin::Internal,
-            plugin_idx: None,
-            plugin_config: PluginConfigUpdate::Missing,
-            columns_config: ColumnConfigUpdate::Missing,
-            task: None,
+            commit: RunCommit::None,
             presentation: None,
         }
     }
@@ -208,7 +222,7 @@ impl Default for RunSpec {
 /// One locked, witnessed, snapshot-consuming render run — the SINGLE lock
 /// body shared by every config-driven run (`apply_and_render` &co. via
 /// [`render_run`]'s tail, the `restore` family via
-/// [`super::restore_and_render`]): eager mount → pre-bind `task` →
+/// [`super::transactional_restore`]): the restore's commit → eager mount →
 /// plugin-swap commit → theme stamp → error guard → [`bind_snapshot`]
 /// (gated on a bound `Table`, else `Deferred` — the config is already
 /// committed, so the eventual `load()` run binds from it) → bucket updates
@@ -216,7 +230,7 @@ impl Default for RunSpec {
 ///
 /// A pre-existing session error skips the run for `Internal` origins and
 /// fails it for `Public` ones (the caller asked and must hear the failure —
-/// I6). Returns the RAW run result; error-reporting policy (`set_run_error`
+/// I6). Returns the RAW run result; error-reporting policy (`Renderer::fail`
 /// vs. propagate) belongs to the caller.
 pub(crate) async fn locked_run(
     session: &Session,
@@ -226,16 +240,68 @@ pub(crate) async fn locked_run(
     clone!(session, renderer);
     renderer
         .clone()
-        .render_task(|guard| async move {
-            renderer.mount_active_plugin()?;
-            if let Some(task) = spec.task {
-                task.await?;
+        .render_task(|guard| run_locked(guard, session, renderer, spec))
+        .await
+}
+
+/// [`locked_run`]'s body, for a caller that already holds the draw lock.
+pub(crate) async fn run_locked(
+    guard: RenderGuard,
+    session: Session,
+    renderer: Renderer,
+    spec: RunSpec,
+) -> ApiResult<()> {
+    {
+        {
+            if let Some(disposal) = session.disposal() {
+                return match (disposal, spec.origin) {
+                    (Disposal::Reject, RunOrigin::Public) => Err(ApiError::new("Panel disposed")),
+                    _ => Ok(()),
+                };
+            }
+
+            let committed = match spec.commit {
+                RunCommit::Done(committed) => Some(committed),
+                RunCommit::Deferred(commit) => {
+                    let (committed, binding) = commit();
+                    let rebound = binding.rebound();
+                    session.finish_binding(binding).await?;
+                    if rebound
+                        && session.get_table().is_none()
+                        && let Some(plugin) = renderer.active_plugin()
+                    {
+                        plugin.clear().await?;
+                    }
+
+                    Some(committed)
+                },
+                RunCommit::None => None,
+            };
+
+            if !committed.as_ref().is_some_and(|c| c.activate) {
+                renderer.mount_active_plugin()?;
             }
 
-            let plugin_swapped = renderer.commit_plugin(spec.plugin_idx)?;
+            let plugin_swapped = match &committed {
+                Some(committed) => {
+                    if committed.activate {
+                        renderer.activate_committed_plugin()?;
+                    }
+
+                    committed.plugin_swapped
+                },
+                None => {
+                    renderer.ensure_plugin_selected()?;
+                    false
+                },
+            };
             let plugin = renderer.active_plugin().ok_or("No Plugin")?;
             renderer.stamp_theme(Some(&plugin));
-            if let Some(error) = session.get_error() {
+            let blocking = session
+                .get_error()
+                .or_else(|| renderer.failure().map(|x| x.0));
+
+            if let Some(error) = blocking {
                 return match spec.origin {
                     RunOrigin::Public => Err(error),
                     RunOrigin::Internal => Ok(()),
@@ -248,39 +314,35 @@ pub(crate) async fn locked_run(
                 (BindDisposition::Deferred, None)
             };
 
-            let view_config_snapshot = session.get_view_config().clone();
-            let plugin_config_changed =
-                renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
-            let plugin_config_snapshot = renderer.get_plugin_config();
-            let plugin_update =
-                JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
-
-            let plugin_restored = plugin_config_changed || plugin_swapped;
-            if plugin_restored {
-                let columns_config = renderer
-                    .all_columns_configs_materialized(&view_config_snapshot, &session)
-                    .await;
-                plugin.restore(&plugin_update, Some(&columns_config))?;
-            }
+            let view_config_snapshot = session.committed_view_config().clone();
+            let changed = match committed {
+                Some(committed) => {
+                    let changed =
+                        committed.plugin_config_changed || committed.columns_config_changed;
 
-            let columns_config_changed = renderer.update_columns_configs(
-                &view_config_snapshot,
-                &session,
-                spec.columns_config,
-            )?;
-
-            let changed = plugin_config_changed || columns_config_changed;
-            if columns_config_changed {
-                let columns_config = renderer
-                    .all_columns_configs_materialized(&view_config_snapshot, &session)
-                    .await;
-                plugin.restore(&plugin_update, Some(&columns_config))?;
-                renderer.columns_config_changed.emit(columns_config);
-            }
+                    if changed || plugin_swapped {
+                        let plugin_config = renderer.committed_plugin_config();
+                        let plugin_update =
+                            JsValue::from_serde_ext(&plugin_config).unwrap_or(JsValue::NULL);
 
-            if plugin_config_changed {
-                renderer.plugin_config_changed.emit(plugin_config_snapshot);
-            }
+                        let columns_config = renderer
+                            .all_columns_configs_materialized(&view_config_snapshot, &session)
+                            .await;
+
+                        plugin.restore(&plugin_update, Some(&columns_config))?;
+                        if committed.columns_config_changed {
+                            renderer.columns_config_changed.emit(columns_config);
+                        }
+
+                        if committed.plugin_config_changed {
+                            renderer.plugin_config_changed.emit(plugin_config);
+                        }
+                    }
+
+                    changed
+                },
+                None => false,
+            };
 
             if spec
                 .presentation
@@ -291,22 +353,23 @@ pub(crate) async fn locked_run(
                 dispatch_bound(&guard, &renderer, disposition, changed, spec.origin).await?;
             }
 
+            renderer.landed();
             Ok(())
-        })
-        .await
+        }
+    }
 }
 
 /// [`locked_run`]'s host-internal tail: a failed RUN sets error state (with
 /// the reset-reconnect affordance); the committed config is NOT rolled back
 /// (I4). Cancellation by a superseding run ("View already deleted") is not
 /// a failure.
-async fn render_run(
+pub(super) async fn render_run(
     session: Session,
     renderer: Renderer,
-    plugin_idx: Option<usize>,
+    commit: RunCommit,
 ) -> ApiResult<()> {
     let spec = RunSpec {
-        plugin_idx,
+        commit,
         ..RunSpec::default()
     };
 
@@ -314,7 +377,7 @@ async fn render_run(
         .await
         .ignore_view_delete()
     {
-        Err(e) => session.set_run_error(e).await,
+        Err(e) => renderer.fail(e),
         Ok(_) => Ok(()),
     }
 }

package/src/rust/tasks/reset_all.rs

@@ -11,20 +11,20 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 //! Cross-engine reset orchestration: reset session config, optionally clear
-//! presentation columns config / theme, then delegate to `restore_and_render`
-//! to switch back to the default plugin and redraw.
+//! presentation columns config / theme, then delegate to a transactional
+//! restore to switch back to the default plugin and redraw.
 
 use perspective_client::clone;
-use perspective_js::utils::ApiFuture;
+use perspective_js::utils::{ApiFuture, ApiResult};
 
 use super::pipeline::RunOrigin;
-use super::restore_and_render;
+use super::transactional_restore::restore_in_place;
 use crate::config::{
     ColumnConfigUpdate, OptionalUpdate, PluginConfigUpdate, PluginUpdate, ViewerConfigUpdate,
 };
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::session::{ResetOptions, Session};
+use crate::session::{OpKind, ResetOptions, Session};
 
 /// Reset the viewer's `ViewerConfig` to the default.
 ///
@@ -37,7 +37,7 @@ use crate::session::{ResetOptions, Session};
 /// futures like this one) and error, rather than this task spawning unowned
 /// work.
 ///
-/// Delegates plugin selection + draw to [`restore_and_render`], whose
+/// Delegates plugin selection + draw to [`restore_in_place`], 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
@@ -49,8 +49,27 @@ pub fn reset_all(
     all: bool,
 ) -> ApiFuture<()> {
     presentation.set_open_column_settings(None);
-    clone!(session, renderer, presentation);
-    ApiFuture::new(async move {
+    let ticket = session.submit(OpKind::Restore { update: None }, {
+        clone!(session, renderer, presentation);
+        move |_ctx| {
+            Box::pin(async move {
+                reset_all_step(&session, &renderer, &presentation, all).await?;
+                Ok(None)
+            })
+        }
+    });
+
+    ApiFuture::new(ticket.settle())
+}
+
+/// The body of [`reset_all`], run as one op on the panel's queue.
+async fn reset_all_step(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    all: bool,
+) -> ApiResult<()> {
+    {
         session
             .reset(ResetOptions {
                 config: true,
@@ -65,10 +84,10 @@ pub fn reset_all(
             // `reset_theme` only resets the host, which an explicitly-themed
             // panel would otherwise keep overriding.
             presentation.reset_theme().await?;
-            renderer.set_theme(presentation.get_default_theme_name().await);
+            renderer.commit_theme(presentation.get_default_theme_name().await);
         }
 
-        // For `all = true`, route the bucket clears through `restore_and_render`'s
+        // For `all = true`, route the bucket clears through the restore'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
@@ -93,16 +112,8 @@ pub fn reset_all(
 
         // `reset()` is a public element API — `Public` keeps its repaint
         // affordance even on an already-default config.
-        restore_and_render(
-            &session,
-            &renderer,
-            &presentation,
-            RunOrigin::Public,
-            update,
-            async { Ok(()) },
-        )
-        .await?;
+        restore_in_place(session, renderer, presentation, RunOrigin::Public, update).await?;
         renderer.reset_changed.emit(());
         Ok(())
-    })
+    }
 }

package/src/rust/tasks/restore_derived.rs

@@ -0,0 +1,200 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Reconcile the workspace's derived `Table`s with a restored
+//! `derived_tables` map.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use perspective_js::utils::*;
+
+use crate::config::{DerivedTableConfig, OptionalUpdate, ViewerConfigUpdate};
+use crate::derived::topo_order;
+use crate::presentation::Presentation;
+use crate::session::MissingTable;
+use crate::tasks::{RestoreErrors, RestoreMode, build_derived, restore_panel};
+use crate::workspace::Workspace;
+
+/// Build every derivation in `configs` that is not already reusable,
+/// parents-first, deferring any whose parent is not yet hosted.
+pub async fn apply_derived_tables(
+    workspace: &Workspace,
+    configs: BTreeMap<String, DerivedTableConfig>,
+) -> ApiResult<()> {
+    let order = topo_order(&configs).map_err(ApiError::new)?;
+    let reuse = workspace.derived_reusable(&order, &configs);
+
+    // Delete the stale generations children-first BEFORE building: a
+    // non-reusable name's old registration otherwise blocks its parent's
+    // redefinition (the parent's consumer count includes the stale child,
+    // and the engine refuses to delete a table the child's view reads).
+    for name in order.iter().rev() {
+        if reuse.contains(name) || !workspace.is_derived(name) {
+            continue;
+        }
+
+        let consumers = workspace.derived_consumers(name);
+        if consumers > 0 {
+            return Err(ApiError::new(format!(
+                "Cannot redefine `{name}` while {consumers} panels or tables read it"
+            )));
+        }
+
+        if let Some(stale) = workspace.take_derived(name) {
+            stale.delete().await?;
+        }
+    }
+
+    let mut deferred = BTreeMap::new();
+    for name in &order {
+        let config = &configs[name];
+        if reuse.contains(name) {
+            continue;
+        }
+
+        if deferred.contains_key(&config.table) {
+            deferred.insert(name.clone(), config.clone());
+            continue;
+        }
+
+        let Some(client) = workspace
+            .resolve_client_for_table(&config.table, None)
+            .await
+        else {
+            deferred.insert(name.clone(), config.clone());
+            continue;
+        };
+
+        if !build_derived(&client, workspace, name, &config.table, &config.view_config).await? {
+            deferred.insert(name.clone(), config.clone());
+        }
+    }
+
+    workspace.set_derived_pending(deferred);
+    Ok(())
+}
+
+/// Delete every registered derivation absent from `keep`, children first.
+pub async fn prune_derived(workspace: &Workspace, keep: &BTreeSet<String>) -> ApiResult<()> {
+    let mut doomed = workspace
+        .derived_names()
+        .into_iter()
+        .filter(|name| !keep.contains(name))
+        .collect::<Vec<_>>();
+
+    doomed.sort_by_key(|name| std::cmp::Reverse(workspace.derived_ancestors(name).len()));
+    for name in doomed {
+        if workspace.derived_consumers(&name) > 0 {
+            tracing::warn!("Keeping derived table \"{name}\", which is still read");
+            continue;
+        }
+
+        if let Some(derived) = workspace.take_derived(&name)
+            && let Err(err) = derived.delete().await
+        {
+            tracing::warn!("Failed to delete derived table \"{name}\": {err}");
+        }
+    }
+
+    Ok(())
+}
+
+/// Retry the derivations whose parent was not hosted when they were restored.
+pub async fn resume_derived(workspace: &Workspace) -> ApiResult<()> {
+    let pending = workspace.derived_pending();
+    if pending.is_empty() {
+        return Ok(());
+    }
+
+    let mut configs = workspace.derived_configs();
+    configs.extend(pending);
+    apply_derived_tables(workspace, configs).await
+}
+
+/// Tear down the element's ENTIRE derived state (the "all" reset): release
+/// every panel bound or pending to a derived (or pending-derived) table to
+/// its root ancestor, clear the pending registry, and delete every
+/// registered derivation children-first.
+pub async fn purge_derived(workspace: &Workspace, presentation: &Presentation) -> ApiResult<()> {
+    let pending = workspace.derived_pending();
+    if workspace.derived_names().is_empty() && pending.is_empty() {
+        return Ok(());
+    }
+
+    let parent_of = |name: &str| {
+        workspace
+            .derived_config(name)
+            .map(|x| x.table)
+            .or_else(|| pending.get(name).map(|x| x.table.clone()))
+    };
+
+    let root_of = |name: &str| {
+        let mut seen = BTreeSet::new();
+        let mut cursor = name.to_owned();
+        while seen.insert(cursor.clone()) {
+            match parent_of(&cursor) {
+                Some(parent) => cursor = parent,
+                None => break,
+            }
+        }
+
+        cursor
+    };
+
+    let active = workspace.active_id();
+    let mut rebinds = Vec::new();
+    for panel in workspace.panels() {
+        let Some(bound) = panel
+            .session
+            .get_table()
+            .map(|x| x.get_name().to_owned())
+            .or_else(|| panel.session.pending_table())
+        else {
+            continue;
+        };
+
+        if parent_of(&bound).is_none() {
+            continue;
+        }
+
+        let update = ViewerConfigUpdate {
+            table: OptionalUpdate::Update(root_of(&bound).into()),
+            ..ViewerConfigUpdate::default()
+        };
+
+        let is_active = active.as_ref() == Some(&panel.id);
+        let presentation = presentation.clone();
+        let workspace = workspace.clone();
+        rebinds.push(async move {
+            restore_panel(
+                &panel.session,
+                &panel.renderer,
+                &presentation,
+                &workspace,
+                RestoreMode::Existing { active: is_active },
+                update,
+                RestoreErrors::Publish,
+                MissingTable::Pend,
+                None,
+            )
+            .await
+        });
+    }
+
+    futures::future::join_all(rebinds)
+        .await
+        .into_iter()
+        .collect::<ApiResult<Vec<_>>>()?;
+
+    workspace.set_derived_pending(BTreeMap::new());
+    prune_derived(workspace, &BTreeSet::new()).await
+}