@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/config/workspace_config.rs

@@ -14,7 +14,7 @@ use std::collections::BTreeMap;
 
 use perspective_client::config::Filter;
 
-use crate::config::{PanelViewerConfig, ViewerConfigUpdate};
+use crate::config::{PanelViewerConfig, ViewerConfigInitial};
 
 /// The whole-element config format (`{version, active?, layout, panels}`) —
 /// the multi-panel counterpart of the single-panel [`ViewerConfig`] — as
@@ -59,10 +59,11 @@ pub struct WorkspaceConfig {
 }
 
 /// The parse target of a whole-element config in
-/// [`PerspectiveViewerElement::restore`]. Mirrors [`WorkspaceConfig`],
-/// but `panels` entries are full [`ViewerConfigUpdate`]s so a stray per-panel
-/// `settings` can be detected (warned, then ignored — `create_panel` strips
-/// it).
+/// [`PerspectiveViewerElement::restoreWorkspace`]. Mirrors
+/// [`WorkspaceConfig`], but `panels` entries are [`ViewerConfigInitial`]s —
+/// every entry creates a NEW panel, so `table` is required by type (a
+/// stray per-panel `settings` key is ignored; it is element-level state,
+/// carried by the top-level `active` field).
 #[derive(serde::Deserialize, ts_rs::TS)]
 pub struct WorkspaceConfigUpdate {
     #[serde(default)]
@@ -73,7 +74,7 @@ pub struct WorkspaceConfigUpdate {
     #[ts(optional)]
     pub layout: Option<crate::js::Layout>,
 
-    pub panels: BTreeMap<String, ViewerConfigUpdate>,
+    pub panels: BTreeMap<String, ViewerConfigInitial>,
 
     /// The element-level global (master/detail cross-) filters to re-apply as
     /// a transient overlay on every DETAIL panel. Restored as one

package/src/rust/custom_elements/viewer.rs

@@ -29,6 +29,8 @@ use wasm_bindgen_futures::JsFuture;
 use web_sys::HtmlElement;
 use yew::Callback;
 
+#[cfg(feature = "llm-agent")]
+use crate::agent::AgentRuntime;
 use crate::components::viewer::{PerspectiveViewerMsg, PerspectiveViewerProps};
 use crate::config::*;
 use crate::custom_events::*;
@@ -59,6 +61,16 @@ extern "C" {
     #[wasm_bindgen(typescript_type = "PanelOptions")]
     pub type JsPanelOptions;
 
+    /// `restore()` options dict
+    /// (`{ panel?: string, suppress_errors?: boolean }`).
+    #[wasm_bindgen(typescript_type = "RestoreOptions")]
+    pub type JsRestoreOptions;
+
+    /// `addPanel()` argument: a new panel's initial config — `table`
+    /// REQUIRED.
+    #[wasm_bindgen(typescript_type = "ViewerConfigInitial")]
+    pub type JsViewerConfigInitial;
+
     /// `download`/`export`/`copy` options dict
     /// (`{ method?: ExportMethod, panel?: string }`).
     #[wasm_bindgen(typescript_type = "ExportOptions")]
@@ -919,9 +931,12 @@ impl PerspectiveViewerElement {
     /// optional `{panel}` selector.
     ///
     /// If `panel` names no existing panel, a NEW panel is created with that id
-    /// and the config restored into it (an upsert), equivalent to
-    /// [`Self::addPanel`] but with a caller-chosen id. As with a created panel,
+    /// and the config restored into it (an upsert). As with a created panel,
     /// the element-level `settings`/`theme` fields are ignored in that case.
+    /// Unlike [`Self::addPanel`], the argument is a PATCH, so a `table` is
+    /// optional: creating without one yields a DEFERRED panel that the next
+    /// [`Self::load`] binds. Such a panel renders but cannot be serialized —
+    /// [`Self::save`] rejects with "Panel has no `table`" until it is bound.
     ///
     /// On an empty element with a pending [`Self::load`] whose payload is not
     /// yet classified, the active-target form (no `panel`) instead claims and
@@ -940,7 +955,15 @@ impl PerspectiveViewerElement {
     ///
     /// - `update` - The config to restore to, as returned by [`Self::save`] in
     ///   either "json", "string" or "arraybuffer" format.
-    /// - `name` - The panel to target, or `None` for the active panel.
+    /// - `options.panel` - The panel to target, or the active panel when
+    ///   omitted.
+    /// - `options.suppress_errors` - when `true`, a failed restore only rejects
+    ///   the returned `Promise`; the error is NOT committed to the viewer's
+    ///   visible error state and the session remains usable. The view config is
+    ///   rolled back to its pre-call value, so a rejected patch cannot re-merge
+    ///   into a later restore. Element-level state the call already applied
+    ///   (theme, title, a plugin swap) is NOT undone — restore a known-good
+    ///   config to recover those exactly.
     ///
     /// # JavaScript Examples
     ///
@@ -960,15 +983,62 @@ impl PerspectiveViewerElement {
     pub fn restore(
         &self,
         update: JsViewerConfigUpdate,
-        options: Option<JsPanelOptions>,
+        options: Option<JsRestoreOptions>,
     ) -> JsVoidPromise {
-        let PanelOptions { panel: name } = parse_options(options);
+        let RestoreOptions {
+            panel: name,
+            suppress_errors,
+        } = parse_options(options);
+
+        // `suppress_errors` failures reject the returned Promise WITHOUT
+        // committing to the viewer's visible error state — for programmatic
+        // callers (the agent's `set_view_config`) whose failed patches are
+        // caller feedback, not user-facing faults.
+        let errors = if suppress_errors.unwrap_or_default() {
+            RestoreErrors::Suppress
+        } else {
+            RestoreErrors::Publish
+        };
+
         let effect = self.workspace.effects().guard();
         let this = self.clone();
         let fut = ApiFuture::new_throttled(async move {
             let _effect = effect;
             let id = name.map(PanelId::from);
-            let update = ViewerConfigUpdate::decode(&update)?;
+            let mut update = ViewerConfigUpdate::decode(&update)?;
+
+            // `settings` is ELEMENT-level chrome, not panel state — it
+            // rides in this object only because the legacy single-panel
+            // `restore()` has always carried it. Apply it HERE and hand
+            // the panel pipeline a purely per-panel update: the
+            // panel-CREATING branch below converts to
+            // `ViewerConfigInitial`, which has no `settings` field at
+            // all, so a `restore()` against an empty element — the first
+            // call every embedding makes — would otherwise drop it
+            // silently. Applied BEFORE the panel work so the plugin
+            // draws once, already at its final size.
+            // BOTH halves move together, or the flag and the chrome
+            // disagree: `set_settings_before_open` writes the persisted
+            // `is_settings_open` (what `save()` reports) and the host
+            // `settings` attribute, while `ToggleSettingsComplete`
+            // performs the component's own toggle. `restore_and_render`
+            // used to do the first for the panel-UPDATING path only —
+            // which the creating path never reaches, since
+            // `ViewerConfigInitial` has no `settings` field to carry.
+            let settings = std::mem::replace(&mut update.settings, OptionalUpdate::Missing);
+            if !matches!(settings, OptionalUpdate::Missing) {
+                if let OptionalUpdate::Update(open) = settings {
+                    this.presentation.set_settings_before_open(open);
+                }
+
+                let (sender, receiver) = channel::<()>();
+                this.root.borrow().as_ref().into_apierror()?.send_message(
+                    PerspectiveViewerMsg::ToggleSettingsComplete(settings, sender),
+                );
+
+                receiver.await.unwrap_or_log();
+            }
+
             match this.workspace.panel_or_active(id.as_ref()) {
                 // An existing (or the active) panel — update it in place.
                 Some(panel) => {
@@ -978,9 +1048,9 @@ impl PerspectiveViewerElement {
                         &panel.renderer,
                         &this.presentation,
                         &this.workspace,
-                        Some(&this.root),
                         RestoreMode::Existing { active },
                         update,
+                        errors,
                     )
                     .await
                 },
@@ -1007,13 +1077,25 @@ impl PerspectiveViewerElement {
                                 &panel.renderer,
                                 &this.presentation,
                                 &this.workspace,
-                                Some(&this.root),
                                 RestoreMode::Existing { active: true },
                                 update,
+                                errors,
                             )
                             .await
                         },
                         None => {
+                            // The panel-creating upsert. `restore`'s
+                            // argument is a PATCH, so a `table` is
+                            // optional here as it is everywhere else on
+                            // this path: an update carrying none creates
+                            // a deferred panel, which the next `load()`
+                            // binds (it targets `active_panel()` before
+                            // reserving one of its own). The
+                            // table-required rule belongs to the
+                            // CREATION types — `addPanel`,
+                            // `restoreWorkspace`'s `panels`, the agent's
+                            // `add_panel` — which enforce it in their
+                            // own signatures.
                             create_panel(
                                 &this.elem,
                                 &this.presentation,
@@ -1063,9 +1145,9 @@ impl PerspectiveViewerElement {
                         &renderer,
                         &presentation,
                         &workspace,
-                        None,
                         RestoreMode::Fresh,
                         config,
+                        crate::tasks::RestoreErrors::Publish,
                     )
                     .await?;
                     if workspace.is_master(&id) {
@@ -1726,27 +1808,32 @@ impl PerspectiveViewerElement {
     }
 
     /// Add a new, independent panel to this viewer's layout, rendering the
-    /// supplied [`ViewerConfigUpdate`] into it. The panel uses the default
-    /// [`perspective_client::Client`] (the first passed to [`Self::load`]) to
-    /// resolve its `table`. Returns the generated panel id.
-    ///
-    /// Element-level config fields (`settings`, `theme`) in the argument are
-    /// ignored — those are shared across the element, not per-panel.
+    /// supplied [`ViewerConfigInitial`] into it. Unlike [`Self::restore`]'s
+    /// update-shaped argument, a new panel has no prior state, so `table`
+    /// is REQUIRED — a table-less call rejects before the layout is
+    /// touched. The panel uses the default [`perspective_client::Client`]
+    /// (the first passed to [`Self::load`]) to resolve its `table`. Returns
+    /// the generated panel id.
+    ///
+    /// The element-level `settings` field does not exist on the argument
+    /// type (it is shared across the element, not per-panel).
     #[wasm_bindgen]
-    pub fn addPanel(&self, update: JsViewerConfigUpdate) -> ApiFuture<JsValue> {
+    pub fn addPanel(&self, config: JsViewerConfigInitial) -> ApiFuture<JsValue> {
         clone!(self.elem, self.presentation, self.workspace);
         let effect = workspace.effects().guard();
         let notify = self.layout_changed_notify();
         ApiFuture::new(async move {
             let _effect = effect;
-            let update = ViewerConfigUpdate::decode(&update)?;
+            // The table-required guarantee is HERE, in the argument type
+            // and this decode — `create_panel` itself takes a patch.
+            let config = ViewerConfigInitial::decode(&config)?;
             let id = create_panel(
                 &elem,
                 &presentation,
                 &workspace,
                 &notify,
                 None,
-                update,
+                config.into(),
                 None,
             )
             .await?;
@@ -1864,3 +1951,107 @@ impl PerspectiveViewerElement {
         })
     }
 }
+
+#[cfg(feature = "llm-agent")]
+#[wasm_bindgen]
+impl PerspectiveViewerElement {
+    /// Configure the embedded LLM agent (see `prompt()`), replacing any prior
+    /// configuration and conversation.
+    ///
+    /// The agent core is provider-agnostic: one OpenAI-chat-completions
+    /// protocol over primitive connection fields. Exactly one of
+    /// `config.url` or `config.engine` is required; the `providers` presets
+    /// exported by this package are plain spreadable collections of these
+    /// fields (`{...providers.anthropic, apiKey}`).
+    ///
+    /// - `config.url` - a full chat-completions endpoint URL (any
+    ///   OpenAI-compatible service: Anthropic/Gemini compatibility endpoints,
+    ///   LM Studio, Ollama, OpenRouter, a proxy...).
+    /// - `config.engine` - an in-page engine object with an OpenAI-compatible
+    ///   `chat.completions.create(request)` method (e.g. WebLLM's `MLCEngine`);
+    ///   mutually exclusive with `url`.
+    /// - `config.headers` - extra request headers, sent verbatim.
+    /// - `config.apiKey` - sugar for the `Authorization: Bearer` header.
+    /// - `config.model` - model id sent with each request; local servers and
+    ///   engines generally answer with whatever model is loaded.
+    /// - `config.name` - cosmetic label for the chat badge (presets set this).
+    /// - `config.systemPrompt` - extra system-prompt context appended to the
+    ///   agent's built-in instructions.
+    /// - `config.maxTurns` - max model turns (tool-call rounds + the final
+    ///   answer) per `prompt()` call. Defaults to 16.
+    /// - `config.docs` - the agent metadata bundle, which supplies the
+    ///   `search_docs` corpus and the rich tool parameter schemas: the packaged
+    ///   `dist/docs/perspective-docs.json` asset as a parsed object (`import
+    ///   docs from "…json" with { type: "json" }`), a `fetch()` `Response`, an
+    ///   `ArrayBuffer`, a JSON string, or a `Promise` of any of those — and/or
+    ///   an inline array of `{title?, text}` entries for host data definitions.
+    ///   Omitted, `search_docs` searches an empty corpus and the parameter
+    ///   schemas degrade to permissive objects.
+    /// - `config.systemRole` - where the preamble (plus `systemPrompt`) is
+    ///   placed: `"system"` (default) or `"user"`. Some engines refuse a system
+    ///   message alongside `tools` because they substitute their own — WebLLM's
+    ///   Hermes function calling throws `CustomSystemPromptError` on ANY system
+    ///   message — and those need `"user"`, which folds the same text into the
+    ///   opening user turn.
+    /// - `config.entitlements` - access grants limiting which tools the agent
+    ///   is offered (and may call): any of `"read_view"`, `"configure_view"`,
+    ///   `"manage_layout"`, `"read_docs"`, `"read_data"`. Omitted, all but
+    ///   `"read_data"` are granted; `["read_view", "read_docs"]` yields a
+    ///   read-only agent.
+    ///
+    /// # JavaScript Examples
+    ///
+    /// ```javascript
+    /// import { providers } from "@perspective-dev/viewer";
+    ///
+    /// viewer.agentConfig({
+    ///     ...providers.anthropic,
+    ///     apiKey: "sk-ant-...",
+    ///     docs: fetch(
+    ///         "node_modules/@perspective-dev/viewer/dist/docs/perspective-docs.json",
+    ///     ),
+    /// });
+    /// ```
+    #[wasm_bindgen(js_name = "agentConfig")]
+    pub fn agent_config(&self, config: JsValue) -> ApiResult<()> {
+        let runtime = AgentRuntime::new(&config, self.clone())?;
+        self.presentation.agent.configure(runtime);
+        Ok(())
+    }
+
+    /// Run one conversational turn of the embedded LLM agent (configured via
+    /// `agentConfig()`), resolving with the agent's final text response after
+    /// any tool calls have been applied to this element. Turns share a
+    /// conversation history (and the chat sidebar's transcript) until
+    /// `agentReset()`; a call made while a turn is already running rejects.
+    /// Tool activity is emitted as `perspective-agent-tool` CustomEvents on
+    /// this element.
+    ///
+    /// # JavaScript Examples
+    ///
+    /// ```javascript
+    /// await viewer.agentPrompt("Show me sales by region as a bar chart");
+    /// ```
+    #[wasm_bindgen(js_name = "agentPrompt")]
+    pub fn agent_prompt(&self, prompt: String) -> js_sys::Promise {
+        let presentation = self.presentation.clone();
+        let fut = ApiFuture::new(async move {
+            Ok(JsValue::from(presentation.agent.run_prompt(prompt).await?))
+        });
+
+        js_sys::Promise::from(fut)
+    }
+
+    /// Clear the agent's conversation (history and chat transcript), keeping
+    /// its configuration. Cancels any in-flight turn.
+    #[wasm_bindgen(js_name = "agentReset")]
+    pub fn agent_reset(&self) -> js_sys::Promise {
+        let presentation = self.presentation.clone();
+        let fut = ApiFuture::new(async move {
+            presentation.agent.reset().await;
+            Ok(JsValue::UNDEFINED)
+        });
+
+        js_sys::Promise::from(fut)
+    }
+}

package/src/rust/custom_events.rs

@@ -261,7 +261,36 @@ pub fn wire_element_events(
         }
     });
 
+    let layout_sub = workspace.layout_changed().add_listener({
+        clone!(elem);
+        move |panels: Vec<crate::workspace::PanelId>| {
+            let ids = panels
+                .iter()
+                .map(|id| JsValue::from_str(id.as_str()))
+                .collect::<js_sys::Array>();
+
+            let detail = js_sys::Object::new();
+            let _ = js_sys::Reflect::set(&detail, &JsValue::from_str("panels"), &ids);
+            dispatch_event(&elem, "layout-update", JsValue::from(detail)).unwrap();
+        }
+    });
+
+    let active_panel_sub = workspace.active_changed().add_listener({
+        clone!(elem);
+        move |active: Option<crate::workspace::PanelId>| {
+            let panel = active
+                .map(|id| JsValue::from_str(id.as_str()))
+                .unwrap_or(JsValue::NULL);
+
+            let detail = js_sys::Object::new();
+            let _ = js_sys::Reflect::set(&detail, &JsValue::from_str("panel"), &panel);
+            dispatch_event(&elem, "active-panel-update", JsValue::from(detail)).unwrap();
+        }
+    });
+
     vec![
+        layout_sub,
+        active_panel_sub,
         theme_sub,
         before_settings_sub,
         settings_sub,

package/src/rust/lib.rs

@@ -31,6 +31,8 @@
 // `SESSION_CONFIG_COHERENCE_PLAN.md`) — deny, don't warn.
 #![deny(clippy::await_holding_refcell_ref)]
 
+#[cfg(feature = "llm-agent")]
+mod agent;
 pub mod components;
 pub mod config;
 pub mod custom_elements;
@@ -71,34 +73,48 @@ import type {
     ColumnType,
     TableInitOptions,
     ColumnWindow,
-    ViewWindow, 
+    ViewWindow,
     TypedArrayWindow,
     OnUpdateOptions,
     JoinOptions,
     UpdateOptions,
     DeleteOptions,
+    ViewConfig,
     ViewConfigUpdate,
     SystemInfo,
+    Scalar,
+    Features,
 } from "@perspective-dev/client";
 
 export type * from "../../src/ts/ts-rs/ViewerConfig.d.ts";
 export type * from "../../src/ts/ts-rs/ViewerConfigUpdate.d.ts";
+export type * from "../../src/ts/ts-rs/ViewerConfigInitial.d.ts";
 export type * from "../../src/ts/ts-rs/PluginStaticConfig.d.ts";
 export type * from "../../src/ts/ts-rs/WorkspaceConfig.d.ts";
 export type * from "../../src/ts/ts-rs/WorkspaceConfigUpdate.d.ts";
 export type * from "../../src/ts/ts-rs/ExportMethod.d.ts";
 export type * from "../../src/ts/ts-rs/PanelOptions.d.ts";
+export type * from "../../src/ts/ts-rs/RestoreOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ClientOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ExportOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 export type * from "../../src/ts/ts-rs/GetClientOptions.d.ts";
+export type * from "../../src/ts/ts-rs/CustomNumberFormatConfig.d.ts";
+export type * from "../../src/ts/ts-rs/NumberFormatStyle.d.ts";
+export type * from "../../src/ts/ts-rs/Notation.d.ts";
+export type * from "../../src/ts/ts-rs/DatetimeFormatType.d.ts";
+export type * from "../../src/ts/ts-rs/StringColorMode.d.ts";
+export type * from "../../src/ts/ts-rs/DatetimeColorMode.d.ts";
+export type * from "../../src/ts/ts-rs/FormatMode.d.ts";
 import type {GetTableOptions} from "../../src/ts/ts-rs/GetTableOptions.d.ts";
 import type {PanelOptions} from "../../src/ts/ts-rs/PanelOptions.d.ts";
+import type {RestoreOptions} from "../../src/ts/ts-rs/RestoreOptions.d.ts";
 import type {ExportOptions} from "../../src/ts/ts-rs/ExportOptions.d.ts";
 import type {GetClientOptions} from "../../src/ts/ts-rs/GetClientOptions.d.ts";
 import type {ClientOptions} from "../../src/ts/ts-rs/ClientOptions.d.ts";
 import type {ViewerConfig} from "../../src/ts/ts-rs/ViewerConfig.d.ts";
 import type {ViewerConfigUpdate} from "../../src/ts/ts-rs/ViewerConfigUpdate.d.ts";
+import type {ViewerConfigInitial} from "../../src/ts/ts-rs/ViewerConfigInitial.d.ts";
 import type {WorkspaceConfig} from "../../src/ts/ts-rs/WorkspaceConfig.d.ts";
 import type {WorkspaceConfigUpdate} from "../../src/ts/ts-rs/WorkspaceConfigUpdate.d.ts";
 "#;

package/src/rust/presentation/column_locator.rs

@@ -19,6 +19,7 @@ use std::fmt::Display;
 pub enum ColumnLocator {
     Table(String),
     Expression(String),
+    Window(String),
     NewExpression,
 }
 
@@ -28,7 +29,7 @@ impl ColumnLocator {
     /// function will return None.
     pub fn name(&self) -> Option<&String> {
         match self {
-            Self::Table(s) | Self::Expression(s) => Some(s),
+            Self::Table(s) | Self::Expression(s) | Self::Window(s) => Some(s),
             Self::NewExpression => None,
         }
     }
@@ -50,6 +51,19 @@ impl ColumnLocator {
     pub fn is_new_expr(&self) -> bool {
         matches!(self, ColumnLocator::NewExpression)
     }
+
+    #[inline(always)]
+    pub fn is_saved_window(&self) -> bool {
+        matches!(self, ColumnLocator::Window(_))
+    }
+
+    #[inline(always)]
+    pub fn is_window_editable(&self) -> bool {
+        matches!(
+            self,
+            ColumnLocator::Window(_) | ColumnLocator::NewExpression
+        )
+    }
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
@@ -57,6 +71,7 @@ impl ColumnLocator {
 pub enum ColumnSettingsTab {
     #[default]
     Attributes,
+    Window,
     Style,
 }
 

package/src/rust/presentation.rs

@@ -63,6 +63,12 @@ impl DragState {
 pub struct PresentationHandle {
     viewer_elem: HtmlElement,
 
+    /// The embedded LLM agent's shared model (runtime + chat transcript) —
+    /// carried here so the settings sidebar can render the chat tab without
+    /// threading a new prop chain from the element.
+    #[cfg(feature = "llm-agent")]
+    pub agent: crate::agent::AgentSlot,
+
     /// The available themes as detected in the browser environment or set
     /// explicitly when CORS prevents detection — a MEMO of a document
     /// external, not component state. `None` until first parsed (detection
@@ -148,6 +154,8 @@ impl Presentation {
     pub fn new(elem: &HtmlElement) -> Self {
         let theme = Self(Rc::new(PresentationHandle {
             viewer_elem: elem.clone(),
+            #[cfg(feature = "llm-agent")]
+            agent: Default::default(),
             themes: Default::default(),
             theme_init: Default::default(),
             is_workspace: Default::default(),

package/src/rust/queries/columns_iter_set.rs

@@ -102,7 +102,8 @@ impl<'a> ColumnsIteratorSet<'a> {
                     .get_table_columns()
                     .map(|x: &Vec<String>| x.len())
                     .unwrap_or_default()
-                    + self.config.expressions.len();
+                    + self.config.expressions.len()
+                    + self.config.windows.len();
 
         match &self.is_dragover_column {
             Some((to_index, from_column)) => {
@@ -238,6 +239,11 @@ impl<'a> ColumnsIteratorSet<'a> {
         self.order_columns(self.metadata.get_expression_columns())
     }
 
+    /// Generate an iterator for inactive window columns.
+    pub fn window(&'a self) -> impl Iterator<Item = OrderedColumn<'a>> {
+        self.order_columns(self.metadata.get_window_columns())
+    }
+
     /// Generate an iterator for inactive columns, which also shows the columns
     /// in sorted order by type, then name.
     pub fn inactive(&'a self) -> impl Iterator<Item = OrderedColumn<'a>> {

package/src/rust/queries/get_viewer_config.rs

@@ -51,10 +51,14 @@ pub async fn get_viewer_config(
         None => presentation.get_selected_theme_name().await,
     };
     let title = session.get_title();
+    // Placed ⇒ bound (or binding in flight): creation requires a `table`
+    // by type, so a panel with neither a bound nor pending table is an
+    // invariant violation, not a serializable state.
     let table = session
         .get_table()
         .map(|x| x.get_name().to_owned())
-        .or_else(|| session.pending_table());
+        .or_else(|| session.pending_table())
+        .ok_or_else(|| ApiError::from("Panel has no `table`"))?;
     let columns_config = renderer.all_columns_configs();
     Ok(ViewerConfig {
         settings,