@perspective-dev/viewer 4.5.2 → 5.0.0

package/src/rust/tasks/presize_panels.rs

@@ -0,0 +1,324 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Presize/resize sweeps over the [`Workspace`]'s visible panels, plus the DOM
+//! geometry measurements they (and `MainPanel`'s `before-resize` presize)
+//! depend on. These implement the presize-everywhere architecture: every
+//! geometry change renders each plugin at its *target* box before the layout
+//! commits, so content never lags its container.
+
+use std::future::Future;
+
+use futures::channel::oneshot::channel;
+use futures::future::join_all;
+use perspective_js::utils::*;
+use wasm_bindgen::JsCast;
+
+use crate::workspace::Workspace;
+
+/// Resize every *visible* panel's plugin to its current cell box, concurrently.
+/// Used after a layout change that does NOT emit `regular-layout-before-resize`
+/// — settings-panel toggle (the outer SplitPanel) and maximize/minimize — so
+/// the per-panel `ResizeObserver` (now scoped to drags) isn't needed to catch
+/// them. Hidden panels (e.g. an unselected stacked tab → null `offset_parent`)
+/// are skipped; they resize when revealed. `resize()` debounces per renderer.
+pub async fn resize_visible_panels(workspace: &Workspace) {
+    let panels = workspace
+        .panels()
+        .into_iter()
+        .filter(|panel| {
+            // `offset_parent` is `None` for a `display:none` cell.
+            panel
+                .renderer
+                .active_plugin()
+                .and_then(|plugin| {
+                    plugin
+                        .unchecked_ref::<web_sys::HtmlElement>()
+                        .offset_parent()
+                })
+                .is_some()
+        })
+        .collect::<Vec<_>>();
+
+    join_all(panels.iter().map(|p| p.renderer.resize())).await;
+}
+
+/// The present closures collected from a presize sweep — the deferred
+/// "reveal" half of the staged-presize protocol
+/// ([`crate::renderer::Renderer::presize_with_dimensions`]). Call
+/// [`Self::reveal`] in the same task as the layout commit the sweep
+/// anticipated, so every panel's staged pixels and the geometry change
+/// reach the screen in a single paint. The reveal runs through `Drop`, so
+/// an error or early-return path between sweep and commit releases every
+/// hold instead of stranding the displays — the pairing invariant is
+/// carried by the value, not by convention.
+#[derive(Default)]
+pub struct StagedPresents(Vec<js_sys::Function>);
+
+impl StagedPresents {
+    /// Reveal every staged frame now (a semantically-named drop; the
+    /// closures are lock-free blits, safe in any task).
+    pub fn reveal(self) {}
+}
+
+impl From<Vec<js_sys::Function>> for StagedPresents {
+    fn from(presents: Vec<js_sys::Function>) -> Self {
+        Self(presents)
+    }
+}
+
+impl Drop for StagedPresents {
+    fn drop(&mut self) {
+        for f in self.0.drain(..) {
+            let _ = f.call0(&wasm_bindgen::JsValue::NULL);
+        }
+    }
+}
+
+/// The `(width, height)` factors each plugin's cell grows by when the settings
+/// pane collapses. The plugin area (`#main_panel_container`) grows to the full
+/// `#layout_area` width (the side settings pane is gone) AND to the full
+/// `#main_column` height — because the status bar switches to
+/// `position:absolute` when settings closes (see `status-bar.css`) and no
+/// longer consumes column height. Each factor defaults to `1.0` if it can't be
+/// measured.
+fn settings_close_grow_ratios(elem: &web_sys::HtmlElement) -> (f64, f64) {
+    let measure = |sel: &str| -> Option<web_sys::DomRect> {
+        elem.shadow_root()?
+            .query_selector(sel)
+            .ok()?
+            .map(|e| e.get_bounding_client_rect())
+    };
+
+    fn ratio(full: Option<f64>, current: Option<f64>) -> f64 {
+        match (full, current) {
+            (Some(f), Some(c)) if c > 0.0 && f > c => f / c,
+            _ => 1.0,
+        }
+    }
+
+    let mpc = measure("#main_panel_container");
+    let width = ratio(
+        measure("#layout_area").map(|r| r.width()),
+        mpc.as_ref().map(|r| r.width()),
+    );
+    let height = ratio(
+        measure("#main_column").map(|r| r.height()),
+        mpc.as_ref().map(|r| r.height()),
+    );
+    (width, height)
+}
+
+/// Pre-size each visible plugin to its GROWN post-close cell *before* the
+/// settings pane collapses, so the pane collapses into an already-correct
+/// plugin — one clean resize instead of grow-then-resize. The cell grows in
+/// BOTH width (the side settings pane is gone) and height (the status bar goes
+/// floating).
+pub async fn presize_visible_panels_grown(
+    workspace: &Workspace,
+    elem: &web_sys::HtmlElement,
+) -> StagedPresents {
+    let (width_ratio, height_ratio) = settings_close_grow_ratios(elem);
+    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).
+pub async fn presize_visible_panels_open(
+    workspace: &Workspace,
+    elem: &web_sys::HtmlElement,
+    delta_w: f64,
+    delta_h: f64,
+) -> StagedPresents {
+    let Some(mpc) = shadow_rect(elem, "#main_panel_container") else {
+        return StagedPresents::default();
+    };
+
+    let (mpc_w0, mpc_h0) = (mpc.width(), mpc.height());
+    if mpc_w0 <= 0.0 || mpc_h0 <= 0.0 {
+        return StagedPresents::default();
+    }
+
+    let width_ratio = (mpc_w0 - delta_w) / mpc_w0;
+    let height_ratio = (mpc_h0 - delta_h) / mpc_h0;
+    presize_visible_panels_scaled(workspace, elem, width_ratio, height_ratio).await
+}
+
+/// Pre-size each visible plugin for a proposed settings-pane width (P1, the
+/// deferred divider's pump). The grid distributes width proportionally, so the
+/// target cells scale by the container's width ratio, derived arithmetically:
+/// `mpc₁ = mpc₀ + (pane₀ − pane₁)`. Height is unaffected by the divider.
+pub async fn presize_visible_panels_pane_width(
+    workspace: &Workspace,
+    elem: &web_sys::HtmlElement,
+    pane_width: f64,
+) -> StagedPresents {
+    let Some(mpc) = shadow_rect(elem, "#main_panel_container") else {
+        return StagedPresents::default();
+    };
+
+    let Some(pane) = shadow_rect(elem, "#app_panel > .split-panel-child") else {
+        return StagedPresents::default();
+    };
+
+    let mpc_w0 = mpc.width();
+    if mpc_w0 <= 0.0 {
+        return StagedPresents::default();
+    }
+
+    let width_ratio = (mpc_w0 + (pane.width() - pane_width)) / mpc_w0;
+    presize_visible_panels_scaled(workspace, elem, width_ratio, 1.0).await
+}
+
+/// Shared presize core: render every visible plugin at its current cell box
+/// scaled by `(width_ratio, height_ratio)` (track space), before the container
+/// change those ratios anticipate.
+async fn presize_visible_panels_scaled(
+    workspace: &Workspace,
+    elem: &web_sys::HtmlElement,
+    width_ratio: f64,
+    height_ratio: f64,
+) -> StagedPresents {
+    if !width_ratio.is_finite()
+        || !height_ratio.is_finite()
+        || width_ratio <= 0.0
+        || height_ratio <= 0.0
+    {
+        return StagedPresents::default();
+    }
+
+    let mut last_chrome: Option<(f64, f64)> = None;
+    let targets = workspace
+        .panels()
+        .into_iter()
+        .filter_map(|panel| {
+            let plugin = panel.renderer.active_plugin()?;
+            let el = plugin.unchecked_ref::<web_sys::Element>();
+            el.unchecked_ref::<web_sys::HtmlElement>().offset_parent()?; // skip hidden
+            let plugin_box = el.get_bounding_client_rect();
+            let chrome = elem
+                .shadow_root()
+                .and_then(|r| {
+                    r.query_selector(&format!(
+                        "regular-layout-frame[name=\"{}\"]",
+                        panel.id.as_str()
+                    ))
+                    .ok()
+                    .flatten()
+                })
+                .and_then(|frame| plugin_chrome(&frame, el));
+
+            last_chrome = chrome.or(last_chrome);
+            let (cw, ch) = last_chrome.unwrap_or(super::CHROME_FALLBACK);
+            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))
+        })
+        .collect::<Vec<_>>();
+
+    staged_presents_with_deadline(
+        workspace.effects().guard(),
+        async move {
+            join_all(
+                targets
+                    .iter()
+                    .map(|(p, w, h)| p.renderer.presize_with_dimensions(*w, *h)),
+            )
+            .await
+            .into_iter()
+            .filter_map(|r| r.ok().flatten())
+            .collect()
+        },
+        || {},
+    )
+    .await
+}
+
+/// Run `work` (a presize sweep producing staged present closures) against
+/// the [`super::STAGING_DEADLINE_MS`] deadline. When `work` wins, its
+/// presents are returned for the caller to reveal in its commit task. When
+/// the deadline wins, an empty [`StagedPresents`] is returned (the caller's
+/// commit proceeds); `work` then finishes late — `late` runs its cleanup and
+/// the presents are revealed immediately, so a hold can never outlive its
+/// prepare. The single consumer makes a double release inexpressible.
+pub(crate) async fn staged_presents_with_deadline(
+    effect: crate::utils::EffectGuard,
+    work: impl Future<Output = Vec<js_sys::Function>> + 'static,
+    late: impl FnOnce() + 'static,
+) -> StagedPresents {
+    let (done, on_done) = channel::<Vec<js_sys::Function>>();
+    ApiFuture::spawn(async move {
+        let _effect = effect;
+        let presents = work.await;
+        if let Err(presents) = done.send(presents) {
+            late();
+            StagedPresents::from(presents).reveal();
+        }
+
+        Ok(())
+    });
+
+    let deadline = crate::utils::set_timeout(super::STAGING_DEADLINE_MS);
+    match futures::future::select(Box::pin(on_done), Box::pin(deadline)).await {
+        futures::future::Either::Left((Ok(presents), _)) => StagedPresents::from(presents),
+        _ => StagedPresents::default(),
+    }
+}
+
+/// Measure a shadow-DOM descendant's border-box rect.
+fn shadow_rect(elem: &web_sys::HtmlElement, sel: &str) -> Option<web_sys::DomRect> {
+    Some(
+        elem.shadow_root()?
+            .query_selector(sel)
+            .ok()??
+            .get_bounding_client_rect(),
+    )
+}
+
+/// The open-state geometry deltas cached for the next settings *open* (P2):
+/// `(layout_area.w − mpc.w, main_column.h − mpc.h)`. Only meaningful while the
+/// settings pane is open (i.e. measured at close time).
+pub fn measure_settings_open_deltas(elem: &web_sys::HtmlElement) -> Option<(f64, f64)> {
+    let mpc = shadow_rect(elem, "#main_panel_container")?;
+    let layout_area = shadow_rect(elem, "#layout_area")?;
+    let main_column = shadow_rect(elem, "#main_column")?;
+    Some((
+        (layout_area.width() - mpc.width()).max(0.0),
+        (main_column.height() - mpc.height()).max(0.0),
+    ))
+}
+
+/// 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 —
+/// rather than hardcoded constants. `real_coordinates` reports the grid TRACK,
+/// which equals the frame's *margin box* (`getBoundingClientRect` + margins);
+/// the plugin fills the frame's container below its titlebar, so `track −
+/// plugin` is exactly the chrome. Returns `None` if it can't be measured.
+pub fn plugin_chrome(frame: &web_sys::Element, plugin: &web_sys::Element) -> Option<(f64, f64)> {
+    let style = web_sys::window()?.get_computed_style(frame).ok()??;
+    let px = |prop: &str| {
+        style
+            .get_property_value(prop)
+            .ok()
+            .and_then(|v| v.trim().trim_end_matches("px").parse::<f64>().ok())
+            .unwrap_or(0.0)
+    };
+    let frame_box = frame.get_bounding_client_rect();
+    let plugin_box = plugin.get_bounding_client_rect();
+    let width = frame_box.width() + px("margin-left") + px("margin-right") - plugin_box.width();
+    let height = frame_box.height() + px("margin-top") + px("margin-bottom") - plugin_box.height();
+    Some((width.max(0.0), height.max(0.0)))
+}

