@perspective-dev/viewer 5.2.0 → 5.3.1

package/src/rust/components/viewer/msg.rs

@@ -22,7 +22,9 @@ use wasm_bindgen::JsValue;
 
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab, DragDropProps, PresentationProps};
+use crate::presentation::{
+    ColumnSettingsTab, ColumnSettingsTarget, DragDropProps, PresentationProps,
+};
 use crate::renderer::RendererProps;
 use crate::session::{SessionProps, TableLoadState, ViewStats};
 use crate::utils::Completion;
@@ -48,17 +50,19 @@ pub enum PerspectiveViewerMsg {
     ColumnSettingsPanelSizeUpdate(Option<i32>),
     ColumnSettingsPanelAutoWidth(f64),
     ToggleColumnSettingsPin,
+    ToggleColumnSettingsPinComplete(Sender<()>),
     ColumnSettingsTabChanged(ColumnSettingsTab),
     OpenColumnSettings {
-        locator: Option<ColumnLocator>,
+        target: Option<ColumnSettingsTarget>,
         sender: Option<Sender<()>>,
         toggle: bool,
     },
     PreloadFontsUpdate,
 
     /// Element-level reset (the public `reset()` API): reset EVERY panel and
-    /// clear the cross-filter overlay, symmetric with whole-element
-    /// `save`/`restore`. The `bool` also clears expressions/column settings.
+    /// clear the cross-filter overlay, symmetric with
+    /// `saveWorkspace`/`restoreWorkspace`. The `bool` also clears
+    /// expressions/column settings.
     Reset(bool, Option<Completion>),
 
     /// Reset ONLY the named panel — or the active panel when `None` — to its
@@ -86,10 +90,10 @@ pub enum PerspectiveViewerMsg {
     /// I6) — carrying any teardown error, which was previously dropped.
     ClosePanel(String, Option<Completion>),
 
-    /// Whole-element `restore` finished replacing the panel set in the
+    /// `restoreWorkspace` finished replacing the panel set in the
     /// `Workspace` (new models inserted, old panels ejected, layout staged):
     /// activate the named panel, re-subscribe the per-panel wiring, and
-    /// re-render — the SINGLE visible commit of the whole restore.
+    /// re-render — the SINGLE visible commit of the restore.
     CommitWorkspaceRestore(String),
 
     /// Duplicate the named panel: snapshot its config into a new independent
@@ -149,8 +153,34 @@ pub enum PerspectiveViewerMsg {
     SettingsPanelTabChanged(SelectedTab),
     SettingsPanelAutoWidth(f64),
     ToggleDebug,
+
+    /// The toggle choreography's INTERNAL completion leaf: flip the pane
+    /// and resolve on the render commit. Never send this to toggle
+    /// settings from outside `settings.rs` — it skips the presize/resize
+    /// sweep (the pane's `SplitPanel` emits no `before-resize` and the
+    /// host box is unchanged, so nothing else resizes the plugins), which
+    /// leaves canvas plugins CSS-stretched at their old backing size. API
+    /// entry points send [`Self::ToggleSettingsInit`].
     ToggleSettingsComplete(SettingsUpdate, Sender<()>),
-    ToggleSettingsInit(Option<SettingsUpdate>, Option<Sender<ApiResult<JsValue>>>),
+
+    /// Toggle (or force) the settings pane with the FULL choreography:
+    /// presize every visible plugin to its post-toggle box, commit the
+    /// pane, then the exactness-finalizer resize. The `Sender` resolves
+    /// after the sweep. The one settings-toggle entry point for both the
+    /// toolbar and the element API (`toggleConfig`, `restore({settings})`,
+    /// `restoreWorkspace`).
+    ///
+    /// The `bool` is `announce`: `true` when this toggle is the SOLE
+    /// carrier of the config change (a user gesture — toolbar,
+    /// `toggleConfig`), which emits `toggle-settings` + one
+    /// `perspective-config-update`; `false` for the `restore` family,
+    /// whose own view-config commit dispatch announces the settings field
+    /// — one API call, one config-update.
+    ToggleSettingsInit(
+        Option<SettingsUpdate>,
+        bool,
+        Option<Sender<ApiResult<JsValue>>>,
+    ),
     UpdateSession(Box<SessionProps>),
     UpdateRenderer(Box<RendererProps>),
     UpdatePresentation(Box<PresentationProps>),
@@ -161,7 +191,16 @@ pub enum PerspectiveViewerMsg {
     UpdateIsWorkspace(bool),
 
     /// Update only `open_column_settings` in the presentation snapshot.
+    /// Handled in `settings.rs` (not `snapshots.rs`): a docked-drawer
+    /// mount/unmount defers the snapshot behind a presize sweep.
     UpdateColumnSettings(Box<crate::presentation::OpenColumnSettings>),
+
+    /// Every visible panel has rendered at its post-transition box — NOW
+    /// apply the newest deferred `open_column_settings` target (the
+    /// latest-wins slot, not a copy captured at sweep spawn); the `Sender`
+    /// resolves on the render commit so the staged presents reveal in the
+    /// same paint (mirrors `ToggleSettingsComplete`).
+    UpdateColumnSettingsCommit(Sender<()>),
     UpdateDragDrop(Box<DragDropProps>),
 
     /// Update only stats-related fields of `session_props` without touching

package/src/rust/components/viewer/panels.rs

@@ -27,7 +27,7 @@ use super::wiring::{
     clear_active_callbacks, create_active_subscriptions, inject_active_callbacks,
     subscribe_panel_titles,
 };
-use crate::config::{ViewerConfigInitial, ViewerConfigUpdate};
+use crate::config::ViewerConfigInitial;
 use crate::queries::*;
 use crate::renderer::Renderer;
 use crate::session::*;
@@ -124,7 +124,7 @@ impl PerspectiveViewer {
         }
     }
 
-    /// Whole-element `restore`'s single commit: the `Workspace` already holds
+    /// `restoreWorkspace`'s single commit: the `Workspace` already holds
     /// the final panel set (models inserted, olds ejected) and the staged
     /// layout. Re-subscribe the per-panel title wiring (the set changed
     /// wholesale), activate the restored panel, and re-render — `MainPanel`'s
@@ -193,7 +193,8 @@ impl PerspectiveViewer {
                     })
                     .await?;
 
-                let update = ViewerConfigUpdate::decode(&config.encode()?)?;
+                // TODO(texodus): what the ****?
+                let update = ViewerConfigInitial::decode(&config.encode()?)?;
                 let client = panel.session.get_client();
                 let new_id = create_panel(
                     &elem,
@@ -235,7 +236,7 @@ impl PerspectiveViewer {
                     &workspace,
                     &notify,
                     None,
-                    ViewerConfigInitial::new(table_name).into(),
+                    ViewerConfigInitial::new(table_name),
                     client,
                 )
                 .await?;
@@ -279,7 +280,7 @@ impl PerspectiveViewer {
                 &workspace,
                 &notify,
                 None,
-                ViewerConfigInitial::new(table).into(),
+                ViewerConfigInitial::new(table),
                 Some(client),
             )
             .await?;
@@ -308,11 +309,12 @@ impl PerspectiveViewer {
         let presentation = ctx.props().presentation.clone();
         let workspace = ctx.props().workspace.clone();
         ApiFuture::spawn(async move {
-            let default_theme = presentation.get_default_theme_name().await;
-            if let Some(renderer) = workspace.active_renderer()
-                && let Some(theme) = renderer.theme().or(default_theme)
-            {
+            // Only an EXPLICITLY themed panel mirrors onto the host; an
+            // unpinned one inherits whatever the host already shows, so
+            // activating it must not restate (and thereby pin) that value.
+            if let Some(theme) = workspace.active_renderer().and_then(|x| x.theme()) {
                 presentation.set_theme_name(Some(&theme)).await?;
+                presentation.publish_theme_config().await?;
             }
 
             Ok(())

package/src/rust/components/viewer/render.rs

@@ -53,7 +53,7 @@ impl PerspectiveViewer {
         }
 
         let on_open_expr_panel = ctx.link().callback(|c| OpenColumnSettings {
-            locator: c,
+            target: c,
             sender: None,
             toggle: true,
         });
@@ -62,7 +62,9 @@ impl PerspectiveViewer {
             .link()
             .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
 
-        let on_close_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_close_settings = ctx
+            .link()
+            .callback(|()| ToggleSettingsInit(None, true, None));
         let on_debug = ctx.link().callback(|_| ToggleDebug);
         let selected_column = get_current_column_locator(
             &self.presentation_props.open_column_settings,
@@ -116,7 +118,9 @@ impl PerspectiveViewer {
             html! { <></> }
         };
 
-        let on_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_settings = ctx
+            .link()
+            .callback(|()| ToggleSettingsInit(None, true, None));
         let on_select_tab = ctx.link().callback(ColumnSettingsTabChanged);
         // Pinning the drawer is a pure CSS positioning flip on `#modal_panel`
         // (absolute overlay over the main panel <-> static flex sibling
@@ -153,6 +157,7 @@ impl PerspectiveViewer {
                         {presentation}
                         {renderer}
                         {session}
+                        workspace={ctx.props().workspace.clone()}
                     />
                     <></>
                 </SplitPanel>

package/src/rust/components/viewer/settings.rs

@@ -25,7 +25,8 @@ use super::msg::PerspectiveViewerMsg::*;
 use crate::components::font_loader::FontLoaderStatus;
 use crate::components::settings_panel::SelectedTab;
 use crate::config::*;
-use crate::presentation::{ColumnLocator, ColumnSettingsTab};
+use crate::presentation::{ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings};
+use crate::queries::get_current_column_locator;
 use crate::tasks::*;
 
 /// The settings sidebar's geometry state, folded into one field on
@@ -69,6 +70,19 @@ pub(super) struct SettingsGeometry {
     /// than FLOATING over the main panel (the default absolute overlay).
     /// Session UI state, not part of the saved config.
     pub column_settings_pinned: bool,
+
+    /// Latest-wins deferred `open_column_settings` snapshot: the newest
+    /// target not yet applied while a docked-drawer presize sweep is in
+    /// flight. `UpdateColumnSettingsCommit` applies THIS slot (not a copy
+    /// captured at spawn), so a newer target arriving mid-sweep wins and
+    /// out-of-order commits are inexpressible.
+    pub column_settings_target: Option<OpenColumnSettings>,
+    pub column_settings_commit_pending: bool,
+
+    /// The docked drawer's span, cached whenever it is measurable (pin
+    /// toggle, docked unmount) - used to presize for a drawer that MOUNTS
+    /// directly into pinned mode, when it isn't in the DOM to measure.
+    pub column_settings_docked_width: Option<f64>,
 }
 
 impl PerspectiveViewer {
@@ -76,6 +90,7 @@ impl PerspectiveViewer {
         &mut self,
         ctx: &Context<Self>,
         update: Option<SettingsUpdate>,
+        announce: bool,
         resolve: Option<Sender<ApiResult<JsValue>>>,
     ) -> bool {
         match (update, resolve) {
@@ -85,15 +100,15 @@ impl PerspectiveViewer {
                 false
             },
             (Some(SettingsUpdate::SetDefault), resolve) => {
-                self.init_toggle_settings_task(ctx, Some(false), resolve);
+                self.init_toggle_settings_task(ctx, Some(false), announce, resolve);
                 false
             },
             (Some(SettingsUpdate::Update(force)), resolve) => {
-                self.init_toggle_settings_task(ctx, Some(force), resolve);
+                self.init_toggle_settings_task(ctx, Some(force), announce, resolve);
                 false
             },
             (None, resolve) => {
-                self.init_toggle_settings_task(ctx, None, resolve);
+                self.init_toggle_settings_task(ctx, None, announce, resolve);
                 false
             },
         }
@@ -150,10 +165,10 @@ impl PerspectiveViewer {
         &mut self,
         ctx: &Context<Self>,
         force: Option<bool>,
+        announce: bool,
         sender: Option<Sender<ApiResult<JsValue>>>,
     ) {
         let is_open = ctx.props().presentation.is_settings_open();
-        ctx.props().presentation.set_settings_before_open(!is_open);
         match force {
             Some(force) if is_open == force => {
                 if let Some(sender) = sender {
@@ -161,6 +176,7 @@ impl PerspectiveViewer {
                 }
             },
             Some(_) | None => {
+                ctx.props().presentation.set_settings_before_open(!is_open);
                 let force = !is_open;
                 let callback = ctx.link().callback(move |resolve| {
                     let update = SettingsUpdate::Update(force);
@@ -195,7 +211,7 @@ impl PerspectiveViewer {
                             let presents = presize_visible_panels_grown(&workspace, &elem).await;
                             let (notify, rendered) = channel::<()>();
                             callback.emit(notify);
-                            presentation.set_settings_open(false);
+                            presentation.set_settings_open(false, announce);
                             rendered.await?;
                             // `notify` fires in `rendered()` (same task as the
                             // Yew DOM patch) and this future resumes as one of
@@ -219,7 +235,7 @@ impl PerspectiveViewer {
 
                             let (notify, rendered) = channel::<()>();
                             callback.emit(notify);
-                            presentation.set_settings_open(true);
+                            presentation.set_settings_open(true, announce);
                             rendered.await?;
                             presents.reveal();
                             resize_visible_panels(&workspace).await;
@@ -339,36 +355,34 @@ impl PerspectiveViewer {
     pub(super) fn on_open_column_settings(
         &mut self,
         ctx: &Context<Self>,
-        locator: Option<ColumnLocator>,
+        target: Option<ColumnSettingsTarget>,
         sender: Option<Sender<()>>,
         toggle: bool,
     ) -> bool {
         let mut open_column_settings = ctx.props().presentation.get_open_column_settings();
-        if locator == open_column_settings.locator {
+        if target == open_column_settings.target {
             if toggle {
                 ctx.props().presentation.set_open_column_settings(None);
             }
         } else {
-            open_column_settings.locator.clone_from(&locator);
-            open_column_settings.tab = if matches!(locator, Some(ColumnLocator::NewExpression)) {
-                Some(ColumnSettingsTab::Attributes)
-            } else {
-                locator.as_ref().and_then(|x| {
-                    x.name().map(|x| {
-                        if self.session_props.is_column_active(x) {
-                            ColumnSettingsTab::Style
-                        } else {
-                            ColumnSettingsTab::Attributes
-                        }
+            open_column_settings.target.clone_from(&target);
+            open_column_settings.tab = match &target {
+                Some(ColumnSettingsTarget::NewExpression) => Some(ColumnSettingsTab::Attributes),
+                Some(ColumnSettingsTarget::Column(name)) => {
+                    Some(if self.session_props.is_column_active(name) {
+                        ColumnSettingsTab::Style
+                    } else {
+                        ColumnSettingsTab::Attributes
                     })
-                })
+                },
+                None => None,
             };
 
             ctx.props()
                 .presentation
                 .set_open_column_settings(Some(open_column_settings));
 
-            if locator.is_some() {
+            if target.is_some() {
                 self.settings_geometry.selected_tab = SelectedTab::Query;
             }
         }
@@ -402,9 +416,135 @@ impl PerspectiveViewer {
         }
     }
 
-    pub(super) fn on_toggle_column_settings_pin(&mut self) -> bool {
+    pub(super) fn on_toggle_column_settings_pin(&mut self, ctx: &Context<Self>) -> bool {
+        let is_pinned = self.settings_geometry.column_settings_pinned;
+        let delta_w = measure_column_settings_pin_delta(&ctx.props().elem, is_pinned);
+        if let Some(delta_w) = delta_w {
+            self.settings_geometry.column_settings_docked_width = Some(delta_w.abs());
+        }
+
+        self.presize_column_settings_shift(ctx, delta_w, ToggleColumnSettingsPinComplete);
+        false
+    }
+
+    pub(super) fn on_toggle_column_settings_pin_complete(&mut self, resolve: Sender<()>) -> bool {
         self.settings_geometry.column_settings_pinned =
             !self.settings_geometry.column_settings_pinned;
+        self.on_rendered.push(resolve);
+        true
+    }
+
+    /// Shared presize choreography for a column-settings geometry shift:
+    /// pre-size every visible panel by `delta_w` (`None` = no sweep, commit
+    /// only), send `commit_msg` to apply the deferred state on the render
+    /// commit, reveal the staged frames in that same paint, then reactively
+    /// finalize at the exact settled cells (I6).
+    fn presize_column_settings_shift(
+        &self,
+        ctx: &Context<Self>,
+        delta_w: Option<f64>,
+        commit_msg: fn(Sender<()>) -> super::msg::PerspectiveViewerMsg,
+    ) {
+        let workspace = ctx.props().workspace.clone();
+        let elem = ctx.props().elem.clone();
+        let callback = ctx.link().callback(commit_msg);
+        ApiFuture::spawn(async move {
+            let presents = match delta_w {
+                Some(delta_w) => presize_visible_panels_open(&workspace, &elem, delta_w, 0.0).await,
+                None => StagedPresents::default(),
+            };
+
+            let (notify, rendered) = channel::<()>();
+            callback.emit(notify);
+            rendered.await?;
+            presents.reveal();
+            resize_visible_panels(&workspace).await;
+            Ok(())
+        });
+    }
+
+    /// Whether the drawer renders for this `open_column_settings` snapshot
+    /// (the `render()` mount predicate). Sensitive to the session snapshot
+    /// too — `snapshots.rs` re-evaluates it across an `UpdateSession` apply,
+    /// which can invalidate the open column's locator (e.g. a drag
+    /// replacing it in `columns`) and unmount the drawer without any
+    /// `UpdateColumnSettings` traffic.
+    pub(super) fn is_column_settings_mounted(&self, ocs: &OpenColumnSettings) -> bool {
+        get_current_column_locator(
+            ocs,
+            &self.active_renderer,
+            &self.session_props.config,
+            &self.session_props.metadata,
+        )
+        .is_some()
+    }
+
+    /// The `open_column_settings` snapshot handler: mount/unmount of the
+    /// DOCKED drawer moves `#main_panel_container`'s flex box just like the
+    /// pin toggle — and no `before-resize` fires for it — so those
+    /// transitions defer the snapshot behind the presize choreography.
+    /// Floating transitions and in-place locator changes apply synchronously
+    /// as before, unless a deferred commit is in flight (they queue into the
+    /// latest-wins slot to preserve commit order).
+    pub(super) fn on_update_column_settings(
+        &mut self,
+        ctx: &Context<Self>,
+        ocs: OpenColumnSettings,
+    ) -> bool {
+        self.refresh_session_snapshot(ctx);
+        let effective = self
+            .settings_geometry
+            .column_settings_target
+            .as_ref()
+            .unwrap_or(&self.presentation_props.open_column_settings);
+        if ocs == *effective {
+            return false;
+        }
+
+        let was_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
+        let will_mount = self.is_column_settings_mounted(&ocs);
+        let needs_presize =
+            self.settings_geometry.column_settings_pinned && was_mounted != will_mount;
+        if !needs_presize && !self.settings_geometry.column_settings_commit_pending {
+            self.presentation_props.open_column_settings = ocs;
+            return true;
+        }
+
+        self.settings_geometry.column_settings_target = Some(ocs);
+        if self.settings_geometry.column_settings_commit_pending {
+            return false;
+        }
+
+        self.settings_geometry.column_settings_commit_pending = true;
+        let delta_w = if !needs_presize {
+            None
+        } else if was_mounted {
+            // Unmounting - the docked drawer is still in the DOM, and its
+            // freed span is the same measurement as an unpin.
+            let delta = measure_column_settings_pin_delta(&ctx.props().elem, true);
+            if let Some(delta) = delta {
+                self.settings_geometry.column_settings_docked_width = Some(delta.abs());
+            }
+
+            delta
+        } else {
+            // Mounting directly into pinned mode - not yet in the DOM; the
+            // span cached at the last dock/unmount predicts the shrink.
+            self.settings_geometry.column_settings_docked_width
+        };
+
+        self.presize_column_settings_shift(ctx, delta_w, UpdateColumnSettingsCommit);
+        false
+    }
+
+    pub(super) fn on_update_column_settings_commit(&mut self, resolve: Sender<()>) -> bool {
+        self.settings_geometry.column_settings_commit_pending = false;
+        self.on_rendered.push(resolve);
+        if let Some(ocs) = self.settings_geometry.column_settings_target.take() {
+            self.presentation_props.open_column_settings = ocs;
+        }
+
         true
     }
 

package/src/rust/components/viewer/snapshots.rs

@@ -15,17 +15,45 @@
 //! subscriptions/callbacks) into the root's props fields, re-rendering only
 //! on an actual change.
 
+use futures::channel::oneshot::channel;
+use perspective_js::utils::ApiFuture;
 use yew::prelude::*;
 
 use super::PerspectiveViewer;
-use crate::presentation::{DragDropProps, OpenColumnSettings, PresentationProps};
+use crate::presentation::{DragDropProps, PresentationProps};
 use crate::renderer::RendererProps;
 use crate::session::{SessionProps, TableLoadState, ViewStats};
+use crate::tasks::resize_visible_panels;
 
 impl PerspectiveViewer {
-    pub(super) fn on_update_session(&mut self, props: SessionProps) -> bool {
+    pub(super) fn refresh_session_snapshot(&mut self, ctx: &Context<Self>) {
+        let props = self.active_session.to_props();
+        if props != self.session_props {
+            self.on_update_session(ctx, props);
+        }
+    }
+
+    pub(super) fn on_update_session(&mut self, ctx: &Context<Self>, props: SessionProps) -> bool {
         let changed = props != self.session_props;
+        let was_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
         self.session_props = props;
+        let now_mounted =
+            self.is_column_settings_mounted(&self.presentation_props.open_column_settings);
+        if self.settings_geometry.column_settings_pinned
+            && was_mounted != now_mounted
+            && !self.settings_geometry.column_settings_commit_pending
+        {
+            let (notify, rendered) = channel::<()>();
+            self.on_rendered.push(notify);
+            let workspace = ctx.props().workspace.clone();
+            ApiFuture::spawn(async move {
+                rendered.await?;
+                resize_visible_panels(&workspace).await;
+                Ok(())
+            });
+        }
+
         changed
     }
 
@@ -52,18 +80,17 @@ impl PerspectiveViewer {
         ctx: &Context<Self>,
         props: PresentationProps,
     ) -> bool {
-        // Default-theme fan-out: when the registry default (first available
-        // theme) changes — the async theme discovery resolving at boot, or a
-        // `resetThemes` — push the new default into every panel's renderer
-        // cache (locked draws stamp the effective theme from it), and
-        // restyle the panels whose captured `--psp-*` CSS is STALE against
-        // the new effective value (`Renderer::needs_restyle` — the plugin's
-        // captured theme is the baseline; plugins only re-read CSS at
-        // `restyle()`/first-draw, so a plain redraw would not repaint a
-        // panel that first drew before discovery resolved, while a panel
-        // that captured post-discovery — or owes its first paint — restyles
-        // nothing). The outer default-diff scopes the scan; the per-panel
-        // gate is state, never call history or DOM state.
+        // Boot fill-in: theme discovery resolving turns an empty registry
+        // into a real one, and any panel created before that has no theme to
+        // stamp. Give those — and ONLY those — the new default, then restyle
+        // the ones whose captured `--psp-*` CSS is now stale
+        // (`Renderer::needs_restyle`; plugins re-read CSS only at
+        // `restyle()`/first-draw, so a plain redraw would not repaint them).
+        //
+        // A panel that already has a theme is never touched here: `theme` is
+        // concrete state, so re-ordering the registry — or any other
+        // `resetThemes` that leaves a panel's theme available — must repaint
+        // nothing.
         let old_default = self.presentation_props.available_themes.first().cloned();
         let new_default = props.available_themes.first().cloned();
         if old_default != new_default {
@@ -74,7 +101,11 @@ impl PerspectiveViewer {
                 .into_iter()
                 .filter_map(|id| ctx.props().workspace.panel(&id))
             {
-                panel.renderer.set_default_theme(new_default.clone());
+                if panel.renderer.theme().is_some() {
+                    continue;
+                }
+
+                panel.renderer.set_theme(new_default.clone());
                 if panel.renderer.needs_restyle() {
                     let renderer = panel.renderer.clone();
                     crate::utils::spawn_owned("default-theme-restyle", async move {
@@ -102,12 +133,6 @@ impl PerspectiveViewer {
         changed
     }
 
-    pub(super) fn on_update_column_settings(&mut self, ocs: OpenColumnSettings) -> bool {
-        let changed = ocs != self.presentation_props.open_column_settings;
-        self.presentation_props.open_column_settings = ocs;
-        changed
-    }
-
     pub(super) fn on_update_dragdrop(&mut self, props: DragDropProps) -> bool {
         let changed = props != self.dragdrop_props;
         self.dragdrop_props = props;

package/src/rust/components/viewer/wiring.rs

@@ -343,7 +343,9 @@ pub(super) fn create_active_subscriptions(
 pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> Vec<Subscription> {
     let presentation_props_sub = {
         let presentation = ctx.props().presentation.clone();
-        let cb_settings = ctx.link().callback(UpdateSettingsOpen);
+        let cb_settings = ctx
+            .link()
+            .callback(|(open, _): (bool, bool)| UpdateSettingsOpen(open));
         let cb_theme = {
             let pres = presentation.clone();
             ctx.link()
@@ -368,17 +370,6 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
         vec![sub1, sub2, sub3]
     };
 
-    let dragdrop_props_sub = {
-        let cb_clear = ctx.link().callback(|_: ()| UpdateDragDrop(Box::default()));
-        let sub1 = ctx
-            .props()
-            .presentation
-            .drop_received
-            .add_notify_listener(&cb_clear);
-
-        vec![sub1]
-    };
-
     // The `Workspace`-owned global filter set → the root's render snapshot.
     let filters_sub = {
         let cb = ctx.link().callback(|_: ()| UpdateGlobalFilters);
@@ -388,11 +379,12 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
             .add_notify_listener(&cb)
     };
 
-    // Staged-set transitions (`Workspace::stage_panel`/`clear_staged`) → a
-    // root re-render for the stage-level chrome (`only-child` class,
-    // binding resync). `MainPanel` inserts/reveals promoted panels via its
-    // OWN `staged_changed` subscription (`MainPanelMsg::StagedChanged`) —
-    // see `WorkspaceData::staged_changed`.
+    // Panel-phase transitions (`Workspace::insert_panel` at
+    // `PanelPhase::Staging` / `Workspace::promote`) → a root re-render for
+    // the stage-level chrome (`only-child` class, binding resync).
+    // `MainPanel` inserts/reveals promoted panels via its OWN
+    // `staged_changed` subscription (`MainPanelMsg::StagedChanged`) — see
+    // `WorkspaceData::staged_changed`.
     let staged_sub = {
         let cb = ctx.link().callback(|_: ()| LayoutChanged);
         ctx.props()
@@ -403,7 +395,6 @@ pub(super) fn create_shared_subscriptions(ctx: &Context<PerspectiveViewer>) -> V
 
     let mut subscriptions = Vec::new();
     subscriptions.extend(presentation_props_sub);
-    subscriptions.extend(dragdrop_props_sub);
     subscriptions.push(filters_sub);
     subscriptions.push(staged_sub);
     subscriptions
@@ -446,15 +437,13 @@ pub(super) fn inject_active_callbacks(
         let cb = ctx.link().batch_callback(move |limits: RenderLimits| {
             let mut msgs = vec![UpdateRenderer(Box::new(r.to_props(Some(limits))))];
             if !limits.is_update {
-                let locator = get_current_column_locator(
-                    &presentation.get_open_column_settings(),
-                    &r,
-                    &s.get_view_config(),
-                    &s.metadata(),
-                );
+                let ocs = presentation.get_open_column_settings();
+                let still_open =
+                    get_current_column_locator(&ocs, &r, &s.get_view_config(), &s.metadata())
+                        .is_some();
 
                 msgs.push(OpenColumnSettings {
-                    locator,
+                    target: ocs.target.filter(|_| still_open),
                     sender: None,
                     toggle: false,
                 });