@perspective-dev/viewer 5.3.0 → 5.4.0

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
@@ -133,7 +134,7 @@ impl Renderer {
             else {
                 continue;
             };
-            let needs_warm = schema.fields.iter().any(|f| {
+            let needs_warm = schema.leaf_fields().into_iter().any(|f| {
                 matches!(
                     f,
                     ControlSpec::Number {
@@ -164,7 +165,7 @@ impl Renderer {
                 continue;
             };
 
-            for field in &schema.fields {
+            for field in schema.leaf_fields() {
                 let ControlSpec::Number {
                     key,
                     default,
@@ -380,7 +381,7 @@ impl Renderer {
         let view_config_js = JsValue::from_serde_ext(view_config).unwrap_or(JsValue::NULL);
         let raw = plugin._plugin_config_schema(&view_config_js)?;
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-            .map(|schema| schema.canonicalize_defaults())
+            .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
     }
 
@@ -429,7 +430,7 @@ impl Renderer {
         )?;
 
         serde_wasm_bindgen::from_value::<ColumnConfigSchema>(raw)
-            .map(|schema| schema.canonicalize_defaults())
+            .map(|schema| schema.canonicalize())
             .map_err(|e| e.into())
     }
 
@@ -470,9 +471,9 @@ impl Renderer {
                         ))));
                     }
 
+                    let leaves = s.leaf_fields();
                     map.retain(|key, value| {
-                        let is_default = s
-                            .fields
+                        let is_default = leaves
                             .iter()
                             .any(|spec| matches_declared_default(spec, key, value));
                         if is_default {
@@ -567,9 +568,9 @@ fn strip_default_values(
     schema: &ColumnConfigSchema,
     map: &mut serde_json::Map<String, serde_json::Value>,
 ) {
+    let leaves = schema.leaf_fields();
     map.retain(|key, value| {
-        !schema
-            .fields
+        !leaves
             .iter()
             .any(|spec| matches_declared_default(spec, key, value))
     });
@@ -702,6 +703,53 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn strip_default_values_sees_through_groups() {
+        let leaves = vec![
+            ControlSpec::Bool {
+                key: "flag".to_owned(),
+                default: false,
+            },
+            ControlSpec::Number {
+                key: "size".to_owned(),
+                default: 3.0,
+                include: None,
+                min: None,
+                max: None,
+                step: None,
+            },
+        ];
+
+        let flat = ColumnConfigSchema {
+            fields: leaves.clone(),
+        };
+
+        let grouped = ColumnConfigSchema {
+            fields: vec![ControlSpec::Group {
+                key: "section".to_owned(),
+                fields: leaves,
+            }],
+        };
+
+        let src = json!({ "flag": false, "size": 4.0, "foreign": 1 })
+            .as_object()
+            .unwrap()
+            .clone();
+
+        let mut a = src.clone();
+        let mut b = src;
+        strip_default_values(&flat, &mut a);
+        strip_default_values(&grouped, &mut b);
+        assert_eq!(a, b);
+        assert_eq!(
+            a,
+            json!({ "size": 4.0, "foreign": 1 })
+                .as_object()
+                .unwrap()
+                .clone()
+        );
+    }
+
     #[test]
     fn normalize_css_values_canonicalizes_and_reports() {
         let schema = ColumnConfigSchema {

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 {

package/src/rust/tasks/create_panel.rs

@@ -60,7 +60,7 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
             clone!(renderer, session);
             ApiFuture::spawn(async move {
                 renderer
-                    .update_lazy(async move { Ok(session.get_view()) })
+                    .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
                     .await
                     .ignore_view_delete()
                     .map(|_| ())

package/src/rust/tasks/dismiss_render_warning.rs

@@ -28,7 +28,7 @@ pub fn dismiss_render_warning_callback(session: &Session, renderer: &Renderer) -
         ApiFuture::spawn(async move {
             renderer.disable_active_plugin_render_warning();
             renderer
-                .update_lazy(async move { Ok(session.get_view()) })
+                .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
                 .await
         });
     })

package/src/rust/tasks/eject.rs

@@ -34,6 +34,7 @@ pub fn delete_all<T: Component>(workspace: &Workspace, root: &Root<T>) -> ApiFut
         let panels = workspace
             .take_reserved()
             .into_iter()
+            .chain(workspace.take_all_closing())
             .chain(
                 workspace
                     .panel_ids()

package/src/rust/tasks/pipeline.rs

@@ -10,21 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! The render pipeline (see `SESSION_CONFIG_COHERENCE_PLAN.md`) — the ONE
-//! review surface for how config-driven renders happen.
-//!
-//! Invariants enforced here and by the types this composes:
-//! - **I1** config mutation is a synchronous commit
-//!   ([`Session::commit_view_config`]) — no async writer exists.
-//! - **I2** every run consumes an immutable snapshot taken inside the draw
-//!   lock; async stages never re-read the live config (the `ValidatedSnapshot`
-//!   type-state token).
-//! - **I3** runs serialize on the per-`Renderer` draw lock (the [`RenderGuard`]
-//!   witness — plugin dispatch without it does not compile) and every commit
-//!   schedules a run, so the final render always reflects the final commit.
-//! - **I5** the run pins a [`RenderContext`] so plugin read-backs mid-render
-//!   answer from the run's snapshot, never live state.
-
 use std::rc::Rc;
 
 use futures::future::LocalBoxFuture;
@@ -79,30 +64,10 @@ pub async fn bind_snapshot(
 /// legitimate concurrent public calls).
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum RunOrigin {
-    /// A public element API entry (`restore`, `restorePanel`, `reset`,
-    /// `load`, …): an explicit external request, so a run that reconciles
-    /// `Unchanged` with no state delta STILL repaints — the documented
-    /// no-op-restore refresh affordance (`update` source 6, "the user
-    /// asked" — `PLUGIN_DRAW_INVARIANT_PLAN.md` amendment).
     Public,
-    /// A host-initiated run (UI commits, unpause resumes, subscriptions):
-    /// a reconciled no-op dispatches nothing.
     Internal,
 }
 
-/// The ONE decision table mapping a run's [`BindDisposition`] to its plugin
-/// dispatch (`PLUGIN_DRAW_INVARIANT_PLAN.md`, as amended 2026-07-16):
-/// `plugin.draw` fires iff there is a NEW `View` — a REBUILD, or a
-/// freshly-selected plugin's first paint of the bound `View`
-/// (`promote_first_paint`). `plugin.update` fires iff the `View` is
-/// unchanged but a plugin-visible SOURCE changed: the `Adopted`
-/// config delta, a genuinely changed plugin/columns bucket this run
-/// delivered via `plugin.restore` (`plugin_state_changed`), or an explicit
-/// public API request ([`RunOrigin::Public`]). An INTERNAL run that
-/// reconciled `Unchanged` with no state delta dispatches NOTHING — no
-/// defensive repaints (this is what makes an inert plugin echo, e.g. the
-/// datagrid's `toggle_edit_mode` `restorePanel`, render-silent). Deferred
-/// binds dispatch nothing.
 pub async fn dispatch_bound(
     guard: &RenderGuard,
     renderer: &Renderer,
@@ -343,31 +308,6 @@ async fn render_run(
     }
 }
 
-/// One TRANSACTIONAL activation repaint (see the I5 audit gap in
-/// `SESSION_CONFIG_COHERENCE_PLAN.md` §4): under the panel's draw lock,
-/// stamp the `active` class + theme and `plugin.resize()` in ONE dispatch,
-/// so the activation-dependent chrome (e.g. the datagrid's edit
-/// column-header row, decided by its style listener reading that class) and
-/// the class that styles it land in a single paint commit, never split.
-///
-/// `resize`, NOT `draw`/`update`: activation creates no new `View` and
-/// changes no data (`plugin.draw` ⇔ new `View` —
-/// `PLUGIN_DRAW_INVARIANT_PLAN.md`), and a full dispatch on charts is a
-/// fetch + multi-blit repaint — the stacked-tab two-stage regression, paid
-/// by BOTH sides of every tab switch. `resize` is each plugin's cheap
-/// repaint-from-retained-state, and both built-ins skip it while hidden, so
-/// the OUTGOING (unslotted) panel's nudge costs nothing. Deliberately NOT
-/// debounced/throttled: activation is a one-shot interaction, not a data
-/// stream, and the throttle timer is a task boundary the browser paints
-/// across.
-///
-/// EXCEPTION: a panel whose `table_updated` redraws were dropped while it
-/// was hidden ([`Renderer::take_data_stale`]) HAS changed data — its
-/// retained frame is stale, so this activation dispatches one full
-/// `plugin.update` (same `View`, fresh data; `draw` stays reserved for new
-/// `View`s) instead of the chrome-only repaint. `draw_view` stamps the
-/// activation class + theme itself, so the atomicity contract above holds
-/// on this branch too.
 pub async fn activation_render(session: Session, renderer: Renderer) -> ApiResult<()> {
     let result = {
         clone!(session, renderer);