@perspective-dev/viewer 5.3.0 → 5.4.0

package/src/rust/components/datetime_column_style.rs

@@ -22,11 +22,10 @@ use perspective_js::utils::global::navigator;
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
 
-use super::modal::{ModalLink, SetModalLink};
 use crate::components::datetime_column_style::custom::DatetimeStyleCustom;
 use crate::components::datetime_column_style::simple::DatetimeStyleSimple;
-use crate::components::form::select_value_field::SelectValueField;
 use crate::config::*;
+use crate::ui::{ModalLink, SelectValueField, SetModalLink};
 use crate::utils::WeakScope;
 
 /// Format-only widget for `datetime` columns. Renders the `date_format`
@@ -38,6 +37,9 @@ pub struct DatetimeColumnStyleProps {
     pub enable_time_config: bool,
     pub config: Option<DatetimeColumnStyleConfig>,
 
+    /// The active plugin's declared default `date_format`.
+    pub default_format: Rc<DatetimeFormatType>,
+
     #[prop_or_default]
     pub on_change: Callback<ColumnConfigFieldUpdate>,
 
@@ -57,7 +59,9 @@ impl ModalLink<DatetimeColumnStyle> for DatetimeColumnStyleProps {
 
 impl PartialEq for DatetimeColumnStyleProps {
     fn eq(&self, other: &Self) -> bool {
-        self.enable_time_config == other.enable_time_config && self.config == other.config
+        self.enable_time_config == other.enable_time_config
+            && self.config == other.config
+            && self.default_format == other.default_format
     }
 }
 
@@ -90,7 +94,9 @@ impl Component for DatetimeColumnStyle {
             std::mem::swap(&mut self.config, &mut new_config);
             rerender = true;
         }
-        if old.enable_time_config != ctx.props().enable_time_config {
+        if old.enable_time_config != ctx.props().enable_time_config
+            || old.default_format != ctx.props().default_format
+        {
             rerender = true;
         }
         rerender
@@ -99,22 +105,24 @@ impl Component for DatetimeColumnStyle {
     fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
         match msg {
             DatetimeColumnStyleMsg::TimezoneChanged(val) => {
+                let mut format = self.effective_format(ctx);
                 if Some(&*USER_TIMEZONE) != val.as_ref() {
-                    *self.config.date_format.time_zone_mut() = val;
+                    *format.time_zone_mut() = val;
                 } else {
-                    *self.config.date_format.time_zone_mut() = None;
+                    *format.time_zone_mut() = None;
                 }
 
+                self.set_format(ctx, format);
                 self.dispatch_config(ctx);
                 true
             },
             DatetimeColumnStyleMsg::SimpleDatetimeStyleConfigChanged(simple) => {
-                self.config.date_format = DatetimeFormatType::Simple(simple);
+                self.set_format(ctx, DatetimeFormatType::Simple(simple));
                 self.dispatch_config(ctx);
                 true
             },
             DatetimeColumnStyleMsg::CustomDatetimeStyleConfigChanged(custom) => {
-                self.config.date_format = DatetimeFormatType::Custom(custom);
+                self.set_format(ctx, DatetimeFormatType::Custom(custom));
                 self.dispatch_config(ctx);
                 true
             },
@@ -122,6 +130,24 @@ impl Component for DatetimeColumnStyle {
     }
 
     fn view(&self, ctx: &Context<Self>) -> Html {
+        let format = self.effective_format(ctx);
+        let (date_style_default, time_style_default) = match &*ctx.props().default_format {
+            DatetimeFormatType::Simple(simple) => (simple.date_style, simple.time_style),
+            DatetimeFormatType::Custom(_) => {
+                (SimpleDatetimeFormat::Short, SimpleDatetimeFormat::Medium)
+            },
+        };
+
+        let simple_reset = {
+            let default_format = ctx.props().default_format.clone();
+            ctx.link().callback(move |_| {
+                DatetimeColumnStyleMsg::SimpleDatetimeStyleConfigChanged(match &*default_format {
+                    DatetimeFormatType::Simple(simple) => simple.clone(),
+                    DatetimeFormatType::Custom(_) => SimpleDatetimeStyleConfig::default(),
+                })
+            })
+        };
+
         html! {
             <>
                 <div id="column-style-container" class="datetime-column-style-container">
@@ -131,10 +157,10 @@ impl Component for DatetimeColumnStyle {
                             values={ALL_TIMEZONES.with(|x| (*x).clone())}
                             default_value={(*USER_TIMEZONE).clone()}
                             on_change={ctx.link().callback(DatetimeColumnStyleMsg::TimezoneChanged)}
-                            current_value={self.config.date_format.time_zone().as_ref().unwrap_or(&*USER_TIMEZONE).clone()}
+                            current_value={format.time_zone().as_ref().unwrap_or(&*USER_TIMEZONE).clone()}
                         />
                     }
-                    if let DatetimeFormatType::Simple(config) = &self.config.date_format {
+                    if let DatetimeFormatType::Simple(config) = &format {
                         if ctx.props().enable_time_config {
                             <div class="row">
                                 <button
@@ -149,15 +175,17 @@ impl Component for DatetimeColumnStyle {
                             enable_time_config={ctx.props().enable_time_config}
                             on_change={ctx.link().callback(DatetimeColumnStyleMsg::SimpleDatetimeStyleConfigChanged)}
                             config={config.clone()}
+                            {date_style_default}
+                            {time_style_default}
                         />
-                    } else if let DatetimeFormatType::Custom(config) = &self.config.date_format {
+                    } else if let DatetimeFormatType::Custom(config) = &format {
                         if ctx.props().enable_time_config {
                             <div class="row">
                                 <button
                                     id="datetime_format"
                                     data-title="Custom"
                                     data-title-hover="Switch to Simple"
-                                    onclick={ctx.link().callback(|_| DatetimeColumnStyleMsg::SimpleDatetimeStyleConfigChanged(SimpleDatetimeStyleConfig::default()))}
+                                    onclick={simple_reset}
                                 />
                             </div>
                         }
@@ -201,6 +229,17 @@ static USER_TIMEZONE: LazyLock<String> = LazyLock::new(|| {
 });
 
 impl DatetimeColumnStyle {
+    fn effective_format(&self, ctx: &Context<Self>) -> DatetimeFormatType {
+        self.config
+            .date_format
+            .clone()
+            .unwrap_or_else(|| (*ctx.props().default_format).clone())
+    }
+
+    fn set_format(&mut self, ctx: &Context<Self>, format: DatetimeFormatType) {
+        self.config.date_format = (format != *ctx.props().default_format).then_some(format);
+    }
+
     /// When this config has changed, we must signal the wrapper element.
     fn dispatch_config(&self, ctx: &Context<Self>) {
         let value = if self.config == DatetimeColumnStyleConfig::default() {

package/src/rust/components/{form/debug.rs → debug_panel.rs}

@@ -17,7 +17,7 @@ use perspective_js::utils::{ApiFuture, JsValueSerdeExt};
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
 
-use crate::components::form::code_editor::CodeEditor;
+use crate::components::code_editor::CodeEditor;
 use crate::js::{MimeType, copy_to_clipboard, paste_from_clipboard};
 use crate::presentation::*;
 use crate::renderer::*;
@@ -169,10 +169,10 @@ pub fn debug_panel(props: &DebugPanelProps) -> Html {
             <div id="debug-panel-overflow">
                 <div id="debug-panel" class="sidebar_column" ref={sizer}>
                     <div id="debug-panel-controls">
-                        <button disabled={!*modified} onclick={onapply}>{ "Apply" }</button>
-                        <button disabled={!*modified} onclick={onreset}>{ "Reset" }</button>
-                        <button onclick={oncopy}>{ "Copy" }</button>
-                        <button onclick={onpaste}>{ "Paste" }</button>
+                        <button id="debug-panel-apply" disabled={!*modified} onclick={onapply} />
+                        <button id="debug-panel-reset" disabled={!*modified} onclick={onreset} />
+                        <button id="debug-panel-copy" onclick={oncopy} />
+                        <button id="debug-panel-paste" onclick={onpaste} />
                     </div>
                     <div id="debug-panel-editor">
                         <CodeEditor

package/src/rust/components/{containers/dragdrop_list.rs → dragdrop_list.rs}

@@ -23,6 +23,7 @@ use crate::components::column_dropdown::ColumnDropDownElement;
 use crate::components::column_selector::{EmptyColumn, InPlaceColumn, InvalidColumn};
 use crate::components::type_icon::TypeIcon;
 use crate::presentation::{DragDropContainer, Presentation};
+use crate::ui::intl_slug;
 use crate::utils::DragTarget;
 
 #[derive(Properties, Derivative)]
@@ -405,16 +406,7 @@ where
         // here while the var VALUE stays in the stylesheets - custom
         // properties inherit, so the label's `:before` picks it up.
         let role_style = ctx.props().role_label.as_ref().map(|role| {
-            let slug = role
-                .chars()
-                .map(|x| {
-                    if x.is_ascii_alphanumeric() {
-                        x.to_ascii_lowercase()
-                    } else {
-                        '-'
-                    }
-                })
-                .collect::<String>();
+            let slug = intl_slug(role);
 
             // The second var is a PRESENCE FLAG: CSS cannot ask whether a
             // custom property is set, so the slot's stylesheet reads it as

package/src/rust/components/export_dropdown.rs

@@ -14,10 +14,10 @@ use std::rc::Rc;
 
 use yew::prelude::*;
 
-use super::containers::dropdown_menu::*;
 use crate::config::*;
 use crate::renderer::*;
 use crate::session::Session;
+use crate::ui::{DropDownMenu, DropDownMenuItem};
 
 pub type ExportDropDownMenuItem = DropDownMenuItem<ExportFile>;
 

package/src/rust/components/expression_editor.rs

@@ -15,7 +15,7 @@ use std::rc::Rc;
 use perspective_client::{ExprValidationError, clone};
 use yew::prelude::*;
 
-use super::form::code_editor::*;
+use super::code_editor::CodeEditor;
 use crate::session::{Session, SessionMetadataRc};
 use crate::tasks::{ExprValidation, validate_expression};
 

package/src/rust/components/filter_dropdown.rs

@@ -19,9 +19,9 @@ use web_sys::*;
 use yew::html::ImplicitClone;
 use yew::prelude::*;
 
-use super::portal::PortalModal;
 use super::style::StyleSurface;
 use crate::session::Session;
+use crate::ui::PortalModal;
 use crate::utils::*;
 use crate::*;
 
@@ -219,7 +219,7 @@ impl Component for FilterDropDownPortal {
             html! {
                 <PortalModal
                     tag_name="perspective-dropdown"
-                    surface={StyleSurface::FilterDropdown}
+                    sheet={StyleSurface::FilterDropdown.sheet()}
                     {target}
                     own_focus=false
                     {on_close}

package/src/rust/components/function_dropdown.rs

@@ -19,8 +19,8 @@ use web_sys::*;
 use yew::html::ImplicitClone;
 use yew::prelude::*;
 
-use super::portal::PortalModal;
 use super::style::StyleSurface;
+use crate::ui::PortalModal;
 use crate::utils::*;
 
 #[derive(Default)]
@@ -157,7 +157,7 @@ impl Component for FunctionDropDownPortal {
             html! {
                 <PortalModal
                     tag_name="perspective-dropdown"
-                    surface={StyleSurface::FunctionDropdown}
+                    sheet={StyleSurface::FunctionDropdown.sheet()}
                     {target}
                     own_focus=false
                     {on_close}

package/src/rust/components/main_panel/frame_theme.rs

@@ -21,42 +21,6 @@
 //! own per-panel themed background), but while the plugin is missing — not yet
 //! mounted, first draw pending, or torn down — the host-theme container shows
 //! through a panel themed differently, as a visible artifact.
-//!
-//! There is no native cascade channel from the light-DOM plugin to the frame
-//! (siblings in the flattened tree), so the value is mirrored imperatively:
-//! each panel's *plugin element* — light-DOM, slotted under the panel's slot,
-//! mounted eagerly at panel creation (`create_panel_model` /
-//! `Renderer::mount_active_plugin`) — is where the document theme rules
-//! actually resolve, so its computed `--psp--background-color` is copied onto
-//! the frame's inline style, where the frame's shadow parts inherit it. The
-//! plugin is the ONLY sound source element:
-//!
-//! - An owned hidden probe child of the viewer does NOT work: an *unslotted*
-//!   light-DOM child of a shadow host is outside the flattened tree, and
-//!   `getComputedStyle` returns all-empty for it even though the document rules
-//!   match it syntactically (selector matching is DOM-tree; style computation
-//!   is flat-tree).
-//! - The `<perspective-viewer-tab>` is slotted, but stamps its own `theme` attr
-//!   in `PanelTab::rendered` — an unordered sibling lifecycle relative to this
-//!   pass (the theme-stamp-lag class of bug).
-//! - The plugin's `theme` attr, by contrast, is stamped *synchronously at the
-//!   mutation sites* (`update_theme`, `restorePanel`, …) before the events that
-//!   schedule this render, so it is current when this pass reads it.
-//!
-//! A read is trusted ONLY when the plugin's stamped attr equals the theme
-//! being mirrored: a freshly-created panel's plugin is mounted *unstamped*
-//! (the attr first lands inside its first locked dispatch), and reading it
-//! early would silently mirror the HOST theme's values. Trusted reads seed
-//! [`MainPanel::theme_backgrounds`], the fallback for frames with no readable
-//! plugin (an unregistered plugin name stays lazily unmounted; plugin-switch
-//! and teardown transients). A frame with neither leaves the pass gate
-//! unlatched, so it retries on subsequent renders until the dispatch stamp
-//! lands (the render that follows that dispatch's `update_count` bump).
-//!
-//! Unlike the plugin `theme`/`active` stamps (see the NOTE in [`reconcile`]),
-//! the frame is pure viewer chrome — no plugin dispatch reads it — so
-//! stamping it from this async `rendered` pass cannot split a plugin draw
-//! across paints, and it needs no lock.
 
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
@@ -69,12 +33,7 @@ use crate::workspace::PanelId;
 /// `.rl-panel::part(container)` background resolves.
 const BACKGROUND_VAR: &str = "--psp--background-color";
 
-/// The inputs the frame backgrounds were last computed from; re-mirroring is
-/// skipped while these are unchanged, so the forced style recalcs of
-/// `getComputedStyle` don't run on every render (e.g. the per-update
-/// `update_count` renders of a streaming table). `available_themes` is part of
-/// the key because theme CSS registering late changes the *computed* value
-/// under an unchanged theme name.
+/// The inputs the frame backgrounds were last computed from.
 pub(super) type FrameThemeSnapshot = (
     Vec<PanelId>,
     Vec<(String, Option<String>)>,
@@ -82,12 +41,7 @@ pub(super) type FrameThemeSnapshot = (
 );
 
 impl MainPanel {
-    /// Mirror each panel's effective theme background (its own theme, else the
-    /// registry default — the same fallback the tab/menu use) onto its
-    /// `<regular-layout-frame>`'s inline `--psp--background-color`, read off
-    /// the panel's stamped plugin element (else the theme-keyed cache of prior
-    /// reads). A panel with no resolvable theme has the property removed,
-    /// falling back to the inherited host-theme value.
+    /// Mirror each panel's effective theme background.
     pub(super) fn stamp_frame_themes(&mut self, ctx: &Context<Self>) {
         let Some(layout) = self.layout_ref.cast::<web_sys::Element>() else {
             return;
@@ -104,8 +58,6 @@ impl MainPanel {
             return;
         }
 
-        // A theme-registry change can re-value an unchanged theme name, so
-        // cached reads from the previous registry are unsound.
         if let Some((_, _, prev_themes)) = &self.stamped_frame_themes
             && prev_themes != &snapshot.2
         {
@@ -155,19 +107,11 @@ impl MainPanel {
             }
         }
 
-        // Latch only a fully-resolved pass; an unresolved frame (unmounted or
-        // not-yet-stamped plugin) retries each render until its dispatch
-        // stamp lands.
         self.stamped_frame_themes = complete.then_some(snapshot);
     }
 }
 
-/// Read the computed [`BACKGROUND_VAR`] off `slot`'s plugin element — the
-/// viewer light-DOM child mounted under exactly that slot name (the tab and
-/// toolbar use `tab-`/`statusbar-extra-` prefixed slots). Requires the
-/// plugin's `theme` attr to already equal `theme` — during a plugin switch
-/// two elements briefly share the slot, and a freshly-mounted plugin is not
-/// yet stamped; both are disambiguated by the attr check.
+/// Read the computed [`BACKGROUND_VAR`] off `slot`'s plugin element.
 fn read_plugin_background(viewer: &web_sys::Element, slot: &str, theme: &str) -> Option<String> {
     let children = viewer.children();
     let plugin = (0..children.length())

package/src/rust/components/main_panel/reconcile.rs

@@ -190,16 +190,21 @@ impl MainPanel {
             self.inserted.push(name.to_owned());
         }
 
-        // Remove cells whose panels are gone.
+        let mut pending = std::mem::take(&mut self.pending_removals);
         self.inserted.retain(|name| {
             if panel_ids.iter().any(|id| id.as_str() == name) {
-                true
-            } else {
+                return true;
+            }
+
+            if pending.insert(name.clone()) {
                 let _ = layout.remove_panel(name);
-                false
             }
+
+            true
         });
 
+        self.pending_removals = pending;
+
         // A removed panel can't stay "maximized" (regular-layout drops the
         // maximize stylesheet when its panel leaves the layout).
         if let Some(m) = &self.maximized

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

@@ -18,7 +18,8 @@ use wasm_bindgen::prelude::*;
 use yew::prelude::*;
 
 use super::{MainPanel, MainPanelMsg, MainPanelProps};
-use crate::components::panel_menu::PanelMenu;
+use crate::components::new_panel_menu::NewPanelPick;
+use crate::components::panel_menu::{PanelCommand, PanelMenu};
 use crate::components::panel_tab::PanelTab;
 use crate::components::render_warning::RenderWarning;
 use crate::components::status_bar::StatusBar;
@@ -73,14 +74,26 @@ impl MainPanel {
             let active_slot = renderer.slot_name();
             // Panel-count chrome (`single`/`multi`, closable, draggable)
             let placed_count = ctx.props().workspace.placed_count();
+            let closing = self
+                .inserted
+                .iter()
+                .filter(|name| !ctx.props().panel_ids.iter().any(|id| id.as_str() == *name))
+                .map(|name| PanelId::from(name.as_str()))
+                .collect::<Vec<_>>();
             let cells = ctx
                 .props()
                 .panel_ids
                 .iter()
                 .filter(|id| !ctx.props().workspace.is_staged(id))
-                .map(|id| {
+                .map(|id| (id, false))
+                .chain(closing.iter().map(|id| (id, true)))
+                .map(|(id, is_closing)| {
                     let name = id.as_str().to_owned();
                     let mut class = classes!("rl-panel");
+                    if is_closing {
+                        class.push("closing");
+                    }
+
                     if placed_count > 1 {
                         if active_slot.as_deref() == Some(name.as_str()) {
                             class.push("active");
@@ -103,7 +116,9 @@ impl MainPanel {
                     let on_activate = ctx.props().on_activate_panel.clone();
                     let activate_name = name.clone();
                     let onpointerdown = Callback::from(move |_: web_sys::PointerEvent| {
-                        on_activate.emit(activate_name.clone());
+                        if !is_closing {
+                            on_activate.emit(activate_name.clone());
+                        }
                     });
 
                     // Right-click anywhere in the panel opens the context menu. This
@@ -214,23 +229,41 @@ impl MainPanel {
                     on_settings.emit(());
                 })
             };
+            let closing_tabs = closing.iter().filter_map(|id| {
+                let panel = ctx.props().workspace.closing_panel(id)?;
+                let title = panel.session.get_title().filter(|t| !t.is_empty());
+                let theme = panel.renderer.theme().or_else(|| {
+                    ctx.props()
+                        .presentation_props
+                        .available_themes
+                        .first()
+                        .cloned()
+                });
+                Some((id, panel.session, title, theme, true))
+            });
             let tabs = ctx
                 .props()
                 .panel_ids
                 .iter()
                 .filter(|id| !ctx.props().workspace.is_staged(id))
-                .map(|id| {
-                    let name = id.as_str().to_owned();
+                .filter_map(|id| {
+                    let panel = ctx.props().workspace.panel(id)?;
+                    let name = id.as_str();
                     let title = ctx
                         .props()
                         .panel_titles
                         .iter()
-                        .find(|(pid, _)| pid == &name)
+                        .find(|(pid, _)| pid == name)
                         .and_then(|(_, t)| t.clone());
-                    let active = active_slot.as_deref() == Some(name.as_str());
+                    let theme = ctx.props().effective_panel_theme(name);
+                    Some((id, panel.session, title, theme, false))
+                })
+                .chain(closing_tabs)
+                .map(|(id, session, title, theme, is_closing)| {
+                    let name = id.as_str().to_owned();
+                    let active = !is_closing && active_slot.as_deref() == Some(name.as_str());
                     let visible = !self.hidden_tabs.contains(name.as_str());
-                    let is_master = ctx.props().panel_masters.contains(id);
-                    let theme = ctx.props().effective_panel_theme(&name);
+                    let is_master = !is_closing && ctx.props().panel_masters.contains(id);
 
                     html! {
                         <PanelTab
@@ -238,14 +271,16 @@ impl MainPanel {
                             viewer={viewer_elem.clone()}
                             panel_id={name.clone()}
                             {title}
+                            {session}
                             {theme}
                             {active}
                             {visible}
                             {is_master}
                             {single}
-                            {closable}
+                            closable={closable && !is_closing}
                             {is_settings_open}
-                            {draggable}
+                            draggable={draggable && !is_closing}
+                            closing={is_closing}
                             on_select={on_select.clone()}
                             on_close={on_close.clone()}
                             on_open_settings={on_open_settings.clone()}
@@ -349,11 +384,27 @@ impl MainPanel {
             })
             .unwrap_or_default();
 
+        let on_new_panel = {
+            let on_command = ctx.props().on_panel_command.clone();
+            let id = renderer.slot_name().unwrap_or_default();
+            Callback::from(move |pick: NewPanelPick| {
+                let cmd = match pick {
+                    NewPanelPick::FromTable { client, table } => {
+                        PanelCommand::NewFrom { client, table }
+                    },
+                    NewPanelPick::FromPanel(source) => PanelCommand::NewFromPanel(source),
+                };
+
+                on_command.emit((id.clone(), cmd));
+            })
+        };
+
         html! {
             <div id="main_column">
                 <StatusBar
                     id="status_bar"
                     on_reset={ctx.props().on_reset.clone()}
+                    {on_new_panel}
                     session_props={ctx.props().session_props.clone()}
                     presentation_props={ctx.props().presentation_props.clone()}
                     is_settings_open={ctx.props().is_settings_open}

package/src/rust/components/main_panel/update.rs

@@ -22,6 +22,7 @@ use yew::prelude::*;
 use super::MainPanel;
 use crate::components::panel_menu::PanelCommand;
 use crate::js::{Layout, RegularLayout};
+use crate::renderer::SUBPIXEL_EPSILON;
 use crate::tasks::resize_callback;
 
 impl MainPanel {
@@ -42,11 +43,9 @@ impl MainPanel {
         false
     }
 
+    /// Report closed every panel this commit dropped from the layout, and
+    /// re-render so its frame leaves the DOM in the commit's paint.
     pub(super) fn on_layout_updated(&mut self, ctx: &Context<Self>) -> bool {
-        // A panel still tracked in `inserted` but no longer present in
-        // the layout (calculatePath → null) was removed by the layout —
-        // i.e. its frame's close button was pressed. Report it for
-        // disposal.
         let Some(el) = self.layout_ref.cast::<web_sys::HtmlElement>() else {
             return false;
         };
@@ -68,10 +67,14 @@ impl MainPanel {
             }
         });
 
+        let closed_any = !closed.is_empty();
         for id in closed {
-            ctx.props().on_close_panel.emit(id);
+            self.pending_removals.remove(&id);
+            ctx.props().on_panel_closed.emit(id);
         }
 
+        let reissue = self.forget_dropped_removals(&layout);
+
         // A layout change (divider drag, insert, restore) reflows the
         // grid cells without resizing the host, so the host
         // `ResizeObserver` never fires. Resize every activated panel's
@@ -92,6 +95,19 @@ impl MainPanel {
             if let Some(panel) = ctx.props().workspace.panel(id)
                 && panel.renderer.is_plugin_activated().unwrap_or(false)
             {
+                if let Some((w, h)) = panel.renderer.take_presized_box()
+                    && let Some(plugin) = panel.renderer.active_plugin()
+                {
+                    let rect = plugin
+                        .unchecked_ref::<web_sys::Element>()
+                        .get_bounding_client_rect();
+                    if (rect.width() - w).abs() <= SUBPIXEL_EPSILON
+                        && (rect.height() - h).abs() <= SUBPIXEL_EPSILON
+                    {
+                        continue;
+                    }
+                }
+
                 resize_callback(&panel.session, &panel.renderer).emit(());
             }
         }
@@ -111,10 +127,27 @@ impl MainPanel {
             self.hidden_tabs = hidden;
             true
         } else {
-            false
+            closed_any || reissue
         }
     }
 
+    /// Forget every issued removal whose panel survived the commit, so the
+    /// next `reconcile` re-issues it.
+    fn forget_dropped_removals(&mut self, layout: &RegularLayout) -> bool {
+        let dropped = self
+            .pending_removals
+            .iter()
+            .filter(|id| layout.contains_panel(id))
+            .cloned()
+            .collect::<Vec<_>>();
+        let reissue = !dropped.is_empty();
+        for id in dropped {
+            self.pending_removals.remove(&id);
+        }
+
+        reissue
+    }
+
     pub(super) fn on_tab_selected(&self, ctx: &Context<Self>, name: String) -> bool {
         ctx.props().on_activate_panel.emit(name);
         false
@@ -169,10 +202,6 @@ impl MainPanel {
 
                 self.maximized = None;
             },
-            // The stage menu (no target panel) offers ONLY `NewFrom`, whose
-            // handler resolves the client/table purely from the loaded-clients
-            // registry — the panel id is unused there, so the empty id never
-            // reaches a panel lookup.
             cmd => ctx
                 .props()
                 .on_panel_command