@perspective-dev/viewer 5.4.0 → 5.5.1

package/src/rust/session.rs

@@ -21,7 +21,7 @@ use std::cell::{Cell, Ref, RefCell};
 use std::collections::{HashMap, HashSet};
 use std::future::Future;
 use std::ops::Deref;
-use std::rc::Rc;
+use std::rc::{Rc, Weak};
 
 use perspective_client::config::*;
 use perspective_client::proto::ViewDimensionsResp;
@@ -71,12 +71,8 @@ pub struct SessionHandle {
     pub view_config_changed: PubSub<()>,
     pub title_changed: PubSub<Option<String>>,
 
-    /// 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.
-    pub run_state_changed: PubSub<u32>,
+    /// Account of in-flight CONFIG-DRIVEN pipeline runs.
+    pub config_runs: InFlight,
 
     /// Fires when the user clicks the status indicator while in
     /// [`StatusIconState::Normal`].
@@ -100,31 +96,22 @@ pub struct SessionHandle {
     /// copying the config.
     pub last_dispatched_config: RefCell<Option<std::rc::Rc<crate::config::ViewerConfig>>>,
 
-    /// Monotone load counter, bumped once per `load()` call
-    /// ([`Session::begin_pending_load`]). Identifies the LATEST load so a
-    /// stale async classification — React binds `load` to a prop and fires it
-    /// repeatedly, unawaited and out of order — no-ops instead of clobbering a
-    /// newer load ([`Session::is_current_load`]).
-    load_generation: Cell<u32>,
-
     /// Open between a `load()` call and its payload's classification as
-    /// `Table`/`Client` ([`PendingLoad`]).
-    pending_load: RefCell<Option<PendingLoad>>,
+    /// `Table`/`Client` ([`LoadWindow`]), held weakly so its [`LoadGuard`] is
+    /// the sole owner.
+    pending_load: RefCell<Weak<LoadWindow>>,
 
     /// Coalesces `view_config_changed`: multiple synchronous commits in one
     /// task emit ONE event on the next microtask — the cadence the deleted
     /// `is_clean` flag provided by accident, now deliberate.
     config_event_scheduled: Cell<bool>,
 
-    /// Count of in-flight `perspective-config-update` dispatch tasks for this
-    /// panel (see [`Session::track_dispatch`]). `flush()` joins these via
+    /// Account of in-flight `perspective-config-update` dispatch tasks for
+    /// this panel (see [`Session::track_dispatch`]). `flush()` joins these via
     /// [`Session::settle_dispatches`], so the "config-update fires before
     /// `flush()` resolves" contract holds by construction instead of by
     /// microtask luck.
-    pending_dispatches: Cell<u32>,
-
-    /// Fires when [`SessionHandle::pending_dispatches`] returns to zero.
-    dispatches_settled: PubSub<()>,
+    dispatches: InFlight,
 
     /// Fires when [`SessionHandle::column_stats`] is updated (insert or
     /// clear). Subscribers re-render and re-query the schema with the
@@ -152,6 +139,51 @@ impl Deref for SessionHandle {
     }
 }
 
+/// What an un-hosted `table` name means to a bind, per the `wait_for_table`
+/// option.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum MissingTable {
+    /// A hard error that leaves the panel as it was.
+    Error,
+
+    /// The panel waits unbound and binds when the name is hosted.
+    Pend,
+}
+
+impl MissingTable {
+    /// Decode the `wait_for_table` option (absent = `false` = `Error`).
+    pub fn from_wait(wait_for_table: Option<bool>) -> Self {
+        if wait_for_table.unwrap_or_default() {
+            Self::Pend
+        } else {
+            Self::Error
+        }
+    }
+}
+
+/// Open `name` on `client`, returning `Ok(None)` when the name is not hosted
+/// and `missing` is [`MissingTable::Pend`].
+pub(crate) async fn probe_table(
+    client: &Client,
+    name: &str,
+    missing: MissingTable,
+) -> ApiResult<Option<perspective_client::Table>> {
+    match client.open_table(name.to_owned()).await {
+        Ok(table) => Ok(Some(table)),
+        Err(e) => {
+            let hosted = client.get_hosted_table_names().await.unwrap_or_default();
+            if hosted.iter().any(|n| n == name) {
+                return Err(e.into());
+            }
+
+            match missing {
+                MissingTable::Pend => Ok(None),
+                MissingTable::Error => Err(ApiError::new(format!("Unknown table \"{name}\""))),
+            }
+        },
+    }
+}
+
 /// Mutable state for `Session`.
 #[derive(Default)]
 pub struct SessionData {
@@ -166,6 +198,11 @@ pub struct SessionData {
     is_loading: bool,
     is_paused: bool,
 
+    /// Terminal: set by [`Session::mark_disposed`] when the owning panel is
+    /// ejected, never cleared. Distinct from an `Ejected` reset, which a
+    /// suspended or element-ejected session may legitimately rebind after.
+    disposed: Option<Disposal>,
+
     /// Memo for [`Session::validate_snapshot`]: the expression set validated
     /// by the last successful server round trip; an equal snapshot skips the
     /// round trip. Written only under the draw lock; cleared on table
@@ -210,6 +247,19 @@ impl TableErrorState {
     }
 }
 
+/// How a terminal disposal reports itself to a public run still in flight on
+/// the ejected panel.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Disposal {
+    /// A separate call destroyed the panel, so a racing public run rejects
+    /// rather than reporting a success it never achieved.
+    Reject,
+
+    /// The ejecting call reports the eviction on its own promise, so a racing
+    /// public run resolves rather than surfacing it twice.
+    Resolve,
+}
+
 #[derive(Debug, Default)]
 pub enum TableIntermediateState {
     #[default]
@@ -217,13 +267,52 @@ pub enum TableIntermediateState {
     Reloaded,
 }
 
-/// The open-load window state (see [`SessionHandle::pending_load`]): the
-/// generation that opened it (for supersession detection) and the raw config
-/// deltas committed while it was open, in commit order, awaiting replay over a
-/// reset base if the payload classifies as a `Table`.
-pub struct PendingLoad {
-    generation: u32,
-    journal: Vec<ViewConfigUpdate>,
+/// The raw config deltas committed while a `load()` classifies its payload, in
+/// commit order, awaiting replay over a reset base if it classifies as a
+/// `Table` — identified by [`Rc`] identity rather than a generation counter.
+#[derive(Default)]
+pub struct LoadWindow {
+    journal: RefCell<Vec<ViewConfigUpdate>>,
+}
+
+/// A `load()` call site's handle on THE window it opened, closing that window
+/// on `Drop` so no exit can strand `is_loading`.
+pub struct LoadGuard {
+    session: Session,
+    window: Rc<LoadWindow>,
+}
+
+impl LoadGuard {
+    /// Close this window and take its journal for replay, or `None` when a
+    /// later `load()` superseded it — "abandon this classification, hold the
+    /// frame".
+    pub fn claim(&self) -> Option<Vec<ViewConfigUpdate>> {
+        self.close_current().then(|| self.window.journal.take())
+    }
+
+    /// Close this window, discarding its journal; idempotent, and a no-op once
+    /// superseded.
+    pub fn close(&self) {
+        self.close_current();
+    }
+
+    fn close_current(&self) -> bool {
+        let mut slot = self.session.pending_load.borrow_mut();
+        if !slot.upgrade().is_some_and(|x| Rc::ptr_eq(&x, &self.window)) {
+            return false;
+        }
+
+        *slot = Weak::new();
+        drop(slot);
+        self.session.borrow_mut().is_loading = false;
+        true
+    }
+}
+
+impl Drop for LoadGuard {
+    fn drop(&mut self) {
+        self.close();
+    }
 }
 
 /// Options for [`Session::reset`]
@@ -248,19 +337,6 @@ pub struct ResetOptions {
 #[derive(Clone)]
 pub struct Session(Rc<SessionHandle>);
 
-/// RAII spinner accounting for one config-driven pipeline run.
-pub struct ConfigRunToken(Session);
-
-impl Drop for ConfigRunToken {
-    fn drop(&mut self) {
-        let count = self.0.0.in_flight_config_runs.get();
-        debug_assert!(count > 0, "ConfigRunToken underflow");
-        let count = count.saturating_sub(1);
-        self.0.0.in_flight_config_runs.set(count);
-        self.0.run_state_changed.emit(count);
-    }
-}
-
 impl ImplicitClone for Session {}
 
 impl Deref for Session {
@@ -309,6 +385,7 @@ impl Session {
     /// `Session`.
     pub fn reset(&self, options: ResetOptions) -> impl Future<Output = ApiResult<()>> + use<> {
         let view = self.0.borrow_mut().view_sub.take();
+        let had_table = self.borrow().table.is_some();
         let err = self.get_error();
         self.borrow_mut().error = None;
         if options.stats {
@@ -328,11 +405,13 @@ impl Session {
                 self.borrow_mut().is_loading = false;
                 self.borrow_mut().table = None;
                 self.borrow_mut().pending_table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
             },
             Some(TableIntermediateState::Reloaded) => {
                 self.borrow_mut().is_loading = true;
                 self.borrow_mut().table = None;
                 self.borrow_mut().pending_table = None;
+                self.borrow_mut().metadata = SessionMetadata::default();
             },
             _ => {
                 self.borrow_mut().is_loading = false;
@@ -353,7 +432,7 @@ impl Session {
         let session = self.clone();
         async move {
             let res = view.delete().await;
-            if options.table.is_some() {
+            if options.table.is_some() && had_table {
                 session.table_unloaded.emit(true)
             }
 
@@ -361,21 +440,19 @@ impl Session {
         }
     }
 
-    /// Open a pending-load window (see [`SessionHandle::pending_load`]) at the
-    /// `load()` call site. Bumps the load generation and returns it — the
-    /// caller carries it into the async classification to detect supersession
-    /// by a later `load()`. Sets `is_loading` so a FRESH panel shows the
-    /// spinner while a slow payload resolves (a RELOAD keeps its bound table,
-    /// hence [`TableLoadState::Loaded`], throughout — no spinner flicker).
-    pub fn begin_pending_load(&self) -> u32 {
-        let generation = self.0.load_generation.get() + 1;
-        self.0.load_generation.set(generation);
-        *self.0.pending_load.borrow_mut() = Some(PendingLoad {
-            generation,
-            journal: Vec::new(),
-        });
+    /// Open a load window (see [`LoadWindow`]) at the `load()` call site,
+    /// returning the [`LoadGuard`] that owns it. Sets `is_loading` so a FRESH
+    /// panel shows the spinner while a slow payload resolves (a RELOAD keeps
+    /// its bound table, hence [`TableLoadState::Loaded`], throughout — no
+    /// spinner flicker).
+    pub fn begin_pending_load(&self) -> Rc<LoadGuard> {
+        let window = Rc::new(LoadWindow::default());
+        *self.0.pending_load.borrow_mut() = Rc::downgrade(&window);
         self.borrow_mut().is_loading = true;
-        generation
+        Rc::new(LoadGuard {
+            session: self.clone(),
+            window,
+        })
     }
 
     /// Whether a `load()` payload is still awaiting classification. A `true`
@@ -383,25 +460,23 @@ impl Session {
     /// ([`crate::tasks::bind_snapshot`]) — the incoming config must never draw
     /// against the outgoing table.
     pub fn has_pending_load(&self) -> bool {
-        self.0.pending_load.borrow().is_some()
-    }
-
-    /// Close the pending-load window for `generation`, returning its journal
-    /// (the raw deltas committed while it was open, in order) for replay.
-    /// Returns `None` when a later `load()` already superseded this one (or it
-    /// was already closed), which the caller treats as "abandon this
-    /// classification, hold the frame". Clears `is_loading` — the
-    /// classification that follows sets the real table state.
-    pub fn take_pending_load(&self, generation: u32) -> Option<Vec<ViewConfigUpdate>> {
-        let mut slot = self.0.pending_load.borrow_mut();
-        if slot.as_ref().map(|p| p.generation) != Some(generation) {
-            return None;
-        }
+        self.0.pending_load.borrow().strong_count() > 0
+    }
 
-        let journal = slot.take().map(|p| p.journal);
-        drop(slot);
-        self.borrow_mut().is_loading = false;
-        journal
+    /// Mark this session disposed (its panel was ejected): every later
+    /// table bind and locked run refuses, so nothing can rebind or draw a
+    /// panel that no longer exists.
+    pub(crate) fn mark_disposed(&self, disposal: Disposal) {
+        self.borrow_mut().disposed = Some(disposal);
+    }
+
+    pub(crate) fn is_disposed(&self) -> bool {
+        self.borrow().disposed.is_some()
+    }
+
+    /// This session's disposal, if its panel was ejected.
+    pub(crate) fn disposal(&self) -> Option<Disposal> {
+        self.borrow().disposed
     }
 
     pub(crate) fn has_table(&self) -> Option<TableLoadState> {
@@ -410,6 +485,8 @@ impl Session {
             Some(TableLoadState::Loaded)
         } else if data.is_loading {
             Some(TableLoadState::Loading)
+        } else if data.pending_table.is_some() {
+            Some(TableLoadState::Pending)
         } else {
             None
         }
@@ -470,10 +547,8 @@ impl Session {
     /// `table_name` is unique per `Client`, so if this value has not changed,
     /// `Session::set_table` does nothing and returns `Ok(false)`.
     ///
-    /// A name NO loaded client hosts (yet) is not an error: the session
-    /// records it PENDING ([`SessionData::pending_table`]) and returns
-    /// `Ok(false)`; the element's hosted-tables subscription
-    /// (`tasks::table_lifecycle`) re-runs the bind when the table is created.
+    /// A name no loaded client hosts pends ([`MissingTable::Pend`]) and
+    /// returns `Ok(false)` until the table lifecycle re-runs the bind.
     pub async fn set_table(&self, table_name: String) -> ApiResult<bool> {
         if Some(table_name.as_str()) == self.0.borrow().table.as_ref().map(|x| x.get_name()) {
             self.0.borrow_mut().pending_table = None;
@@ -481,60 +556,76 @@ impl Session {
         }
 
         let client = self.0.borrow().client.clone().into_apierror()?;
-        let table = match client.open_table(table_name.clone()).await {
-            Ok(table) => table,
-            Err(e) => {
-                // Distinguish "not hosted (yet)" — which PENDS — from a real
-                // open failure by the hosted set, not the error's text.
-                let hosted = client.get_hosted_table_names().await.unwrap_or_default();
-                if hosted.iter().any(|n| n == &table_name) {
-                    return Err(e.into());
-                }
-
-                self.0.borrow_mut().pending_table = Some(table_name);
-                return Ok(false);
+        match probe_table(&client, &table_name, MissingTable::Pend).await? {
+            Some(table) => match self.bind_table(table).await {
+                Ok(()) => Ok(true),
+                Err(err) => self.set_error(false, err).await.map(|_| false),
             },
-        };
+            None => {
+                self.pend_table(table_name).await?;
+                Ok(false)
+            },
+        }
+    }
 
-        match SessionMetadata::from_table(&table).await {
-            Ok(metadata) => {
-                let client = table.get_client();
-                let on_error = self.on_table_errored.borrow().clone();
-                let session = self.clone();
-                let poll_loop = LocalPollLoop::new(move |(message, reconnect): (ApiError, _)| {
-                    session.borrow_mut().error = Some(TableErrorState(message, reconnect));
-                    if let Some(cb) = &on_error {
-                        cb.emit(());
-                    }
-                    if let Some(sub) = session.borrow_mut().view_sub.take() {
-                        sub.dismiss();
-                    }
+    /// Bind an opened `Table`, replacing any previous binding and announcing
+    /// `table_loaded`.
+    pub(crate) async fn bind_table(&self, table: perspective_client::Table) -> ApiResult<()> {
+        if self.is_disposed() {
+            return Err(ApiError::new("Panel disposed"));
+        }
 
-                    Ok(JsValue::UNDEFINED)
-                });
-
-                let _callback_id = client
-                    .on_error(Box::new(move |message: ClientError, reconnect| {
-                        let poll_loop = poll_loop.clone();
-                        async move {
-                            poll_loop.poll((message.into(), reconnect)).await;
-                            Ok(())
-                        }
-                    }))
-                    .await?;
+        let metadata = SessionMetadata::from_table(&table).await?;
+        let client = table.get_client();
+        let on_error = self.on_table_errored.borrow().clone();
+        let session = self.clone();
+        let poll_loop = LocalPollLoop::new(move |(message, reconnect): (ApiError, _)| {
+            session.borrow_mut().error = Some(TableErrorState(message, reconnect));
+            if let Some(cb) = &on_error {
+                cb.emit(());
+            }
+            if let Some(sub) = session.borrow_mut().view_sub.take() {
+                sub.dismiss();
+            }
 
-                let sub = self.borrow_mut().view_sub.take();
-                self.borrow_mut().metadata = metadata;
-                self.borrow_mut().table = Some(table);
-                self.borrow_mut().pending_table = None;
-                self.borrow_mut().is_loading = false;
-                self.borrow_mut().last_validated_expressions = None;
-                sub.delete().await?;
-                self.table_loaded.emit(());
-                Ok(true)
-            },
-            Err(err) => self.set_error(false, err).await.map(|_| false),
+            Ok(JsValue::UNDEFINED)
+        });
+
+        let _callback_id = client
+            .on_error(Box::new(move |message: ClientError, reconnect| {
+                let poll_loop = poll_loop.clone();
+                async move {
+                    poll_loop.poll((message.into(), reconnect)).await;
+                    Ok(())
+                }
+            }))
+            .await?;
+
+        let sub = self.borrow_mut().view_sub.take();
+        self.borrow_mut().metadata = metadata;
+        self.borrow_mut().table = Some(table);
+        self.borrow_mut().pending_table = None;
+        self.borrow_mut().is_loading = false;
+        self.borrow_mut().last_validated_expressions = None;
+        sub.delete().await?;
+        self.table_loaded.emit(());
+        Ok(())
+    }
+
+    /// Record `name` as pending, dropping any bound `Table` so nothing binds
+    /// against the outgoing table while the name waits for a host.
+    pub(crate) async fn pend_table(&self, name: String) -> ApiResult<()> {
+        if self.is_disposed() {
+            return Err(ApiError::new("Panel disposed"));
         }
+
+        let sub = self.borrow_mut().view_sub.take();
+        self.borrow_mut().table = None;
+        self.borrow_mut().metadata = SessionMetadata::default();
+        self.borrow_mut().pending_table = Some(name);
+        self.borrow_mut().is_loading = false;
+        self.borrow_mut().last_validated_expressions = None;
+        sub.delete().await
     }
 
     pub async fn set_error(&self, reset_table: bool, err: ApiError) -> ApiResult<()> {
@@ -754,20 +845,20 @@ impl Session {
         // absent from the outgoing one — mirroring the "no table bound yet"
         // leniency already in `validate_names`. Authoritative validation is
         // deferred to the replay.
-        let pending = self.has_pending_load();
+        let window = self.0.pending_load.borrow().upgrade();
         let mut candidate = self.borrow().config.clone();
-        let journal_entry = pending.then(|| config_update.clone());
+        let journal_entry = window.is_some().then(|| config_update.clone());
         if !candidate.apply_update(config_update) {
             return Ok(());
         }
 
-        if let Some(entry) = journal_entry
-            && let Some(p) = self.0.pending_load.borrow_mut().as_mut()
+        if let Some(window) = &window
+            && let Some(entry) = journal_entry
         {
-            p.journal.push(entry);
+            window.journal.borrow_mut().push(entry);
         }
 
-        if !pending {
+        if window.is_none() {
             self.validate_names(&candidate)?;
         }
 
@@ -871,19 +962,10 @@ impl Session {
     /// [`Self::settle_dispatches`]. Used by the `perspective-config-update`
     /// dispatcher, whose landing `flush()` must be able to await.
     pub fn track_dispatch(&self, fut: impl std::future::Future<Output = ApiResult<()>> + 'static) {
-        self.0
-            .pending_dispatches
-            .set(self.0.pending_dispatches.get() + 1);
-        let session = self.clone();
+        let guard = self.0.dispatches.guard();
         ApiFuture::spawn_named("config-update-dispatch", async move {
-            let result = fut.await;
-            let remaining = session.0.pending_dispatches.get() - 1;
-            session.0.pending_dispatches.set(remaining);
-            if remaining == 0 {
-                session.0.dispatches_settled.emit(());
-            }
-
-            if let Err(e) = result {
+            let _guard = guard;
+            if let Err(e) = fut.await {
                 tracing::error!("[config-update dispatch] {}", e);
             }
 
@@ -894,10 +976,7 @@ impl Session {
     /// Resolve once every in-flight tracked dispatch for this panel has
     /// landed. Immediate when none are pending.
     pub async fn settle_dispatches(&self) -> ApiResult<()> {
-        while self.0.pending_dispatches.get() > 0 {
-            self.0.dispatches_settled.read_next().await?;
-        }
-
+        self.0.dispatches.settle().await;
         Ok(())
     }
 
@@ -917,26 +996,10 @@ impl Session {
     }
 
     /// Begin spinner accounting for ONE config-driven pipeline run: call
-    /// immediately after the run's commit, and move the returned token INTO
-    /// the run future. `Drop` settles it on every exit — completion, error,
-    /// cancellation, and runs that never reach `bind_view` (the
-    /// deferred-draw restore) — so, unlike edge-counting PubSub pairs, the
-    /// count cannot strand by construction.
-    /// [`SessionHandle::run_state_changed`] broadcasts the ABSOLUTE count
-    /// on both edges.
-    pub fn begin_config_run(&self) -> ConfigRunToken {
-        let count = self.0.in_flight_config_runs.get() + 1;
-        self.0.in_flight_config_runs.set(count);
-        self.run_state_changed.emit(count);
-        ConfigRunToken(self.clone())
-    }
-
-    /// The number of config-driven pipeline runs currently in flight (see
-    /// [`Self::begin_config_run`]). Read directly when (re)targeting a
-    /// panel — level-triggered consumers initialize from this and then
-    /// track [`SessionHandle::run_state_changed`].
-    pub fn in_flight_config_runs(&self) -> u32 {
-        self.0.in_flight_config_runs.get()
+    /// immediately after the run's commit, and move the returned guard INTO
+    /// the run future.
+    pub fn begin_config_run(&self) -> InFlightGuard {
+        self.0.config_runs.guard()
     }
 
     /// Read the cached `ColumnStats` for a column. Returns `None` if no
@@ -1094,31 +1157,7 @@ impl Session {
             .clone()
             .ok_or("`restore()` called before `load()`")?;
 
-        // Populate the aggregates with defaults as a courtesy to the
-        // virtual server api. Snapshot-local — never written back.
-        let mut view_config = (*effective).clone();
-        for col in view_config
-            .columns
-            .iter()
-            .flatten()
-            .chain(view_config.sort.iter().map(|x| &x.0))
-        {
-            if !view_config.aggregates.contains_key(col.as_str()) {
-                let agg = self
-                    .metadata()
-                    .get_column_aggregates(col.as_str())
-                    .and_then(|mut aggs| aggs.next())
-                    .into_apierror();
-
-                match agg {
-                    Err(_) => {
-                        tracing::warn!("No default aggregate for column '{}' found, skipping", col)
-                    },
-                    Ok(agg) => _ = view_config.aggregates.insert(col.to_string(), agg),
-                };
-            }
-        }
-
+        let view_config = self.with_default_aggregates(&effective);
         let view = table.view(Some(view_config.into())).await?;
         let view_schema = view.schema().await?;
         self.metadata_mut().update_view_schema(&view_schema)?;
@@ -1150,6 +1189,43 @@ impl Session {
         }
     }
 
+    /// The engine config for a `View` built from `effective`, per-column
+    /// default aggregates filled in as a courtesy to the virtual server API.
+    fn with_default_aggregates(&self, effective: &ViewConfig) -> ViewConfig {
+        let mut view_config = effective.clone();
+        for col in view_config
+            .columns
+            .iter()
+            .flatten()
+            .chain(view_config.sort.iter().map(|x| &x.0))
+        {
+            if !view_config.aggregates.contains_key(col.as_str()) {
+                let agg = self
+                    .metadata()
+                    .get_column_aggregates(col.as_str())
+                    .and_then(|mut aggs| aggs.next())
+                    .into_apierror();
+
+                match agg {
+                    Err(_) => {
+                        tracing::warn!("No default aggregate for column '{}' found, skipping", col)
+                    },
+                    Ok(agg) => _ = view_config.aggregates.insert(col.to_string(), agg),
+                };
+            }
+        }
+
+        view_config
+    }
+
+    /// Build a caller-owned `View` from the effective config outside the
+    /// render pipeline, with no subscription and no interaction with pause.
+    pub async fn create_detached_view(&self) -> ApiResult<View> {
+        let table = self.borrow().table.clone().ok_or("No `Table` set")?;
+        let view_config = self.with_default_aggregates(&self.effective_view_config());
+        Ok(table.view(Some(view_config.into())).await?)
+    }
+
     /// Record a failed pipeline run: error state plus a reconnect affordance
     /// that resets the config (the error screen's reset button). Replaces
     /// the old `validate()` error path — the committed config is NOT rolled
@@ -1239,6 +1315,8 @@ impl Session {
                 Some(TableLoadState::Loaded)
             } else if data.is_loading {
                 Some(TableLoadState::Loading)
+            } else if data.pending_table.is_some() {
+                Some(TableLoadState::Pending)
             } else {
                 None
             },