@perspective-dev/viewer 5.2.0 → 5.3.0

package/src/rust/session/metadata.rs

@@ -187,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()?
@@ -197,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.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
@@ -70,29 +70,19 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
 }
 
 /// Create a new independent panel (own `Session` + `Renderer` + id) and
-/// restore `update` into it. Shared by `addPanel`, `restore`'s
-/// create-if-missing upsert, and `restorePanel`. `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.
-///
-/// A `table` is OPTIONAL here: an update with none creates a deferred
-/// panel that a later `load()` binds, which is the pre-existing
-/// `restore`-then-`load` contract and the same state the reserved
-/// `load()` path produces. The routes where a table-less panel WOULD be
-/// permanently blank require one in their own argument types instead —
-/// `addPanel`'s [`ViewerConfigInitial`], `WorkspaceConfigUpdate`'s
-/// `panels` entries, and the agent's `add_panel` — so the guarantee sits
-/// at the boundary that owns it rather than here, which would sweep
-/// `restore`'s patch in with them.
+/// 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(
@@ -100,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.
@@ -146,7 +125,7 @@ pub(crate) async fn create_panel(
 
     // 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(());
     }
 
@@ -156,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.
@@ -180,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()) {
@@ -221,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)
@@ -230,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(())
 }
 
@@ -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()

package/src/rust/tasks/pipeline.rs