package/src/rust/tasks/reset_all.rs

@@ -14,10 +14,10 @@
 //! presentation columns config / theme, then delegate to `restore_and_render`
 //! to switch back to the default plugin and redraw.
 
-use futures::channel::oneshot;
 use perspective_client::clone;
 use perspective_js::utils::ApiFuture;
 
+use super::pipeline::RunOrigin;
 use super::restore_and_render;
 use crate::config::{
     ColumnConfigUpdate, OptionalUpdate, PluginConfigUpdate, PluginUpdate, ViewerConfigUpdate,
@@ -32,8 +32,10 @@ use crate::session::{ResetOptions, Session};
 ///   per-column style maps.
 /// - `all = true`: also clears expressions, per-column styles, and theme.
 ///
-/// Optionally signals `sender` once the reset+redraw round-trip completes,
-/// then emits `renderer.reset_changed`.
+/// Returns the reset+redraw round-trip's future — the CALLER owns completion
+/// (invariant I6: message handlers resolve their `Completion` only from run
+/// futures like this one) and error, rather than this task spawning unowned
+/// work.
 ///
 /// Delegates plugin selection + draw to [`restore_and_render`], whose
 /// two-pass restore guarantees the default plugin sees materialized
@@ -45,11 +47,10 @@ pub fn reset_all(
     renderer: &Renderer,
     presentation: &Presentation,
     all: bool,
-    sender: Option<oneshot::Sender<()>>,
-) {
+) -> ApiFuture<()> {
     presentation.set_open_column_settings(None);
     clone!(session, renderer, presentation);
-    ApiFuture::spawn(async move {
+    ApiFuture::new(async move {
         session
             .reset(ResetOptions {
                 config: true,
@@ -60,6 +61,10 @@ 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);
             presentation.reset_theme().await?;
         }
 
@@ -86,12 +91,17 @@ pub fn reset_all(
             ..Default::default()
         };
 
-        restore_and_render(&session, &renderer, &presentation, update, async { Ok(()) }).await?;
-
-        if let Some(sender) = sender {
-            sender.send(()).unwrap();
-        }
-
+        // `reset()` is a public element API — `Public` keeps its repaint
+        // affordance even on an already-default config.
+        restore_and_render(
+            &session,
+            &renderer,
+            &presentation,
+            RunOrigin::Public,
+            update,
+            async { Ok(()) },
+        )
+        .await?;
         renderer.reset_changed.emit(());
         Ok(())
     })

package/src/rust/tasks/resize_observer.rs

@@ -10,127 +10,164 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use perspective_js::utils::ApiFuture;
+use futures::future::join_all;
+use perspective_client::clone;
+use perspective_js::utils::{ApiFuture, ApiResult};
 use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::*;
 use web_sys::*;
-use yew::prelude::*;
 
+use super::update_theme::seed_default_themes;
 use crate::components::viewer::{PerspectiveViewer, PerspectiveViewerMsg};
-use crate::js::*;
+use crate::js::{ResizeObserver, ResizeObserverEntry};
 use crate::presentation::Presentation;
-use crate::renderer::*;
+use crate::renderer::Renderer;
 use crate::root::Root;
-use crate::session::{Session, TableLoadState};
-use crate::utils::*;
+use crate::session::TableLoadState;
+use crate::workspace::Workspace;
 
-pub struct ResizeObserverHandle {
+struct SizeObserver {
     elem: HtmlElement,
     observer: ResizeObserver,
     _callback: Closure<dyn FnMut(js_sys::Array)>,
 }
 
-impl ResizeObserverHandle {
-    pub fn new(
-        elem: &HtmlElement,
-        renderer: &Renderer,
-        session: &Session,
-        presentation: &Presentation,
-        root: &Root<PerspectiveViewer>,
-    ) -> Self {
-        let on_resize = root
-            .borrow()
-            .as_ref()
-            .unwrap()
-            .callback(|()| PerspectiveViewerMsg::Resize);
+impl SizeObserver {
+    fn new(elem: &HtmlElement, mut on_change: impl FnMut() + 'static) -> Self {
+        let mut width = elem.offset_width();
+        let mut height = elem.offset_height();
+        let target = elem.clone();
+        let _callback = Closure::new(move |entries: js_sys::Array| {
+            let is_visible = target
+                .offset_parent()
+                .map(|x| !x.is_null())
+                .unwrap_or(false);
+            for y in entries.iter() {
+                let entry: ResizeObserverEntry = y.unchecked_into();
+                let content = entry.content_rect();
+                let content_width = content.width().floor() as i32;
+                let content_height = content.height().floor() as i32;
+                let resized = width != content_width || height != content_height;
+                if resized && is_visible {
+                    on_change();
+                }
+
+                width = content_width;
+                height = content_height;
+            }
+        });
 
-        let mut state = ResizeObserverState {
-            elem: elem.clone(),
-            renderer: renderer.clone(),
-            session: session.clone(),
-            presentation: presentation.clone(),
-            width: elem.offset_width(),
-            height: elem.offset_height(),
-            on_resize,
-        };
-
-        let _callback = Closure::new(move |xs: js_sys::Array| state.on_resize(&xs));
         let observer = ResizeObserver::new(_callback.as_ref().unchecked_ref::<js_sys::Function>());
         observer.observe(elem);
         Self {
             elem: elem.clone(),
-            _callback,
             observer,
+            _callback,
         }
     }
 }
 
-impl Drop for ResizeObserverHandle {
+impl Drop for SizeObserver {
     fn drop(&mut self) {
         self.observer.unobserve(&self.elem);
     }
 }
 
-#[derive(Clone)]
-struct ResizeObserverState {
-    elem: HtmlElement,
-    renderer: Renderer,
-    session: Session,
-    presentation: Presentation,
-    width: i32,
-    height: i32,
-    on_resize: Callback<()>,
-}
+/// The host element's `ResizeObserver`: fans a host box change out to every
+/// panel — a resize for drawn panels, a deferred first render for loaded
+/// panels whose first draw was discarded while invisible.
+pub struct ResizeObserverHandle(#[allow(dead_code)] SizeObserver);
 
-impl ResizeObserverState {
-    fn on_resize(&mut self, entries: &js_sys::Array) {
-        let is_visible = self
-            .elem
-            .offset_parent()
-            .map(|x| !x.is_null())
-            .unwrap_or(false);
-
-        for y in entries.iter() {
-            let entry: ResizeObserverEntry = y.unchecked_into();
-            let content = entry.content_rect();
-            let content_width = content.width().floor() as i32;
-            let content_height = content.height().floor() as i32;
-            let resized = self.width != content_width || self.height != content_height;
-            if resized && is_visible {
-                let state = self.clone();
-                clone!(self.on_resize);
-                ApiFuture::spawn_throttled(async move {
-                    let needs_render = state
-                        .renderer
-                        .clone()
-                        .with_lock(async {
-                            Ok(!state.renderer.is_plugin_activated()?
-                                && matches!(
-                                    state.session.has_table(),
-                                    Some(TableLoadState::Loaded)
-                                ))
-                        })
-                        .await?;
+impl ResizeObserverHandle {
+    pub fn new(
+        elem: &HtmlElement,
+        workspace: &Workspace,
+        presentation: &Presentation,
+        root: &Root<PerspectiveViewer>,
+    ) -> Self {
+        let on_resize = root
+            .borrow()
+            .as_ref()
+            .unwrap()
+            .callback(|()| PerspectiveViewerMsg::Resize);
+
+        clone!(workspace, presentation);
+        Self(SizeObserver::new(elem, move || {
+            clone!(workspace, presentation, on_resize);
+            ApiFuture::spawn_throttled(async move {
+                let mut plans = Vec::new();
+                for panel in workspace.panels() {
+                    // Skip only a plugin that HAS DRAWN but is currently
+                    // hidden (an unselected stacked tab → null
+                    // `offset_parent`); it renders when revealed.
+                    // `is_plugin_activated` is an explicit has-drawn flag,
+                    // so an eagerly-MOUNTED but never-drawn plugin (its
+                    // deferred first render was discarded by the
+                    // `is_visible` gate) falls through to the
+                    // `needs_render` branch below, which owes it a draw.
+                    if panel.renderer.is_plugin_activated()?
+                        && let Some(plugin) = panel.renderer.active_plugin()
+                        && plugin
+                            .unchecked_ref::<HtmlElement>()
+                            .offset_parent()
+                            .is_none()
+                    {
+                        continue;
+                    }
 
+                    let needs_render = !panel.renderer.is_plugin_activated()?
+                        && matches!(panel.session.has_table(), Some(TableLoadState::Loaded));
+
+                    plans.push((panel, needs_render));
+                }
+
+                // For first mounts below: "stamp before restyle" — the
+                // plugin captures its `--psp-*` CSS at first draw.
+                if plans.iter().any(|(_, needs_render)| *needs_render) {
+                    presentation.reset_attached();
+                    seed_default_themes(&presentation, &workspace).await;
+                }
+
+                join_all(plans.into_iter().map(|(panel, needs_render)| async move {
+                    // A concurrent run (e.g. the `load()` that made
+                    // `needs_render` true) is harmless: this run queues
+                    // behind it, reconciles `Unchanged` with no state delta
+                    // and dispatches nothing — never a duplicate draw.
                     if needs_render {
-                        state.presentation.reset_attached();
-                        super::update_and_render(
-                            &state.session,
-                            &state.renderer,
-                            Default::default(),
-                        )?
-                        .await?;
+                        super::just_render(&panel.session, &panel.renderer)?.await?;
                     } else {
-                        state.renderer.resize().await?;
+                        panel.renderer.resize().await?;
                     }
 
-                    on_resize.emit(());
-                    Ok(())
-                });
-            }
+                    ApiResult::<()>::Ok(())
+                }))
+                .await
+                .into_iter()
+                .collect::<ApiResult<Vec<_>>>()?;
 
-            self.width = content_width;
-            self.height = content_height;
-        }
+                on_resize.emit(());
+                Ok(())
+            });
+        }))
+    }
+}
+
+/// A per-panel [`ResizeObserver`] bound to a single panel's slotted plugin
+/// element, resizing only that panel's [`Renderer`] when its box changes.
+pub struct PanelResizeObserverHandle(#[allow(dead_code)] SizeObserver);
+
+impl PanelResizeObserverHandle {
+    pub fn new(elem: &HtmlElement, renderer: &Renderer) -> Self {
+        clone!(renderer);
+        Self(SizeObserver::new(elem, move || {
+            clone!(renderer);
+            ApiFuture::spawn_throttled(async move {
+                if renderer.is_plugin_activated()? {
+                    renderer.resize().await?;
+                }
+
+                Ok(())
+            });
+        }))
     }
 }