@perspective-dev/viewer 5.3.1 → 5.4.0

package/src/rust/renderer/dispatch.rs

@@ -19,6 +19,7 @@ use std::future::Future;
 use std::rc::Rc;
 
 use perspective_client::View;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::{ApiResult, ResultTApiErrorExt};
 use wasm_bindgen::prelude::*;
 use web_sys::*;
@@ -44,25 +45,27 @@ impl Renderer {
         let _ = el.class_list().toggle_with_force("multi", !is_solo);
     }
 
-    /// Stamp this panel's effective `theme` attribute.
     pub fn stamp_theme(&self, plugin: Option<&JsPerspectiveViewerPlugin>) {
+        let theme = self.theme();
         let active_plugin = self.active_plugin();
         if let Some(plugin) = plugin.or(active_plugin.as_ref()) {
-            let theme_elem = plugin.unchecked_ref::<HtmlElement>();
-            match self.theme() {
-                Some(theme)
-                    if theme_elem.get_attribute("theme").as_deref() != Some(theme.as_str()) =>
-                {
-                    let _ = theme_elem.set_attribute("theme", &theme);
-                },
-                Some(_) => {},
-                None => {
-                    let _ = theme_elem.remove_attribute("theme");
-                },
-            }
+            stamp_theme_attr(plugin.unchecked_ref::<Element>(), theme.as_deref());
+        }
+
+        if let Some(tab) = self.tab_host() {
+            stamp_theme_attr(&tab, theme.as_deref());
         }
     }
 