@@ -285,12 +285,12 @@ pub(crate) async fn locked_run(
 
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
-                renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config);
+                renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
             let columns_config_changed = renderer.update_columns_configs(
                 &view_config_snapshot,
                 &session,
                 spec.columns_config,
-            );
+            )?;
 
             let changed = plugin_config_changed || columns_config_changed;
             if changed || plugin_swapped {

package/src/rust/tasks/presize_panels.rs

@@ -131,11 +131,14 @@ pub async fn presize_visible_panels_grown(
     presize_visible_panels_scaled(workspace, elem, width_ratio, height_ratio).await
 }
 
-/// Pre-size each visible plugin to its SHRUNK post-open cell *before* the
-/// settings pane mounts (P2), using the open-state geometry deltas cached at
-/// the last close (`(layout_area.w − mpc.w, main_column.h − mpc.h)` — the pane
-/// and divider width and the docked status-bar height, both stable across a
-/// close/open cycle since the pane width persists in the override).
+/// Pre-size each visible plugin to its cell SHRUNK by `(delta_w, delta_h)` —
+/// GROWN when a delta is negative — *before* the layout change commits. Used
+/// by the settings-pane open (P2, deltas `(layout_area.w − mpc.w,
+/// main_column.h − mpc.h)` cached at the last close — the pane and divider
+/// width and the docked status-bar height, both stable across a close/open
+/// cycle since the pane width persists in the override) and by the
+/// column-settings pin toggle and docked-drawer mount/unmount (signed delta
+/// measured live at toggle time).
 pub async fn presize_visible_panels_open(
     workspace: &Workspace,
     elem: &web_sys::HtmlElement,
@@ -199,6 +202,7 @@ async fn presize_visible_panels_scaled(
         return StagedPresents::default();
     }
 
+    let mpc = shadow_rect(elem, "#main_panel_container");
     let mut last_chrome: Option<(f64, f64)> = None;
     let targets = workspace
         .panels()
@@ -222,6 +226,23 @@ async fn presize_visible_panels_scaled(
 
             last_chrome = chrome.or(last_chrome);
             let (cw, ch) = last_chrome.unwrap_or(super::CHROME_FALLBACK);
+
+            // Per axis, chrome can never exceed the container's
+            // non-plugin remainder: with no sibling panel on that axis,
+            // `mpc − box` IS the exact chrome, while the frame-margin
+            // measurement overcounts (margins that overlap container
+            // padding) — the source of a ~2px target miss that pushed
+            // every commit past the plugin transport's ±0.5px resize
+            // dedupe, costing an extra corrective render. With siblings
+            // the remainder is large and the measured chrome wins.
+            let (cw, ch) = match &mpc {
+                Some(mpc) => (
+                    cw.min((mpc.width() - plugin_box.width()).max(0.0)),
+                    ch.min((mpc.height() - plugin_box.height()).max(0.0)),
+                ),
+                None => (cw, ch),
+            };
+
             let w = ((plugin_box.width() + cw) * width_ratio - cw).max(0.0);
             let h = ((plugin_box.height() + ch) * height_ratio - ch).max(0.0);
             Some((panel, w, h))
@@ -300,6 +321,24 @@ pub fn measure_settings_open_deltas(elem: &web_sys::HtmlElement) -> Option<(f64,
     ))
 }
 
+/// The signed `#main_panel_container` width delta a column-settings pin
+/// toggle will cause: the docked `#modal_panel`'s flex box spans its drawer
+/// child plus the overlapping divider (`drawer.right − divider.left`, the
+/// same span in both modes since `.pinned` reparents nothing) — PINNING
+/// takes it from the main column (positive, shrink), UNPINNING releases it
+/// back (negative, grow). `None` when the drawer isn't mounted.
+pub fn measure_column_settings_pin_delta(
+    elem: &web_sys::HtmlElement,
+    is_pinned: bool,
+) -> Option<f64> {
+    let drawer = shadow_rect(elem, "#modal_panel > .split-panel-child:first-child")?;
+    let divider_left = shadow_rect(elem, "#modal_panel > .split-panel-divider")
+        .map(|r| r.left())
+        .unwrap_or_else(|| drawer.left());
+    let width = (drawer.right() - divider_left).max(0.0);
+    Some(if is_pinned { -width } else { width })
+}
+
 /// The frame chrome a plugin's grid cell has that the plugin itself doesn't
 /// occupy, as `(width, height)` px: margin + border + titlebar. Measured live
 /// from a `regular-layout-frame` and its plugin — robust to theme/CSS changes —

package/src/rust/tasks/reset_all.rs

@@ -61,11 +61,11 @@ pub fn reset_all(
 
         presentation.reset_available_themes(None).await;
         if all {
-            // Clear this panel's own per-panel theme so it reverts to inheriting
-            // the (reset-to-default) host theme — `reset_theme` only resets the
-            // host, which an explicitly-themed panel would otherwise override.
-            renderer.set_theme(None);
+            // Put this panel back on the registry default CONCRETELY —
+            // `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);
         }
 
         // For `all = true`, route the bucket clears through `restore_and_render`'s

package/src/rust/tasks/restore_and_render.rs

@@ -18,6 +18,7 @@ use futures::Future;
 use perspective_client::clone;
 
 use super::pipeline::{RunOrigin, RunSpec, locked_run};
+use super::update_theme::seed_panel_theme;
 use crate::config::{OptionalUpdate, ViewerConfigUpdate};
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
@@ -70,11 +71,6 @@ pub fn restore_and_render(
             session.set_title(None);
         }
 
-        // Mirror a config-carried theme onto the host attribute (the shared
-        // chrome). The restyle a theme change requires is owned by the
-        // MUTATION SITES (`restorePanel`'s own-theme tail, the theme-picker
-        // task), not here — this run's own draw below already stamps the new
-        // effective theme before the plugin's first style read.
         match theme_name {
             OptionalUpdate::SetDefault => {
                 let current_name = presentation.get_selected_theme_name().await;
@@ -83,59 +79,31 @@ pub fn restore_and_render(
                 }
             },
             OptionalUpdate::Update(x) => {
-                // No pre-resolution gate: `set_theme_name` stamps the host
-                // attribute SYNCHRONOUSLY before its registry await and
-                // no-ops on literal equality itself. The old
-                // `get_selected_theme_name().await` guard was precisely
-                // the former-theme window on a cold registry — the host
-                // held the old attribute until stylesheet parsing (and
-                // everything queued behind it) resolved.
                 presentation.set_theme_name(Some(&x)).await?;
             },
             _ => {},
         };
 
-        // Resolve the target plugin here (pure — needed now for
-        // `set_update_column_defaults`), but COMMIT it only inside the locked
-        // run below, atomically with the view rebind it belongs to. No swap
-        // intent may exist outside that run: an unrelated run that wins the
-        // lock first (e.g. a `table_updated` redraw) must observe either the
-        // fully-old or fully-new world, never a staged half of this one.
         let resolved_plugin = renderer.resolve_plugin_update(&plugin);
         if let Some((_, metadata)) = &resolved_plugin {
             session.set_update_column_defaults(&mut view_config, metadata);
         } else {
-            // Same-plugin (or plugin-less) restore: `resolve_plugin_update`
-            // returns `None`, but the plugin-advised `group_rollup_mode`
-            // must STILL be enforced against the active plugin's metadata —
-            // `restorePanel`'s table-change reset wipes the committed mode,
-            // and nothing else on this path would restore it, leaving a
-            // flat-only chart (Treemap / Sunburst) rendering rollup
-            // subtotal rows. Rollup only; the full column-defaults pass is
-            // reserved for plugin swaps, where `columns` genuinely needs
-            // re-defaulting.
-            session.set_update_rollup_defaults(&mut view_config, &renderer.metadata());
+            let metadata = if renderer.active_plugin().is_none() {
+                renderer
+                    .resolve_plugin_update(&OptionalUpdate::SetDefault)
+                    .map(|(_, metadata)| metadata)
+                    .unwrap_or_else(|| renderer.metadata())
+            } else {
+                renderer.metadata()
+            };
+
+            session.set_update_rollup_defaults(&mut view_config, &metadata);
         }
 
         let plugin_idx = resolved_plugin.map(|(idx, _)| idx);
-
-        // The config COMMIT: synchronous, validated, atomic (I1/I4). Under
-        // I2/I3 committing before the lock is safe — whichever queued run
-        // snapshots next picks it up, and this run's own snapshot (taken
-        // inside the lock below) can only be this commit or fresher.
         session.commit_view_config(view_config)?;
-
-        // Spinner accounting (RAII): held to the end of this restore —
-        // INCLUDING the deferred-draw exit (no table yet → no
-        // `bind_snapshot`), which under the old edge-counted scheme
-        // stranded the `StatusIndicator` spinner permanently.
         let _run_token = session.begin_config_run();
-
-        // Awaits theme-registry init, so the stamp below can never observe a
-        // pre-init (empty) theme set on a cold first load. Seeds this
-        // panel's renderer default-theme cache, which every locked draw
-        // stamps the effective theme from.
-        renderer.set_default_theme(presentation.get_default_theme_name().await);
+        seed_panel_theme(&presentation, &renderer).await;
         locked_run(&session, &renderer, RunSpec {
             origin,
             plugin_idx,
@@ -146,6 +114,11 @@ pub fn restore_and_render(
         })
         .await?;
 
+        if renderer.needs_restyle() {
+            renderer.restyle_all().await?;
+        }
+
+        presentation.publish_theme_config().await?;
         Ok(())
     })
 }