@perspective-dev/viewer 5.2.0 → 5.3.1

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!(
@@ -62,7 +68,7 @@ pub impl ViewConfigUpdate {
         if !split_rollups.contains(
             self.split_rollup_mode
                 .as_ref()
-                .unwrap_or(&SplitRollupMode::Flat),
+                .unwrap_or(&current.split_rollup_mode),
         ) {
             self.split_rollup_mode = split_rollups.first().cloned();
             tracing::debug!(
@@ -81,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

@@ -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 —