+    fn tab_host(&self) -> Option<Element> {
+        let slot = format!("tab-{}", self.slot_name()?);
+        let viewer = self.plugin_data.borrow().viewer_elem.clone();
+        let children = viewer.children();
+        (0..children.length())
+            .filter_map(|i| children.item(i))
+            .find(|el| el.get_attribute("slot").as_deref() == Some(slot.as_str()))
+    }
+
     /// Restyle the active plugin and re-draw.
     pub async fn restyle_all(&self) -> ApiResult<JsValue> {
         self.render_task(|guard| async move {
@@ -78,8 +81,14 @@ impl Renderer {
             self.stamp_active(&plugin);
             plugin.restyle();
             *self.0.captured_theme.borrow_mut() = Some(stamped_theme);
-            let mut limits =
-                get_row_and_col_limits(&ctx.view, &meta, self.is_render_warning_enabled()).await?;
+            let dimensions = ctx.view.dimensions().await?;
+            let mut limits = get_row_and_col_limits(
+                &dimensions,
+                &ctx.view,
+                &meta,
+                self.is_render_warning_enabled(),
+            )
+            .await?;
 
             limits.is_update = true;
             plugin
@@ -215,6 +224,7 @@ impl Renderer {
                         };
 
                         self.stamp_active(&jsplugin);
+                        self.0.presized_box.set(None);
                         jsplugin.resize().await?;
                         Ok(None)
                     },
@@ -241,7 +251,33 @@ impl Renderer {
         self.stamp_active(&plugin);
         self.clear_presize()?;
         if plugin.capabilities().presize {
-            return plugin.presize(width, height).await;
+            let Some(present) = plugin.presize(width, height).await? else {
+                return Ok(None);
+            };
+
+            self.0.presized_box.set(Some((width, height)));
+            let inline = js_sys::Reflect::get(&present, &"inline".into())
+                .ok()
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+
+            if inline {
+                self.0.presized_box.set(None);
+            }
+
+            let renderer = self.clone();
+            let wrapped = Closure::once_into_js(move || {
+                let filled = present
+                    .call0(&JsValue::NULL)
+                    .map(|v| v.as_bool() != Some(false))
+                    .unwrap_or(false);
+
+                if !filled {
+                    renderer.0.presized_box.set(None);
+                }
+            });
+
+            return Ok(Some(wrapped.unchecked_into::<js_sys::Function>()));
         }
 
         let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
@@ -278,6 +314,7 @@ impl Renderer {
             }
 
             result?;
+            self.0.presized_box.set(Some((width, height)));
         }
 
         Ok(None)
@@ -307,14 +344,16 @@ impl Renderer {
     pub async fn draw_fresh(&self, guard: &RenderGuard, view: FreshView) -> ApiResult<()> {
         let timer = self.render_timer();
         timer
-            .capture_time(self.draw_view(guard, view.view(), false))
+            .capture_time(self.draw_view(guard, view.view(), false, None))
             .await
     }
 
     /// Repaint the ALREADY-BOUND `view` on the active plugin.
     pub async fn update_bound(&self, guard: &RenderGuard, view: &View) -> ApiResult<()> {
         let timer = self.render_timer();
-        timer.capture_time(self.draw_view(guard, view, true)).await
+        timer
+            .capture_time(self.draw_view(guard, view, true, None))
+            .await
     }
 
     /// Mint the [`FreshView`] full-draw witness for a plugin that has never
@@ -363,7 +402,7 @@ impl Renderer {
     /// Redraw an already-bound view, debounced.
     pub async fn update_lazy(
         &self,
-        view: impl Future<Output = ApiResult<Option<View>>>,
+        view: impl Future<Output = ApiResult<Option<(View, Option<ViewDimensionsResp>)>>>,
     ) -> ApiResult<()> {
         let timer = self.render_timer();
         self.draw_lock()
@@ -382,14 +421,14 @@ impl Renderer {
                 }
 
                 self.mount_active_plugin()?;
-                if let Some(view) = view.await? {
+                if let Some((view, dimensions)) = view.await? {
                     let _pin = self
                         .cached_context()
                         .map(|ctx| self.pin_context(&guard, ctx));
 
                     let timer = self.render_timer();
                     timer
-                        .capture_time(self.draw_view(&guard, &view, true))
+                        .capture_time(self.draw_view(&guard, &view, true, dimensions))
                         .await
                 } else {
                     tracing::debug!("Render skipped, no `View` attached");
@@ -399,11 +438,14 @@ impl Renderer {
             .await
     }
 
+    /// `dimensions` is the caller's already-fetched view dimensions, or
+    /// `None` to fetch here.
     async fn draw_view(
         &self,
         _guard: &RenderGuard,
         view: &perspective_client::View,
         is_update: bool,
+        dimensions: Option<ViewDimensionsResp>,
     ) -> ApiResult<()> {
         debug_assert!(
             !is_update || self.cached_context().is_none() || self.render_context().is_some(),
@@ -420,8 +462,14 @@ impl Renderer {
         };
 
         let meta = self.metadata();
+        let dimensions = match dimensions {
+            Some(dimensions) => dimensions,
+            None => view.dimensions().await?,
+        };
+
         let mut limits =
-            get_row_and_col_limits(view, &meta, self.is_render_warning_enabled()).await?;
+            get_row_and_col_limits(&dimensions, view, &meta, self.is_render_warning_enabled())
+                .await?;
 
         limits.is_update = is_update;
         if let Some(cb) = self.0.on_render_limits_changed.borrow().as_ref() {
@@ -440,6 +488,7 @@ impl Renderer {
         }
 
         self.0.data_stale.set(false);
+        self.0.presized_box.set(None);
         let result = if is_update {
             let task = plugin.update(view.clone().into(), limits.max_cols, limits.max_rows, false);
             activate_plugin(_guard, &viewer_elem, &plugin, slot.as_deref(), task).await
@@ -499,3 +548,15 @@ impl Drop for PresizePendingGuard {
         cell.set(cell.get() - 1);
     }
 }
+
+fn stamp_theme_attr(el: &Element, theme: Option<&str>) {
+    match theme {
+        Some(theme) if el.get_attribute("theme").as_deref() != Some(theme) => {
+            let _ = el.set_attribute("theme", theme);
+        },
+        Some(_) => {},
+        None => {
+            let _ = el.remove_attribute("theme");
+        },
+    }
+}

package/src/rust/renderer/limits.rs

@@ -10,6 +10,7 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_js::utils::ApiError;
 
 use crate::config::PluginStaticConfig;
@@ -31,16 +32,34 @@ pub struct RenderLimits {
     pub max_rows: Option<usize>,
 }
 
-/// Compute the row/column caps for `view` against the plugin's static
-/// limits. `render_warning` is the renderer-state flag controlling
-/// whether the warning is currently armed; when `false`, an oversized
-/// view renders uncapped (the user has dismissed the warning).
+impl RenderLimits {
+    /// The column cap is in effect (fewer columns render than the view has).
+    pub fn is_col_capped(&self) -> bool {
+        self.max_cols.is_some_and(|x| x < self.num_cols)
+    }
+
+    /// The row cap is in effect (fewer rows render than the view has).
+    pub fn is_row_capped(&self) -> bool {
+        self.max_rows.is_some_and(|x| x < self.num_rows)
+    }
+
+    /// Either cap is in effect — exactly when the render warning shows.
+    pub fn is_capped(&self) -> bool {
+        self.is_col_capped() || self.is_row_capped()
+    }
+}
+
+/// Compute the row/column caps for `view` from its already-fetched
+/// `dimensions` against the plugin's static limits. `render_warning` is the
+/// renderer-state flag controlling whether the warning is currently armed;
+/// when `false`, an oversized view renders uncapped (the user has dismissed
+/// the warning).
 pub async fn get_row_and_col_limits(
+    dimensions: &ViewDimensionsResp,
     view: &perspective_client::View,
     config: &PluginStaticConfig,
     render_warning: bool,
 ) -> Result<RenderLimits, ApiError> {
-    let dimensions = view.dimensions().await?;
     let num_cols = dimensions.num_view_columns as usize;
     let num_rows = dimensions.num_view_rows as usize;
     match (config.max_columns, render_warning) {

package/src/rust/renderer/plugin_config.rs

@@ -26,6 +26,7 @@ use super::Renderer;
 use crate::config::*;
 use crate::queries::resolve_abs_max;
 use crate::session::Session;
+use crate::utils::{CssKind, CssLiteralUse, parse_var_ref, resolve_css_refs};
 
 /// A per-column config map. Each inner [`serde_json::Map`] is a flat collection
 /// of plugin-defined JSON keys whose shape is dictated by the active plugin's

package/src/rust/renderer/props.rs

@@ -30,7 +30,8 @@ pub struct RendererProps {
     /// internal `metadata` — `Rc::ptr_eq` works.
     pub config: Rc<PluginStaticConfig>,
 
-    /// Most recently emitted render limits, if any.
+    /// The most recently emitted render limits, only while a cap is in
+    /// effect.
     pub render_limits: Option<RenderLimits>,
 
     /// Names of all registered plugins, in registration order.

package/src/rust/renderer.rs

@@ -120,6 +120,10 @@ pub struct RendererData {
     /// [`Renderer::presize_with_box`] presize calls.
     presize_pending: Cell<u32>,
 
+    /// The `(width, height)` the plugin last painted at through a presize,
+    /// consumed by the post-commit reactive resize.
+    presized_box: Cell<Option<(f64, f64)>>,
+
     /// Debounce slot for geometry tasks (`resize` / presize), separate from
     /// the default slot data-update redraws coalesce on. Invariant: a
     /// geometry request must never resolve via a parked DATA task — a
@@ -160,14 +164,7 @@ pub struct RendererData {
 
     /// The effective theme stamped at the active plugin's last `--psp-*`
     /// CSS CAPTURE — its first paint ([`Renderer::draw_view`]) or last
-    /// [`Renderer::restyle_all`]. `None` = no capture has happened. The
-    /// state behind [`Renderer::needs_restyle`]: restyle necessity is a
-    /// comparison against what the plugin actually captured, never
-    /// inferred from which call site mutated a theme record (the
-    /// raycasting boot double render — see
-    /// `PLUGIN_DRAW_INVARIANT_PLAN.md`, captured-theme revision). Same
-    /// lifecycle as [`Self::has_drawn`]: cleared on plugin swap,
-    /// `dispose` and `delete`; written only inside locked dispatches.
+    /// [`Renderer::restyle_all`].
     captured_theme: RefCell<Option<Option<String>>>,
 
     /// The [`RenderContext`] of the currently-bound `View` (built at bind
@@ -268,6 +265,7 @@ impl Renderer {
             plugin_config_changed: Default::default(),
             render_warning: Cell::new(true),
             presize_pending: Cell::new(0),
+            presized_box: Cell::new(None),
             on_render_limits_changed: Default::default(),
             slot_name: Default::default(),
             theme: Default::default(),
@@ -315,14 +313,7 @@ impl Renderer {
 
     /// Whether the active plugin's captured `--psp-*` CSS is STALE — the
     /// effective theme differs from the one stamped at the plugin's last
-    /// CSS capture (first paint / last restyle). The state-keyed gate for
-    /// every theme-driven `restyle_all` (the `has_drawn` analog for
-    /// `restyle` — `PLUGIN_DRAW_INVARIANT_PLAN.md`, captured-theme
-    /// revision): a caller that just mutated a theme RECORD may not need a
-    /// restyle at all if the plugin's capture already reflects the new
-    /// value (e.g. the same restore also performed the first paint,
-    /// post-stamp). `false` when no capture exists yet — the owed first
-    /// paint captures fresh by construction ("stamp before draw").
+    /// CSS capture (first paint / last restyle).
     pub fn needs_restyle(&self) -> bool {
         match &*self.0.captured_theme.borrow() {
             Some(captured) => *captured != self.theme(),
@@ -336,17 +327,6 @@ impl Renderer {
     /// [`Self::delete`], which clears the entire light DOM). Removes the
     /// plugin (`slot=<id>`) and any panel-scoped aux element it mounted
     /// (e.g. the datagrid toolbar, `slot=statusbar-extra-<id>`).
-    ///
-    /// The teardown is DEFERRED through this renderer's draw lock: spawned
-    /// draws are uncancellable, so a synchronous `plugin.delete()` here could
-    /// land mid-`plugin.draw()`, which the serialized-call contract forbids
-    /// (see [`crate::js::plugin`]). Deferral is invisible — the caller
-    /// (`eject_panel`) has already removed the panel from the `Workspace`, so
-    /// the same commit unmounts its frame and the plugin element sits
-    /// unslotted (unrendered) until teardown lands; panel ids are never
-    /// reused, so it can't collide with a replacement panel's slot. Draws
-    /// still queued behind the lock no-op via the synchronous session reset
-    /// (`get_view()` → `None`).
     pub fn dispose(&self) -> ApiFuture<()> {
         self.0.has_drawn.set(false);
         self.0.captured_theme.borrow_mut().take();
@@ -488,6 +468,12 @@ impl Renderer {
         Ok(self.0.has_drawn.get())
     }
 
+    /// Take the box the plugin last painted at through a presize (see
+    /// `RendererData::presized_box`).
+    pub fn take_presized_box(&self) -> Option<(f64, f64)> {
+        self.0.presized_box.take()
+    }
+
     /// Mount the selected plugin element into the viewer's light DOM without
     /// drawing it (see [`activate::mount_plugin`] — idempotent). Pure query:
     /// a renderer with no selection is a no-op, deferring to the draw path's
@@ -695,6 +681,7 @@ impl Renderer {
     /// suitable for passing as a Yew prop.  Called by the root component
     /// whenever a renderer-related PubSub event fires.
     pub fn to_props(&self, render_limits: Option<RenderLimits>) -> RendererProps {
+        let render_limits = render_limits.filter(RenderLimits::is_capped);
         let has_plugin = self.active_plugin().is_some();
         if has_plugin {
             let config = self.metadata();

package/src/rust/session/props.rs

@@ -19,7 +19,7 @@ use crate::session::column_defaults_update::ViewConfigUpdateExt;
 use crate::session::drag_drop_update::ViewConfigExt as DragDropExt;
 use crate::session::metadata::SessionMetadataRc;
 use crate::session::replace_expression_update::ViewConfigExt as ReplaceExprExt;
-use crate::session::{ColumnStats, TableErrorState, ViewStats};
+use crate::session::{ColumnStats, TableErrorState};
 use crate::utils::*;
 
 #[derive(Clone, Debug, PartialEq, Default)]
@@ -39,8 +39,9 @@ pub struct SessionProps {
     /// The current `ViewConfig` driving the active `View`.
     pub config: PtrEqRc<ViewConfig>,
 
-    /// Row/column statistics for the status bar.
-    pub stats: Option<ViewStats>,
+    /// Whether the view stats carry table dimensions yet, the status
+    /// indicator's loaded/uninitialized split.
+    pub has_table_cells: bool,
 
     /// `true` if a `Table` has been loaded into this session.
     pub has_table: Option<TableLoadState>,

package/src/rust/session/view_subscription.rs

@@ -10,10 +10,11 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 
 use perspective_client::config::*;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_client::{OnUpdateOptions, View};
 use wasm_bindgen::prelude::*;
 use yew::prelude::*;
@@ -41,6 +42,10 @@ struct ViewSubscriptionData {
     on_stats: Callback<ViewStats>,
     on_update: Option<Callback<()>>,
     is_deleted: Rc<Cell<bool>>,
+
+    /// The bound `View`'s latest known dimensions, written before
+    /// `on_update`/`on_stats` fire.
+    dimensions: Rc<RefCell<Option<ViewDimensionsResp>>>,
 }
 
 /// A subscription to `on_update()` events from a Perspective `View()`, managing
@@ -52,20 +57,21 @@ pub struct ViewSubscription {
 impl ViewSubscriptionData {
     /// Main handler when underlying `View()` calls `on_update()`.
     async fn on_view_update(self) -> ApiResult<JsValue> {
+        self.clone().update_view_stats().await?;
         if let Some(on_update) = &self.on_update {
             on_update.emit(());
         };
 
-        self.clone().update_view_stats().await?;
         Ok(JsValue::UNDEFINED)
     }
 
     async fn update_view_stats(self) -> ApiResult<JsValue> {
         let dimensions = self.view.dimensions().await?;
-        let num_rows = dimensions.num_table_rows as u32;
-        let num_cols = dimensions.num_table_columns as u32;
-        let virtual_rows = dimensions.num_view_rows as u32;
-        let virtual_cols = dimensions.num_view_columns as u32;
+        let num_rows = dimensions.num_table_rows;
+        let num_cols = dimensions.num_table_columns;
+        let virtual_rows = dimensions.num_view_rows;
+        let virtual_cols = dimensions.num_view_columns;
+        *self.dimensions.borrow_mut() = Some(dimensions);
         let stats = ViewStats {
             num_table_cells: Some((num_rows, num_cols)),
             num_view_cells: Some((virtual_rows, virtual_cols)),
@@ -119,6 +125,7 @@ impl ViewSubscription {
             callback_id: Rc::default(),
             on_update,
             is_deleted: Rc::default(),
+            dimensions: Rc::default(),
         };
 
         if data.on_update.is_some() {
@@ -160,6 +167,12 @@ impl ViewSubscription {
         &self.data.view
     }
 
+    /// The bound `View`'s latest known dimensions (`None` until the first
+    /// fetch resolves).
+    pub fn dimensions(&self) -> Option<ViewDimensionsResp> {
+        self.data.dimensions.borrow().clone()
+    }
+
     /// User-facing snapshot of the [`ViewConfig`] the bound `View` was
     /// constructed from (the persisted config at build time — global-filter
     /// overlay excluded). This is the [`ViewConfig`] consistent with the

package/src/rust/session.rs

@@ -24,6 +24,7 @@ use std::ops::Deref;
 use std::rc::Rc;
 
 use perspective_client::config::*;
+use perspective_client::proto::ViewDimensionsResp;
 use perspective_client::{Client, ClientError, ReconnectCallback, View};
 use perspective_js::apierror;
 use perspective_js::utils::*;
@@ -56,11 +57,7 @@ pub struct SessionHandle {
     pub table_loaded: PubSub<()>,
     pub table_unloaded: PubSub<bool>,
 
-    /// Fires when a `View` was CREATED — literally: `bind_view`'s REBUILD
-    /// path constructed and bound a new engine `View`. Nothing else may
-    /// emit this (a SKIP/REUSE/paused reconcile is [`Self::commit_reconciled`],
-    /// which REBUILD also emits) — overloading it broke consumers that
-    /// relied on the name's meaning (see `UPDATE_COUNT_REGRESSION_PLAN.md`).
+    /// Fires when a `View` was CREATED — literally.
     pub view_created: PubSub<()>,
 
     /// Fires exactly once per locked run that RECONCILED the committed
@@ -74,43 +71,23 @@ pub struct SessionHandle {
     pub view_config_changed: PubSub<()>,
     pub title_changed: PubSub<Option<String>>,
 
-    /// Count of in-flight CONFIG-DRIVEN pipeline runs (commit → run
-    /// settled), incremented by [`Session::begin_config_run`] and
-    /// decremented when the returned [`ConfigRunToken`] drops. Drives the
-    /// `StatusIndicator` "updating" spinner via [`Self::run_state_changed`].
-    /// Pure redraws (resize, activation nudges, `just_render`) do NOT
-    /// count — the spinner means "a config requery is in flight".
+    /// Count of in-flight CONFIG-DRIVEN pipeline runs.
     in_flight_config_runs: Cell<u32>,
 
     /// Fires with the ABSOLUTE [`Self::in_flight_config_runs`] count after
-    /// every change. LEVEL-triggered by design: subscribers ASSIGN the
-    /// payload rather than accumulate deltas, so a dropped or reordered
-    /// notification is corrected by the next one — the delta-counting
-    /// (`view_config_changed`+1 / `view_created`−1) design this replaces
-    /// drifted whenever those streams weren't perfectly paired (see
-    /// `UPDATE_COUNT_REGRESSION_PLAN.md`).
+    /// every change.
     pub run_state_changed: PubSub<u32>,
 
     /// Fires when the user clicks the status indicator while in
-    /// [`StatusIconState::Normal`]. `wire_panel_events` is the only
-    /// listener and fans this out as the `perspective-status-indicator-click`
-    /// `CustomEvent`.
+    /// [`StatusIconState::Normal`].
     pub status_indicator_clicked: PubSub<()>,
 
-    /// Per-column numeric stats cache. Populated by the
-    /// `fetch_column_abs_max` task and consumed by the schema-query
-    /// path so plugins emit gradient defaults without
-    /// per-render `View::get_min_max` round trips. Cleared
-    /// synchronously inside [`Session::commit_view_config`].
+    /// Per-column numeric stats cache.
     column_stats: RefCell<HashMap<String, ColumnStats>>,
 
     /// Memoized snapshots used by [`Session::to_props`] to keep
     /// `PtrEqRc` identity stable across repeated `to_props()` calls
-    /// when the underlying value hasn't changed. Without this, every
-    /// `PubSub` fire (including `column_stats_changed`) produces a
-    /// fresh `Rc` for `config` / `metadata`, triggering downstream
-    /// `use_effect_with(view_config, ...)` effects to spuriously
-    /// refire — closing a loop with the stats fetch path.
+    /// when the underlying value hasn't changed.
     cached_config: RefCell<Option<PtrEqRc<ViewConfig>>>,
     cached_metadata: RefCell<Option<SessionMetadataRc>>,
 
@@ -131,18 +108,7 @@ pub struct SessionHandle {
     load_generation: Cell<u32>,
 
     /// Open between a `load()` call and its payload's classification as
-    /// `Table`/`Client` ([`PendingLoad`]). While `Some` the payload type is
-    /// unknown, so its RESET/no-RESET disposition cannot be decided yet — but
-    /// the window's POSITION on the config-commit stream is fixed at the
-    /// `load()` call site. During the window, config commits still apply live
-    /// (so `save()` stays coherent — I1) but ALSO append their raw delta to
-    /// the journal, and config-driven binds DEFER ([`Session::snapshot`]'s
-    /// caller [`crate::tasks::bind_snapshot`]) — the incoming config must
-    /// never draw against the still-bound outgoing table (hold the last
-    /// frame). Classified as `Table` the journal replays over a reset base
-    /// (`reset ∘ Δ₁ ∘ Δ₂ …`, the program-order result the old synchronous
-    /// reset guaranteed); as `Client` it is dropped (no reset — live already
-    /// carries every Δ). See `SESSION_CONFIG_COHERENCE_PLAN.md`.
+    /// `Table`/`Client` ([`PendingLoad`]).
     pending_load: RefCell<Option<PendingLoad>>,
 
     /// Coalesces `view_config_changed`: multiple synchronous commits in one
@@ -165,8 +131,11 @@ pub struct SessionHandle {
     /// new value.
     pub column_stats_changed: PubSub<()>,
 
-    /// Injected callback from the root component, replacing the former
-    /// `stats_changed: PubSub` field.  Fires when view stats are updated.
+    /// Fires when view stats are updated.
+    pub stats_changed: PubSub<()>,
+
+    /// Injected callback from the root component, driving
+    /// `session_props.has_table_cells` for the active panel.
     pub on_stats_changed: RefCell<Option<Callback<()>>>,
 
     /// Injected callback from the root component, replacing the former
@@ -279,13 +248,7 @@ pub struct ResetOptions {
 #[derive(Clone)]
 pub struct Session(Rc<SessionHandle>);
 
-/// RAII spinner accounting for one config-driven pipeline run (see
-/// [`Session::begin_config_run`] and `UPDATE_COUNT_REGRESSION_PLAN.md`):
-/// created when the run is scheduled — immediately after its commit — and
-/// moved INTO the run future, so `Drop` settles the count on every exit
-/// path: completion, error, cancellation, and runs that never reach
-/// `bind_view` (the deferred-draw restore). A stranded count is
-/// unrepresentable; there is no other writer.
+/// RAII spinner accounting for one config-driven pipeline run.
 pub struct ConfigRunToken(Session);
 
 impl Drop for ConfigRunToken {
@@ -664,10 +627,27 @@ impl Session {
             .map(|sub| sub.get_view().clone())
     }
 
+    /// The bound `View` together with its latest known dimensions, read under
+    /// one borrow so they always belong together.
+    pub fn get_view_with_dimensions(&self) -> Option<(View, Option<ViewDimensionsResp>)> {
+        self.borrow()
+            .view_sub
+            .as_ref()
+            .map(|sub| (sub.get_view().clone(), sub.dimensions()))
+    }
+
     pub(crate) fn get_table_stats(&self) -> Option<ViewStats> {
         self.borrow().stats.clone()
     }
 
+    /// Whether the stats snapshot carries table dimensions.
+    pub(crate) fn has_table_cells(&self) -> bool {
+        self.borrow()
+            .stats
+            .as_ref()
+            .is_some_and(|s| s.num_table_cells.is_some())
+    }
+
     pub fn get_view_config(&'_ self) -> Ref<'_, ViewConfig> {
         Ref::map(self.borrow(), |x| &x.config)
     }
@@ -924,15 +904,6 @@ impl Session {
     /// Emit `view_config_changed` coalesced to one event per microtask batch.
     /// Stats are cleared synchronously per commit (idempotent — an
     /// already-empty cache no-ops, so rapid commit sequences fetch once).
-    ///
-    /// CONTRACT: this channel is COALESCED and DEFERRED — N same-batch
-    /// commits produce ONE emission, on a microtask AFTER the mutation.
-    /// Subscribers must be batch-tolerant snapshot refreshers (they re-read
-    /// live state; today: the root `SessionProps` snapshot and the debug
-    /// panel). It is NOT suitable for per-commit accounting — pairing its
-    /// edges against any other event stream WILL drift (the stuck-spinner
-    /// regression, `UPDATE_COUNT_REGRESSION_PLAN.md`); run accounting is
-    /// [`Self::begin_config_run`]'s RAII token instead.
     fn notify_view_config_changed(&self) {
         self.clear_column_stats();
         if !self.0.config_event_scheduled.replace(true) {
@@ -1218,6 +1189,8 @@ impl Session {
         if let Some(cb) = self.on_stats_changed.borrow().as_ref() {
             cb.emit(());
         }
+
+        self.stats_changed.emit(());
     }
 
     fn all_columns(&self) -> Vec<String> {
@@ -1258,7 +1231,10 @@ impl Session {
 
         SessionProps {
             config,
-            stats: data.stats.clone(),
+            has_table_cells: data
+                .stats
+                .as_ref()
+                .is_some_and(|s| s.num_table_cells.is_some()),
             has_table: if data.table.is_some() {
                 Some(TableLoadState::Loaded)
             } else if data.is_loading {
@@ -1290,15 +1266,7 @@ pub struct ConfigSnapshot {
 pub struct ValidatedSnapshot(ConfigSnapshot);
 
 /// Type-state witness that a `View` is NEW for the plugin about to render
-/// it — `plugin.draw()`'s contract (see `PLUGIN_DRAW_INVARIANT_PLAN.md`:
-/// `draw` fires iff there is a new `View`, never otherwise). Minted in
-/// exactly two places: [`Session::bind_view`]'s REBUILD arm (a new engine
-/// `View` was constructed) and
-/// [`crate::renderer::Renderer::promote_first_paint`] (a freshly-selected
-/// plugin owes its first paint of the bound `View`). Do NOT construct it
-/// anywhere else — `Renderer::draw_fresh` is the only consumer, and this
-/// witness is what makes "full draw without a new `View`" (the stacked-chart
-/// activation regression) uncompilable.
+/// it.
 pub struct FreshView(View);
 
 impl FreshView {