@perspective-dev/viewer 5.3.1 → 5.5.0

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,
@@ -286,6 +251,18 @@ pub(crate) async fn locked_run(
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
                 renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
+            let plugin_config_snapshot = renderer.get_plugin_config();
+            let plugin_update =
+                JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+
+            let plugin_restored = plugin_config_changed || plugin_swapped;
+            if plugin_restored {
+                let columns_config = renderer
+                    .all_columns_configs_materialized(&view_config_snapshot, &session)
+                    .await;
+                plugin.restore(&plugin_update, Some(&columns_config))?;
+            }
+
             let columns_config_changed = renderer.update_columns_configs(
                 &view_config_snapshot,
                 &session,
@@ -293,17 +270,16 @@ pub(crate) async fn locked_run(
             )?;
 
             let changed = plugin_config_changed || columns_config_changed;
-            if changed || plugin_swapped {
-                let plugin_config_snapshot = renderer.get_plugin_config();
-                let plugin_update =
-                    JsValue::from_serde_ext(&plugin_config_snapshot).unwrap_or(JsValue::NULL);
+            if columns_config_changed {
                 let columns_config = renderer
                     .all_columns_configs_materialized(&view_config_snapshot, &session)
                     .await;
                 plugin.restore(&plugin_update, Some(&columns_config))?;
-                if plugin_config_changed {
-                    renderer.plugin_config_changed.emit(plugin_config_snapshot);
-                }
+                renderer.columns_config_changed.emit(columns_config);
+            }
+
+            if plugin_config_changed {
+                renderer.plugin_config_changed.emit(plugin_config_snapshot);
             }
 
             if spec
@@ -343,31 +319,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);

package/src/rust/tasks/presize_panels.rs

@@ -166,13 +166,14 @@ pub async fn presize_visible_panels_open(
 pub async fn presize_visible_panels_pane_width(
     workspace: &Workspace,
     elem: &web_sys::HtmlElement,
+    pane_sel: &str,
     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 {
+    let Some(pane) = shadow_rect(elem, pane_sel) else {
         return StagedPresents::default();
     };
 
@@ -308,6 +309,28 @@ fn shadow_rect(elem: &web_sys::HtmlElement, sel: &str) -> Option<web_sys::DomRec
     )
 }
 
+/// The width the `SplitPanel` pane at `pane_sel` takes with no divider
+/// override, measured under one forced synchronous layout that no paint or
+/// `ResizeObserver` can observe, or `None` when the pane isn't in the DOM.
+pub fn measure_pane_natural_width(elem: &web_sys::HtmlElement, pane_sel: &str) -> Option<f64> {
+    let pane = elem
+        .shadow_root()?
+        .query_selector(pane_sel)
+        .ok()??
+        .dyn_into::<web_sys::HtmlElement>()
+        .ok()?;
+
+    let style = pane.style();
+    let css_text = style.css_text();
+    let class_name = pane.class_name();
+    style.set_css_text("");
+    let _ = pane.class_list().remove_1("is-width-override");
+    let width = pane.get_bounding_client_rect().width();
+    style.set_css_text(&css_text);
+    pane.set_class_name(&class_name);
+    Some(width)
+}
+
 /// 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).

package/src/rust/tasks/restore_and_render.rs

@@ -10,10 +10,6 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-//! Apply a full [`ViewerConfigUpdate`] (settings, theme, title, plugin,
-//! plugin_config, columns_config, view_config) and re-draw, on the snapshot
-//! pipeline (see `tasks/pipeline.rs` / `SESSION_CONFIG_COHERENCE_PLAN.md`).
-
 use futures::Future;
 use perspective_client::clone;
 
@@ -28,19 +24,6 @@ use crate::*;
 /// Apply a full [`ViewerConfigUpdate`] (theme, title, plugin selection,
 /// plugin config, columns config, view config) to the engines and re-draw.
 /// Returns an [`ApiFuture<()>`] which resolves when the draw completes.
-///
-/// `origin` says who initiated the restore ([`RunOrigin`]): a `Public`
-/// element-API call keeps the no-op-restore refresh affordance (an
-/// `Unchanged` reconcile still repaints via `update`); an `Internal`
-/// restore that reconciles `Unchanged` and changes no plugin state
-/// dispatches nothing.
-///
-/// This function owns the PRE-LOCK prologue only (element-level settings /
-/// title / host-theme mirror, plugin resolution, the synchronous config
-/// commit and spinner token); the run itself is
-/// [`locked_run`] with the caller's `task` awaited inside the lock. The
-/// `update`'s `table` field is NOT applied here — table binding is the
-/// `task`'s job (see `restore_panel` / `table_lifecycle`).
 pub fn restore_and_render(
     session: &Session,
     renderer: &Renderer,

package/src/rust/tasks/restore_panel.rs

@@ -16,7 +16,7 @@ use perspective_client::utils::PerspectiveResultExt;
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::session::{ResetOptions, Session};
+use crate::session::{MissingTable, ResetOptions, Session, TableIntermediateState, probe_table};
 use crate::tasks::*;
 use crate::workspace::Workspace;
 use crate::*;
@@ -38,27 +38,107 @@ pub(crate) enum RestoreErrors {
     Suppress,
 }
 
+/// The client to bind and the opened `Table`, or `None` when pending.
+type Probed = (
+    perspective_client::Client,
+    Option<perspective_client::Table>,
+);
+
+/// Resolve and probe the client hosting `name` without touching the
+/// session's own binding.
+async fn probe(
+    session: &Session,
+    workspace: &Workspace,
+    name: &str,
+    missing: MissingTable,
+) -> ApiResult<Probed> {
+    let current = session.get_client();
+    let resolved = workspace
+        .resolve_client_for_table(name, current.as_ref())
+        .await;
+
+    let client = resolved.or(current).into_apierror()?;
+    let table = probe_table(&client, name, missing).await?;
+    Ok((client, table))
+}
+
+/// Bind an unbound or same-named session to `name`.
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
     name: String,
+    missing: MissingTable,
 ) -> ApiResult<()> {
-    let current = session.get_client();
-    if let Some(client) = workspace
-        .resolve_client_for_table(&name, current.as_ref())
-        .await
+    if session
+        .get_table()
+        .is_some_and(|t| t.get_name() == name.as_str())
     {
-        session.set_client(client);
+        return Ok(());
+    }
+
+    let (client, table) = probe(session, workspace, &name, missing).await?;
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
+    }
+
+    session.commit_table_defaults();
+    Ok(())
+}
+
+/// Rebind a session to `name`, probing the incoming table before the
+/// outgoing binding is dropped and replaying the journal opened as
+/// `generation` over the incoming table's defaults.
+async fn rebind_table_task(
+    session: &Session,
+    renderer: &Renderer,
+    workspace: &Workspace,
+    name: String,
+    missing: MissingTable,
+    generation: u32,
+) -> ApiResult<()> {
+    let probed = probe(session, workspace, &name, missing).await;
+    let journal = session.take_pending_load(generation);
+    let (client, table) = probed?;
+    let Some(journal) = journal else {
+        return Ok(());
+    };
+
+    session
+        .reset(ResetOptions {
+            config: true,
+            expressions: true,
+            stats: true,
+            table: Some(TableIntermediateState::Reloaded),
+        })
+        .await?;
+
+    session.set_client(client);
+    match table {
+        Some(table) => session.bind_table(table).await?,
+        None => session.pend_table(name).await?,
     }
 
-    session.set_table(name).await?;
     session.commit_table_defaults();
+    for delta in journal {
+        session.commit_view_config(delta)?;
+    }
+
+    session.commit_table_defaults();
+    if session.get_table().is_none()
+        && let Some(plugin) = renderer.active_plugin()
+    {
+        plugin.clear().await?;
+    }
+
     Ok(())
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
 /// pipeline shared by `restorePanel` (an existing panel), `restoreWorkspace`,
 /// and `addPanel` (both fresh panels).
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn restore_panel(
     session: &Session,
     renderer: &Renderer,
@@ -67,6 +147,7 @@ pub(crate) async fn restore_panel(
     mode: RestoreMode,
     mut update: ViewerConfigUpdate,
     errors: RestoreErrors,
+    missing: MissingTable,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
@@ -100,21 +181,24 @@ pub(crate) async fn restore_panel(
     let rollback =
         matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
 
-    let table_changed = !fresh
-        && matches!(&update.table, OptionalUpdate::Update(name)
-            if session.get_table().map(|t| t.get_name() != name.as_str()).unwrap_or(true));
+    let binding_before = (
+        session.get_table().map(|t| t.get_name().to_owned()),
+        session.pending_table(),
+    );
 
-    let errored_recovery =
-        session.is_errored() && matches!(&update.table, OptionalUpdate::Update(_));
-
-    let reset = (table_changed || errored_recovery).then(|| {
-        session.reset(ResetOptions {
-            config: true,
-            expressions: true,
-            stats: true,
-            ..ResetOptions::default()
-        })
-    });
+    let generation = match &update.table {
+        OptionalUpdate::Update(name)
+            if session.is_errored()
+                || (!fresh
+                    && session
+                        .get_table()
+                        .map(|t| t.get_name() != name.as_str())
+                        .unwrap_or(true)) =>
+        {
+            Some(session.begin_pending_load())
+        },
+        _ => None,
+    };
 
     let result = restore_and_render(
         session,
@@ -123,27 +207,42 @@ pub(crate) async fn restore_panel(
         RunOrigin::Public,
         update.clone(),
         {
-            clone!(session, update.table, workspace);
+            clone!(session, renderer, update.table, workspace);
             async move {
-                if let OptionalUpdate::Update(name) = table {
-                    if let Some(reset) = reset {
-                        reset.await?;
-                    }
+                let OptionalUpdate::Update(name) = table else {
+                    return Ok(());
+                };
 
-                    bind_table_task(&session, &workspace, name).await?;
+                match generation {
+                    Some(generation) => {
+                        rebind_table_task(
+                            &session, &renderer, &workspace, name, missing, generation,
+                        )
+                        .await
+                    },
+                    None => bind_table_task(&session, &workspace, name, missing).await,
                 }
-
-                Ok(())
             }
         },
     )
     .await;
 
+    if let Some(generation) = generation {
+        session.take_pending_load(generation);
+    }
+
     if let Err(e) = &result {
         match errors {
             RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
             RestoreErrors::Suppress => {
-                if let Some(config) = rollback {
+                let binding_after = (
+                    session.get_table().map(|t| t.get_name().to_owned()),
+                    session.pending_table(),
+                );
+
+                if let Some(config) = rollback
+                    && binding_after == binding_before
+                {
                     session.commit_view_config(config.into()).unwrap_or_log();
                 }
             },

package/src/rust/tasks/send_column_config.rs

@@ -49,8 +49,11 @@ pub fn send_column_config(
 
         clone!(session);
         renderer
-            .update_lazy(async move { Ok(session.get_view()) })
+            .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
             .await?;
+        renderer
+            .columns_config_changed
+            .emit(columns_configs.clone());
         renderer.column_style_changed.emit(columns_configs);
         Ok(())
     })

package/src/rust/tasks/send_plugin_config.rs

@@ -44,7 +44,7 @@ pub fn send_plugin_config(session: &Session, renderer: &Renderer, update: Column
                 .restore(&plugin_token, Some(&columns_configs))?;
             clone!(session);
             renderer
-                .update_lazy(async move { Ok(session.get_view()) })
+                .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
                 .await?;
             renderer.plugin_config_changed.emit(plugin_config);
         }

package/src/rust/tasks/set_edit_mode.rs

@@ -51,7 +51,7 @@ pub fn set_edit_mode(session: &Session, renderer: &Renderer, mode: &str) {
                 .restore(&plugin_token, Some(&columns_configs))?;
             clone!(session);
             renderer
-                .update_lazy(async move { Ok(session.get_view()) })
+                .update_lazy(async move { Ok(session.get_view_with_dimensions()) })
                 .await?;
             renderer.plugin_config_changed.emit(plugin_config);
         }