@perspective-dev/viewer 5.1.0 → 5.2.0

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;
@@ -86,22 +88,33 @@ import type {
 
 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.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/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,

package/src/rust/session/column_defaults_update.rs

@@ -52,6 +52,24 @@ pub impl ViewConfigUpdate {
                 self.group_rollup_mode
             );
         }
+
+        let split_rollup_features = metadata
+            .get_features()
+            .map(|x| x.get_split_rollup_modes())
+            .unwrap_or_default();
+
+        let split_rollups = config_static.get_split_rollups(&split_rollup_features);
+        if !split_rollups.contains(
+            self.split_rollup_mode
+                .as_ref()
+                .unwrap_or(&SplitRollupMode::Flat),
+        ) {
+            self.split_rollup_mode = split_rollups.first().cloned();
+            tracing::debug!(
+                "Setting plugin-advised split rollup mode {:?}",
+                self.split_rollup_mode
+            );
+        }
     }
 
     /// Appends additional columns to the `columns` field of this

package/src/rust/session/metadata.rs

@@ -98,34 +98,20 @@ impl SessionMetadata {
 
     /// Records the pre-aggregation types of the config's window columns, so
     /// `get_column_table_type` resolves them like any other derived column.
-    /// Types mirror the engine's `t_window_engine::resolve_dtype` rules from
-    /// the window's op and its source's table type - independent of any
-    /// aggregation the view may also apply.
     pub(super) fn update_windows(
         &mut self,
         windows: &perspective_client::config::Windows,
     ) -> ApiResult<()> {
-        use perspective_client::config::WindowAggregate;
         let window_schema = windows
             .iter()
             .filter_map(|(name, w)| {
                 let source = self.get_column_table_type(&w.column)?;
-                let dtype = match w.aggregate {
-                    WindowAggregate::Sum
-                    | WindowAggregate::Avg
-                    | WindowAggregate::Stddev
-                    | WindowAggregate::Var
-                    | WindowAggregate::Rate
-                    | WindowAggregate::Ema
-                    | WindowAggregate::Diff => ColumnType::Float,
-                    WindowAggregate::Count => ColumnType::Integer,
-                    WindowAggregate::Min
-                    | WindowAggregate::Max
-                    | WindowAggregate::First
-                    | WindowAggregate::Last
-                    | WindowAggregate::Lag
-                    | WindowAggregate::Lead => source,
-                };
+                let dtype = self
+                    .get_window_aggregate(source, &w.aggregate)
+                    .and_then(|spec| spec.result_type)
+                    .and_then(|ty| ColumnType::try_from(ty).ok())
+                    .unwrap_or(source);
+
                 Some((name.clone(), dtype))
             })
             .collect();
@@ -133,6 +119,18 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// The declaration for one window aggregate over a `source` column type.
+    pub fn get_window_aggregate(
+        &self,
+        source: ColumnType,
+        name: &str,
+    ) -> Option<perspective_client::proto::WindowAggregateArgs> {
+        self.get_features()?
+            .get_window_aggregates(source)
+            .into_iter()
+            .find(|x| x.name == name)
+    }
+
     /// Whether `view_schema` has been populated by a prior successful
     /// `create_view`. Used by `Session::create_view` to force a full
     /// build on first run even when `is_clean` happens to be true, so

package/src/rust/session/replace_expression_update.rs

@@ -126,6 +126,7 @@ pub impl ViewConfig {
             filter_op: None,
             group_by_depth: None,
             group_rollup_mode: None,
+            split_rollup_mode: None,
             windows: None,
         }
     }

package/src/rust/tasks/create_panel.rs

@@ -69,13 +69,23 @@ fn wire_panel_render_sub(session: &Session, renderer: &Renderer) -> Subscription
     })
 }
 
-/// Create a new independent panel (own `Session` + `Renderer` + id) from a
-/// `ViewerConfigUpdate`, mount and draw it, and return its id. Shared by
-/// `addPanel`, whole-element `restore`, and `restorePanel`'s create-if-missing
-/// path. `id` is the panel's id — provided when restoring into a specific named
-/// slot, or `None` to generate a fresh one. `settings`/`theme` are stripped
-/// (element-level, not per-panel) and `client` — or the element's default
-/// client when `None` — is bound so the config's `table` resolves against it.
+/// Create a new independent panel (own `Session` + `Renderer` + id) and
+/// restore `update` into it. Shared by `addPanel`, `restore`'s
+/// create-if-missing upsert, and `restorePanel`. `id` is the panel's id —
+/// provided when restoring into a specific named slot, or `None` to
+/// generate a fresh one. `theme` is stripped (element-level, not
+/// per-panel) and `client` — or the element's default client when `None` —
+/// is bound so the config's `table` resolves against it.
+///
+/// A `table` is OPTIONAL here: an update with none creates a deferred
+/// panel that a later `load()` binds, which is the pre-existing
+/// `restore`-then-`load` contract and the same state the reserved
+/// `load()` path produces. The routes where a table-less panel WOULD be
+/// permanently blank require one in their own argument types instead —
+/// `addPanel`'s [`ViewerConfigInitial`], `WorkspaceConfigUpdate`'s
+/// `panels` entries, and the agent's `add_panel` — so the guarantee sits
+/// at the boundary that owns it rather than here, which would sweep
+/// `restore`'s patch in with them.
 pub(crate) async fn create_panel(
     elem: &HtmlElement,
     presentation: &Presentation,
@@ -128,9 +138,9 @@ pub(crate) async fn create_panel(
         &renderer,
         presentation,
         workspace,
-        None,
         RestoreMode::Fresh,
         update,
+        crate::tasks::RestoreErrors::Publish,
     )
     .await;
 

package/src/rust/tasks/edit_window.rs

@@ -93,7 +93,7 @@ pub fn update_window(
                     config
                         .columns
                         .iter()
-                        .map(|col| col.as_ref().map(&rename))
+                        .map(|col| col.as_ref().map(rename))
                         .collect(),
                 );
                 update.group_by = Some(config.group_by.iter().map(&rename).collect());

package/src/rust/tasks/restore_panel.rs

@@ -10,15 +10,12 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-use futures::channel::oneshot::channel;
 use perspective_client::clone;
 use perspective_client::utils::PerspectiveResultExt;
 
-use crate::components::viewer::{PerspectiveViewer, PerspectiveViewerMsg};
 use crate::config::*;
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
-use crate::root::Root;
 use crate::session::{ResetOptions, Session};
 use crate::tasks::*;
 use crate::workspace::Workspace;
@@ -31,6 +28,20 @@ pub(crate) enum RestoreMode {
     Fresh,
 }
 
+/// Where a failed restore's error goes. `Publish` (every user-facing path)
+/// commits it to the session — the visible error UI and errored session
+/// state. `Suppress` (the agent's `set_view_config` tool) returns it ONLY
+/// to the caller: the model receives the error as a tool result and
+/// self-corrects, so the transient failure is noise to the human user —
+/// and the errored session state would otherwise BLOCK the corrected
+/// retry, since error recovery below requires a `table` field the model's
+/// patches don't carry.
+#[derive(Clone, Copy)]
+pub(crate) enum RestoreErrors {
+    Publish,
+    Suppress,
+}
+
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
@@ -57,9 +68,9 @@ pub(crate) async fn restore_panel(
     renderer: &Renderer,
     presentation: &Presentation,
     workspace: &Workspace,
-    root: Option<&Root<PerspectiveViewer>>,
     mode: RestoreMode,
     mut update: ViewerConfigUpdate,
+    errors: RestoreErrors,
 ) -> ApiResult<()> {
     let active = matches!(mode, RestoreMode::Existing { active: true });
     let fresh = matches!(mode, RestoreMode::Fresh);
@@ -77,17 +88,17 @@ pub(crate) async fn restore_panel(
         tracing::info!("Restoring {update}");
     }
 
-    let (sender, receiver) = channel::<()>();
-    match (active, root) {
-        (true, Some(root)) => {
-            root.borrow().as_ref().into_apierror()?.send_message(
-                PerspectiveViewerMsg::ToggleSettingsComplete(update.settings.clone(), sender),
-            );
-        },
-        _ => {
-            let _ = sender.send(());
-        },
-    }
+    // NOTE: `update.settings` is deliberately NOT applied here. It is
+    // element-level chrome rather than panel state, so `restore()` — the
+    // only caller that can carry it — applies it before dispatching, and
+    // this pipeline stays per-panel. Applying it here reached only the
+    // `Existing { active: true }` mode, which is why a freshly created
+    // panel silently ignored it.
+
+    // Under `Suppress` the restore is TRANSACTIONAL, so snapshot the config
+    // it is about to overwrite — see the failure tail below for why.
+    let rollback =
+        matches!(errors, RestoreErrors::Suppress).then(|| session.get_view_config().clone());
 
     let table_changed = !fresh
         && matches!(&update.table, OptionalUpdate::Update(name)
@@ -122,7 +133,6 @@ pub(crate) async fn restore_panel(
                     bind_table_task(&session, &workspace, name).await?;
                 }
 
-                receiver.await.unwrap_or_log();
                 Ok(())
             }
         },
@@ -130,7 +140,14 @@ pub(crate) async fn restore_panel(
     .await;
 
     if let Err(e) = &result {
-        session.set_error(false, e.clone()).await?;
+        match errors {
+            RestoreErrors::Publish => session.set_error(false, e.clone()).await?,
+            RestoreErrors::Suppress => {
+                if let Some(config) = rollback {
+                    session.commit_view_config(config.into()).unwrap_or_log();
+                }
+            },
+        }
     }
 
     result?;

package/src/rust/tasks/sync_update_panels.rs

@@ -55,20 +55,19 @@ pub fn sync_update_panels(
     let mut fallback_fresh: Option<String> = None;
     let mut active_fresh: Option<String> = None;
     let mut contents = Vec::new();
+    // `panels` entries are `ViewerConfigInitial`s — `table` required by
+    // TYPE (a placed panel without a binding would be permanently blank),
+    // and no per-panel `settings` exists (element-level; carried by the
+    // top-level `active` field). An EMPTY `panels` map restores to the
+    // zero-panel empty stage — the former table-less fallback panel was
+    // exactly the blank-panel state this type exists to preclude.
     for (saved_id, config) in panels {
-        if !matches!(config.settings, OptionalUpdate::Missing) {
-            #[rustfmt::skip]
-            tracing::warn!(
-                "`settings` on panel \"{saved_id}\" is ignored in a whole-element config; use the top-level `active` field"
-            );
-        }
-
         let (fresh, session, renderer, config) = create_panel_model(
             &this.elem,
             &this.presentation,
             &this.workspace,
             None,
-            config,
+            config.into(),
             None,
             Placement::Placed,
         );
@@ -82,21 +81,6 @@ pub fn sync_update_panels(
         contents.push((fresh, session, renderer, config));
     }
 
-    if contents.is_empty() {
-        let (fresh, session, renderer, config) = create_panel_model(
-            &this.elem,
-            &this.presentation,
-            &this.workspace,
-            None,
-            ViewerConfigUpdate::default(),
-            None,
-            Placement::Placed,
-        );
-
-        fallback_fresh = Some(fresh.as_str().to_owned());
-        contents.push((fresh, session, renderer, config));
-    }
-
     let mut eject_tasks = Vec::new();
     if let Some(panel) = this.workspace.take_reserved() {
         eject_tasks.push(eject_panel(panel));

package/src/rust/workspace.rs

@@ -21,7 +21,7 @@ use perspective_client::config::Filter;
 
 use crate::renderer::Renderer;
 use crate::session::Session;
-use crate::utils::{EffectLedger, PubSub, Subscription};
+use crate::utils::{EffectLedger, PubSub, Subscription, spawn_owned};
 
 /// A unique identifier for a [`Panel`] within a [`Workspace`].
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -243,6 +243,22 @@ struct WorkspaceData {
     /// In-flight effects (public mutators + scheduled internal flows),
     /// drained by `flush()` — see [`EffectLedger`].
     effects: EffectLedger,
+
+    /// The PLACED panel set changed since the last emit. Mutation sites set
+    /// this and emit NOTHING; the coalescing flush task owns delivery (see
+    /// [`Workspace::schedule_layout_flush`]).
+    layout_dirty: bool,
+    layout_changed: Rc<PubSub<Vec<PanelId>>>,
+
+    /// The active panel changed since the last emit. A separate channel from
+    /// `layout_dirty`: "which panel is selected" and "which panels exist" are
+    /// distinct facts, and one event may not mean both.
+    active_dirty: bool,
+    active_changed: Rc<PubSub<Option<PanelId>>>,
+
+    /// A flush task is already queued — the flag that makes N mutations
+    /// within one operation schedule ONE task rather than N.
+    flush_scheduled: bool,
 }
 
 impl Default for Workspace {
@@ -269,6 +285,11 @@ impl Workspace {
             staged_changed: Rc::new(PubSub::default()),
             reserved: None,
             effects: EffectLedger::default(),
+            layout_dirty: false,
+            layout_changed: Rc::new(PubSub::default()),
+            active_dirty: false,
+            active_changed: Rc::new(PubSub::default()),
+            flush_scheduled: false,
         })))
     }
 
@@ -277,6 +298,62 @@ impl Workspace {
         self.0.borrow().effects.clone()
     }
 
+    pub fn layout_changed(&self) -> Rc<PubSub<Vec<PanelId>>> {
+        self.0.borrow().layout_changed.clone()
+    }
+
+    pub fn active_changed(&self) -> Rc<PubSub<Option<PanelId>>> {
+        self.0.borrow().active_changed.clone()
+    }
+
+    /// Queue the coalescing layout-event flush, if anything is dirty and no
+    /// flush is already pending.
+    fn schedule_layout_flush(&self) {
+        let schedule = {
+            let mut data = self.0.borrow_mut();
+            let dirty = data.layout_dirty || data.active_dirty;
+            let queued = data.flush_scheduled;
+            data.flush_scheduled |= dirty;
+            dirty && !queued
+        };
+
+        if !schedule {
+            return;
+        }
+
+        let effects = self.effects();
+        let this = self.clone();
+        spawn_owned("workspace_layout_flush", async move {
+            effects.settle().await;
+            this.flush_layout_events();
+            Ok(())
+        });
+    }
+
+    /// Emit whatever is dirty, outside any borrow.
+    fn flush_layout_events(&self) {
+        let (layout, active, panels, active_id, layout_pubsub, active_pubsub) = {
+            let mut data = self.0.borrow_mut();
+            data.flush_scheduled = false;
+            (
+                std::mem::take(&mut data.layout_dirty),
+                std::mem::take(&mut data.active_dirty),
+                data.panels.iter().map(|p| p.id.clone()).collect::<Vec<_>>(),
+                data.active.clone(),
+                data.layout_changed.clone(),
+                data.active_changed.clone(),
+            )
+        };
+
+        if layout {
+            layout_pubsub.emit(panels);
+        }
+
+        if active {
+            active_pubsub.emit(active_id);
+        }
+    }
+
     /// Stage a layout tree for `MainPanel` to apply at its next `rendered`
     /// pass (see `WorkspaceData::pending_layout`).
     pub fn set_pending_layout(&self, layout: crate::js::Layout) {
@@ -512,16 +589,22 @@ impl Workspace {
     /// Append a [`Panel`]. When the element had zero panels, the inserted panel
     /// becomes the active one (there is no other candidate).
     pub fn insert_panel(&self, panel: Panel) {
-        let mut data = self.0.borrow_mut();
-        if data.active.is_none() {
-            data.active = Some(panel.id.clone());
+        {
+            let mut data = self.0.borrow_mut();
+            if data.active.is_none() {
+                data.active = Some(panel.id.clone());
+                data.active_dirty = true;
+            }
+
+            panel
+                .renderer
+                .set_active_flag(data.active.as_ref() == Some(&panel.id));
+            data.panels.push(panel);
+            data.layout_dirty = true;
+            Self::sync_solo_flags(&data);
         }
 
-        panel
-            .renderer
-            .set_active_flag(data.active.as_ref() == Some(&panel.id));
-        data.panels.push(panel);
-        Self::sync_solo_flags(&data);
+        self.schedule_layout_flush();
     }
 
     /// Hold `panel` in the reservation slot (see [`WorkspaceData::reserved`]):
@@ -585,8 +668,10 @@ impl Workspace {
 
             if data.active.as_ref() == Some(id) {
                 data.active = None;
+                data.active_dirty = true;
             }
 
+            data.layout_dirty |= removed.is_some();
             Self::sync_solo_flags(&data);
             (
                 removed,
@@ -605,25 +690,32 @@ impl Workspace {
             staged_pubsub.emit(());
         }
 
+        self.schedule_layout_flush();
         removed
     }
 
     /// Set the active panel. Returns `false` (no-op) if `id` is not a known
     /// panel.
     pub fn set_active(&self, id: PanelId) -> bool {
-        let mut data = self.0.borrow_mut();
-        if data.panels.iter().any(|p| p.id == id) {
-            data.active = Some(id);
-            for panel in data.panels.iter() {
-                panel
-                    .renderer
-                    .set_active_flag(data.active.as_ref() == Some(&panel.id));
+        let known = {
+            let mut data = self.0.borrow_mut();
+            if data.panels.iter().any(|p| p.id == id) {
+                data.active_dirty |= data.active.as_ref() != Some(&id);
+                data.active = Some(id);
+                for panel in data.panels.iter() {
+                    panel
+                        .renderer
+                        .set_active_flag(data.active.as_ref() == Some(&panel.id));
+                }
+
+                true
+            } else {
+                false
             }
+        };
 
-            true
-        } else {
-            false
-        }
+        self.schedule_layout_flush();
+        known
     }
 
     /// The default [`Client`], if one has been loaded.

package/src/themes/intl/de.css

@@ -118,6 +118,22 @@ perspective-dropdown {
     --psp-label--query-tab--content: "Abfrage";
     --psp-label--plugin-tab--content: "Plugin";
     --psp-label--debug-tab--content: "JSON";
+    --psp-label--chat-tab--content: "Chat";
+
+    /* Chat panel */
+    --psp-label--chat-reasoning--content: "Denkprozess";
+    --psp-label--chat-send--content: "Senden";
+    --psp-label--chat-stop--content: "Stopp";
+    --psp-label--chat-placeholder--content: "Frage zu Ihren Daten…";
+
+    /* Plugin-declared pivot roles (PluginStaticConfig) */
+    --psp-label--role--x-axis--content: "X-Achse";
+    --psp-label--role--y-axis--content: "Y-Achse";
+    --psp-label--role--series--content: "Serien";
+    --psp-label--role--hierarchy--content: "Hierarchie";
+    --psp-label--role--facets--content: "Facetten";
+    --psp-label--role--row-groups--content: "Zeilengruppen";
+    --psp-label--role--column-groups--content: "Spaltengruppen";
 
     /* Plugin settings */
     --psp-label--edit-mode--content: "Bearbeitungsmodus";

package/src/themes/intl/es.css

@@ -118,6 +118,22 @@ perspective-dropdown {
     --psp-label--query-tab--content: "Consulta";
     --psp-label--plugin-tab--content: "Plugin";
     --psp-label--debug-tab--content: "JSON";
+    --psp-label--chat-tab--content: "Chat";
+
+    /* Chat panel */
+    --psp-label--chat-reasoning--content: "Razonamiento";
+    --psp-label--chat-send--content: "Enviar";
+    --psp-label--chat-stop--content: "Detener";
+    --psp-label--chat-placeholder--content: "Pregunta sobre tus datos…";
+
+    /* Plugin-declared pivot roles (PluginStaticConfig) */
+    --psp-label--role--x-axis--content: "Eje X";
+    --psp-label--role--y-axis--content: "Eje Y";
+    --psp-label--role--series--content: "Series";
+    --psp-label--role--hierarchy--content: "Jerarquía";
+    --psp-label--role--facets--content: "Facetas";
+    --psp-label--role--row-groups--content: "Grupos de filas";
+    --psp-label--role--column-groups--content: "Grupos de columnas";
 
     /* Plugin settings */
     --psp-label--edit-mode--content: "Modo de edición";