@perspective-dev/viewer 5.2.0 → 5.3.1

package/src/rust/custom_elements/viewer.rs

@@ -84,11 +84,15 @@ extern "C" {
     #[wasm_bindgen(typescript_type = "GetClientOptions")]
     pub type JsGetClientOptions;
 
-    /// `restoreWorkspace()` argument: a whole-element config update.
+    /// `restoreWorkspace()` argument: a workspace config update.
     #[wasm_bindgen(typescript_type = "WorkspaceConfigUpdate")]
     pub type JsWorkspaceConfigUpdate;
 
-    /// `saveWorkspace()` return: a whole-element config.
+    /// `saveWorkspace()` options dict (`{ full_palette?: boolean }`).
+    #[wasm_bindgen(typescript_type = "SaveWorkspaceOptions")]
+    pub type JsSaveWorkspaceOptions;
+
+    /// `saveWorkspace()` return: a workspace config.
     #[wasm_bindgen(typescript_type = "Promise<WorkspaceConfig>")]
     pub type JsWorkspaceConfigPromise;
 
@@ -201,7 +205,8 @@ impl PerspectiveViewerElement {
             .map(|el| el.unchecked_into())
     }
 
-    async fn workspace_config(this: Self) -> ApiResult<JsValue> {
+    async fn workspace_config(this: Self, full_palette: bool) -> ApiResult<JsValue> {
+        this.workspace.effects().settle().await;
         let mut panels: std::collections::BTreeMap<String, PanelViewerConfig> = Default::default();
         for id in &this.workspace.panel_ids() {
             let panel = this.workspace.panel(id).into_apierror()?;
@@ -216,6 +221,26 @@ impl PerspectiveViewerElement {
             panels.insert(id.as_str().to_owned(), config.panel);
         }
 
+        let mut palette = palette_set(&this.workspace, &this.presentation);
+        let mut referenced = std::collections::BTreeSet::new();
+        for (id, item) in styles_in_use(&this.workspace) {
+            let Some(name) = palette_name_for(&palette, item.kind, &item.literal) else {
+                continue;
+            };
+
+            if let Some(entry) = panels
+                .get_mut(id.as_str())
+                .and_then(|panel| panel.columns_config.get_mut(&item.column))
+            {
+                entry.insert(item.key, serde_json::Value::String(format_var_ref(&name)));
+                referenced.insert(name);
+            }
+        }
+
+        if !full_palette {
+            palette.retain(|name, _| referenced.contains(name));
+        }
+
         let active = this
             .presentation
             .is_settings_open()
@@ -240,6 +265,7 @@ impl PerspectiveViewerElement {
                 .iter()
                 .map(|id| id.as_str().to_owned())
                 .collect(),
+            palette,
         })?)
     }
 }
@@ -521,7 +547,7 @@ impl PerspectiveViewerElement {
                 renderer
                     .clone()
                     .render_task(|guard| async move {
-                        renderer.set_default_theme(presentation.get_default_theme_name().await);
+                        seed_panel_theme(&presentation, &renderer).await;
                         renderer.stamp_theme(None);
                         let jstable = JsFuture::from(promise)
                             .await
@@ -536,7 +562,7 @@ impl PerspectiveViewerElement {
                             };
 
                             if let Some(notify) = &notify {
-                                place_reserved(&workspace, notify);
+                                place_reserved(&workspace, notify, true);
                             }
 
                             let _plugin = renderer.ensure_plugin_selected()?;
@@ -594,7 +620,35 @@ impl PerspectiveViewerElement {
                             // commits already applied live (`commit_view_config`).
                             let owned_window = session.take_pending_load(generation).is_some();
                             let discard = if owned_window && notify.is_some() {
-                                workspace.take_reserved()
+                                match workspace.take_reserved() {
+                                    Some(panel) => Some((panel, None)),
+                                    // The one-shot claim read: a table-less
+                                    // `restore` claimed the reservation, and no
+                                    // table has bound nor is pending — evict the
+                                    // panel `CREATE_REQUIRES_TABLE` forbids.
+                                    None if workspace
+                                        .resolve_claim()
+                                        .is_some_and(|has_table| !has_table)
+                                        && session.get_table().is_none()
+                                        && session.pending_table().is_none() =>
+                                    {
+                                        let evicted = renderer
+                                            .slot_name()
+                                            .map(PanelId::from)
+                                            .and_then(|id| workspace.remove_panel(&id));
+
+                                        if evicted.is_some()
+                                            && let Some(notify) = &notify
+                                        {
+                                            notify.emit(());
+                                        }
+
+                                        evicted.map(|panel| {
+                                            (panel, Some(ApiError::new(CREATE_REQUIRES_TABLE)))
+                                        })
+                                    },
+                                    None => None,
+                                }
                             } else {
                                 None
                             };
@@ -613,13 +667,19 @@ impl PerspectiveViewerElement {
                 Err(e) => {
                     session.take_pending_load(generation);
                     if let Some(notify) = &notify {
-                        place_reserved(&workspace, notify);
+                        place_reserved(&workspace, notify, true);
                     }
 
                     session.set_error(false, e.clone()).await?;
                     Err(e)
                 },
-                Ok(Some(panel)) => eject_panel(panel).await,
+                Ok(Some((panel, error))) => {
+                    eject_panel(panel).await?;
+                    match error {
+                        Some(e) => Err(e),
+                        None => Ok(()),
+                    }
+                },
                 Ok(None) => Ok(()),
             }
         }))
@@ -931,18 +991,18 @@ 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). 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.
+    /// and the config restored into it (an upsert). Creation REQUIRES a
+    /// `table` — the same rule [`Self::addPanel`] enforces in its argument
+    /// type — and a would-create call without one REJECTS before any state
+    /// (including `settings`) is applied: with no panel to target and no
+    /// `table`, the patch has no data arrival path. In particular, on an
+    /// element with zero panels every `restore` must carry a `table`.
     ///
     /// On an empty element with a pending [`Self::load`] whose payload is not
     /// yet classified, the active-target form (no `panel`) instead claims and
     /// restores into that load's reserved first panel — see [`Self::load`].
     ///
-    /// This restores a SINGLE panel; a whole-element config (with a `panels`
+    /// This restores a SINGLE panel; a workspace config (with a `panels`
     /// map) must be applied via [`Self::restoreWorkspace`] — its `panels` /
     /// `layout` keys are ignored here.
     ///
@@ -990,10 +1050,6 @@ impl PerspectiveViewerElement {
             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 {
@@ -1006,43 +1062,59 @@ impl PerspectiveViewerElement {
             let _effect = effect;
             let id = name.map(PanelId::from);
             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);
-                }
+            enum Target {
+                Existing { panel: Panel, active: bool },
+                Claimed(Panel),
+                Create(Box<ViewerConfigInitial>),
+            }
+
+            let notify = this.layout_changed_notify();
+            let target = match this.workspace.panel_or_active(id.as_ref()) {
+                // An existing (or the active) panel — update it in place.
+                Some(panel) => {
+                    let active = this.workspace.active_id().as_ref() == Some(&panel.id);
+                    Target::Existing { panel, active }
+                },
+                None => {
+                    let has_table = matches!(&update.table, OptionalUpdate::Update(_));
+                    match id
+                        .is_none()
+                        .then(|| place_reserved(&this.workspace, &notify, has_table))
+                        .flatten()
+                    {
+                        Some(panel) => Target::Claimed(panel),
+                        None => Target::Create(Box::new(ViewerConfigInitial::try_from(
+                            std::mem::take(&mut update),
+                        )?)),
+                    }
+                },
+            };
 
-                let (sender, receiver) = channel::<()>();
+            if !matches!(settings, OptionalUpdate::Missing) {
+                // Through `ToggleSettingsInit` — the SAME full choreography
+                // the toolbar toggle drives (presize every visible plugin
+                // to its post-toggle box, then the exactness-finalizer
+                // resize) — NOT the bare `ToggleSettingsComplete` leaf,
+                // which only re-renders the pane. The pane is the outer
+                // `SplitPanel` (no `before-resize` event) and the host box
+                // is unchanged, so a leaf-only toggle left every canvas
+                // plugin CSS-stretched at its old backing size.
+                //
+                // No `set_settings_before_open` here: `is_settings_open` is
+                // Init's toggle-vs-no-op DISPATCH state, so pre-writing the
+                // target makes every call resolve as a no-op. Init owns the
+                // write, as it does for the toolbar and `toggleConfig`.
+                let (sender, receiver) = channel::<ApiResult<JsValue>>();
                 this.root.borrow().as_ref().into_apierror()?.send_message(
-                    PerspectiveViewerMsg::ToggleSettingsComplete(settings, sender),
+                    PerspectiveViewerMsg::ToggleSettingsInit(Some(settings), false, Some(sender)),
                 );
 
-                receiver.await.unwrap_or_log();
+                receiver.await.map_err(|_| ApiError::new("Cancelled"))??;
             }
 
-            match this.workspace.panel_or_active(id.as_ref()) {
-                // An existing (or the active) panel — update it in place.
-                Some(panel) => {
-                    let active = this.workspace.active_id().as_ref() == Some(&panel.id);
+            match target {
+                Target::Existing { panel, active } => {
                     restore_panel(
                         &panel.session,
                         &panel.renderer,
@@ -1054,61 +1126,30 @@ impl PerspectiveViewerElement {
                     )
                     .await
                 },
-                // No existing panel matched. The active-target form
-                // (`panel: None`) CLAIMS a pending `load()`'s reserved panel
-                // — placing it and restoring into it — so a `restore` fired
-                // right after an unawaited `load(promise)` configures the
-                // panel that load's payload will bind, per the call-site
-                // ordering contract in [`Self::load`]. Named upserts and
-                // reservation-less elements create a fresh panel instead,
-                // routing through the shared `create_panel`
-                // (`RestoreMode::Fresh`) pipeline so the new panel's id is
-                // the requested `panel`.
-                None => {
-                    let notify = this.layout_changed_notify();
-                    let claimed = id
-                        .is_none()
-                        .then(|| place_reserved(&this.workspace, &notify))
-                        .flatten();
-                    match claimed {
-                        Some(panel) => {
-                            restore_panel(
-                                &panel.session,
-                                &panel.renderer,
-                                &this.presentation,
-                                &this.workspace,
-                                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,
-                                &this.workspace,
-                                &notify,
-                                id,
-                                update,
-                                None,
-                            )
-                            .await?;
-                            Ok(())
-                        },
-                    }
+                Target::Claimed(panel) => {
+                    restore_panel(
+                        &panel.session,
+                        &panel.renderer,
+                        &this.presentation,
+                        &this.workspace,
+                        RestoreMode::Existing { active: true },
+                        update,
+                        errors,
+                    )
+                    .await
+                },
+                Target::Create(config) => {
+                    create_panel(
+                        &this.elem,
+                        &this.presentation,
+                        &this.workspace,
+                        &notify,
+                        id,
+                        *config,
+                        None,
+                    )
+                    .await?;
+                    Ok(())
                 },
             }
         });
@@ -1116,8 +1157,8 @@ impl PerspectiveViewerElement {
         js_sys::Promise::from(fut).unchecked_into()
     }
 
-    /// Restore the ENTIRE element from a whole-element
-    /// [`WorkspaceConfigUpdate`] (`{version, active?, layout, panels, ...}`) —
+    /// Restore the ENTIRE element from a [`WorkspaceConfigUpdate`]
+    /// (`{version, active?, layout, panels, ...}`) —
     /// the multi-panel counterpart of [`Self::restore`]. Every existing panel
     /// is replaced by the `panels` entries, and the layout tree + master/detail
     /// cross-filter state re-applied. Unlike [`Self::restore`], this never
@@ -1226,6 +1267,7 @@ impl PerspectiveViewerElement {
         let PanelOptions { panel: name } = parse_options(options);
         let this = self.clone();
         let fut = ApiFuture::new(async move {
+            this.workspace.effects().settle().await;
             let panel = this.resolve_panel(name)?;
             let viewer_config = panel
                 .renderer
@@ -1241,11 +1283,12 @@ impl PerspectiveViewerElement {
         js_sys::Promise::from(fut).unchecked_into()
     }
 
-    /// Save the ENTIRE element to a whole-element [`WorkspaceConfig`]
-    /// (`{version, active?, layout, panels, ...}`) — the multi-panel
-    /// counterpart of [`Self::save`]. Unlike [`Self::save`] (which emits a
-    /// single `ViewerConfig` for one panel), this ALWAYS emits the
-    /// whole-element format, restorable via [`Self::restoreWorkspace`].
+    /// Save the ENTIRE element to a [`WorkspaceConfig`]
+    /// (`{version, active?, layout, panels, palette?, ...}`) — the
+    /// multi-panel counterpart of [`Self::save`]. Unlike [`Self::save`]
+    /// (which emits a single `ViewerConfig` for one panel), this ALWAYS
+    /// emits the workspace format, restorable via
+    /// [`Self::restoreWorkspace`].
     ///
     /// # JavaScript Examples
     ///
@@ -1253,9 +1296,13 @@ impl PerspectiveViewerElement {
     /// const token = await viewer.saveWorkspace();
     /// await viewer.restoreWorkspace(token);
     /// ```
-    pub fn saveWorkspace(&self) -> JsWorkspaceConfigPromise {
+    pub fn saveWorkspace(
+        &self,
+        options: Option<JsSaveWorkspaceOptions>,
+    ) -> JsWorkspaceConfigPromise {
+        let SaveWorkspaceOptions { full_palette } = parse_options(options);
         let this = self.clone();
-        let fut = ApiFuture::new(Self::workspace_config(this));
+        let fut = ApiFuture::new(Self::workspace_config(this, full_palette.unwrap_or(false)));
         js_sys::Promise::from(fut).unchecked_into()
     }
 
@@ -1385,9 +1432,10 @@ impl PerspectiveViewerElement {
     /// Reset a panel's `ViewerConfig` to its data-relative default.
     ///
     /// Without a `panel`, this is ELEMENT-LEVEL: EVERY panel is reset and the
-    /// cross-filter overlay cleared (symmetric with whole-element
-    /// [`Self::save`] / [`Self::restore`]). With `{panel}`, only that panel is
-    /// reset — the other panels and the overlay are left untouched.
+    /// cross-filter overlay cleared (symmetric with
+    /// [`Self::saveWorkspace`] / [`Self::restoreWorkspace`]). With `{panel}`,
+    /// only that panel is reset — the other panels and the overlay are left
+    /// untouched.
     ///
     /// # Arguments
     ///
@@ -1638,17 +1686,15 @@ impl PerspectiveViewerElement {
     /// ```
     #[wasm_bindgen]
     pub fn restyleElement(&self) -> ApiFuture<JsValue> {
-        clone!(self.workspace, self.presentation);
+        clone!(self.workspace);
         let effect = workspace.effects().guard();
         ApiFuture::new(async move {
             let _effect = effect;
-            let default = presentation.get_default_theme_name().await;
             for panel in workspace
                 .panel_ids()
                 .into_iter()
                 .filter_map(|id| workspace.panel(&id))
             {
-                panel.renderer.set_default_theme(default.clone());
                 panel.renderer.restyle_all().await?;
             }
 
@@ -1656,6 +1702,21 @@ impl PerspectiveViewerElement {
         })
     }
 
+    #[wasm_bindgen]
+    pub fn getThemes(&self) -> ApiFuture<JsValue> {
+        clone!(self.presentation);
+        ApiFuture::new(async move {
+            let x = presentation
+                .get_available_themes()
+                .await?
+                .iter()
+                .cloned()
+                .collect::<Vec<_>>();
+
+            Ok(JsValue::from(x))
+        })
+    }
+
     /// Set the available theme names available in the status bar UI.
     ///
     /// Calling [`Self::resetThemes`] may cause the current theme to switch,
@@ -1676,46 +1737,41 @@ impl PerspectiveViewerElement {
         let effect = workspace.effects().guard();
         ApiFuture::new(async move {
             let _effect = effect;
-            let themes: Option<Vec<String>> = themes
-                .unwrap_or_default()
-                .iter()
-                .map(|x| x.as_string())
-                .collect();
+            // `None` (re-parse the document) must survive the conversion —
+            // mapping BEFORE defaulting is what keeps that branch reachable
+            // from JavaScript at all.
+            let themes: Option<Vec<String>> = match themes {
+                None => None,
+                Some(themes) => themes.iter().map(|x| x.as_string()).collect(),
+            };
 
-            let theme_name = presentation.get_selected_theme_name().await;
-            presentation.reset_available_themes(themes).await;
+            let previous = presentation.active_theme_name_sync();
+            let active = presentation.reset_themes(themes).await?;
             let available = presentation.get_available_themes().await?;
-            let reset_theme = available
-                .iter()
-                .find(|y| theme_name.as_ref() == Some(y))
-                .cloned();
-
-            presentation.set_theme_name(reset_theme.as_deref()).await?;
-            let new_default = presentation.get_default_theme_name().await;
             for panel in workspace
                 .panel_ids()
                 .into_iter()
                 .filter_map(|id| workspace.panel(&id))
             {
-                // Availability applies to PANELS too: a panel pinned to a
-                // theme outside the new set follows the host — clear the pin
-                // so it renders (and `save`s) the new registry default, the
-                // same keep-if-available-else-default rule applied to the
-                // host selection above.
-                if panel
-                    .renderer
-                    .theme()
-                    .is_some_and(|t| !available.contains(&t))
-                {
-                    panel.renderer.set_theme(None);
-                }
-
-                panel.renderer.set_default_theme(new_default.clone());
-                if panel.renderer.needs_restyle() {
-                    panel.renderer.restyle_all().await?;
+                let theme = panel.renderer.theme();
+
+                // A panel follows the host only when it was TRACKING it (it
+                // holds the host's previous theme, which is how every panel
+                // born without an explicit one starts — and what keeps the
+                // active panel and the host in agreement), or when its own
+                // theme has left the registry. A panel explicitly set to a
+                // different, still-available theme is untouched: re-ordering
+                // alone must repaint nothing.
+                let stale = theme.as_ref().is_none_or(|x| !available.contains(x));
+                if (stale || theme == previous) && theme != active {
+                    panel.renderer.set_theme(active.clone());
+                    if panel.renderer.needs_restyle() {
+                        panel.renderer.restyle_all().await?;
+                    }
                 }
             }
 
+            presentation.publish_theme_config().await?;
             Ok(JsValue::UNDEFINED)
         })
     }
@@ -1770,7 +1826,7 @@ impl PerspectiveViewerElement {
             let force = force.map(SettingsUpdate::Update);
             let (sender, receiver) = channel::<ApiResult<wasm_bindgen::JsValue>>();
             root.borrow().as_ref().into_apierror()?.send_message(
-                PerspectiveViewerMsg::ToggleSettingsInit(force, Some(sender)),
+                PerspectiveViewerMsg::ToggleSettingsInit(force, true, Some(sender)),
             );
 
             receiver.await.map_err(|_| JsValue::from("Cancelled"))?
@@ -1824,8 +1880,6 @@ impl PerspectiveViewerElement {
         let notify = self.layout_changed_notify();
         ApiFuture::new(async move {
             let _effect = effect;
-            // 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,
@@ -1833,7 +1887,7 @@ impl PerspectiveViewerElement {
                 &workspace,
                 &notify,
                 None,
-                config.into(),
+                config,
                 None,
             )
             .await?;
@@ -1931,7 +1985,12 @@ impl PerspectiveViewerElement {
             let _effect = effect;
             let panel = this.resolve_panel(name)?;
             let was_active = this.workspace.active_id().as_ref() == Some(&panel.id);
-            let locator = get_column_locator(&panel.session.metadata(), Some(column_name));
+            let target = {
+                let config = panel.session.get_view_config();
+                let metadata = panel.session.metadata();
+                classify_column(&column_name, &config, &metadata)
+                    .map(|_| crate::presentation::ColumnSettingsTarget::Column(column_name))
+            };
             if !was_active {
                 this.root.borrow().as_ref().into_apierror()?.send_message(
                     PerspectiveViewerMsg::SetActivePanel(panel.id.as_str().to_owned(), None),
@@ -1941,7 +2000,7 @@ impl PerspectiveViewerElement {
             let (sender, receiver) = channel::<()>();
             this.root.borrow().as_ref().into_apierror()?.send_message(
                 PerspectiveViewerMsg::OpenColumnSettings {
-                    locator,
+                    target,
                     sender: Some(sender),
                     toggle: was_active,
                 },

package/src/rust/custom_events.rs

@@ -150,6 +150,10 @@ fn dispatch_config_update(
     renderer: &Renderer,
     presentation: &Presentation,
 ) {
+    if session.get_table().is_none() && session.pending_table().is_none() {
+        return;
+    }
+
     clone!(session, renderer, presentation);
     let elem = elem.clone();
     let tracker = session.clone();
@@ -218,7 +222,16 @@ pub fn wire_element_events(
 
     let settings_sub = presentation.settings_open_changed.add_listener({
         clone!(elem, presentation, workspace);
-        move |open: bool| {
+        move |(open, announce): (bool, bool)| {
+            // A silent toggle (`restore`/`restoreWorkspace`) is announced
+            // by its own view-config commit dispatch — emitting here too
+            // would double-fire `perspective-config-update`, the first
+            // carrying the intermediate config (see
+            // `PresentationHandle::settings_open_changed`).
+            if !announce {
+                return;
+            }
+
             dispatch_event(&elem, "toggle-settings", open).unwrap();
             if let Some(panel) = workspace.active_panel() {
                 dispatch_config_update(&elem, &panel.session, &panel.renderer, &presentation);

package/src/rust/js/regular_layout.rs

@@ -235,9 +235,9 @@ impl Layout {
     }
 
     /// Rewrite every panel id through `f`, returning the remapped tree. Ids for
-    /// which `f` returns `None` are left unchanged. Used by whole-element
-    /// `restore`, which recreates panels under fresh (collision-free) ids and
-    /// must point the saved layout tree at them.
+    /// which `f` returns `None` are left unchanged. Used by `restoreWorkspace`,
+    /// which recreates panels under fresh (collision-free) ids and must point
+    /// the saved layout tree at them.
     pub fn remap(&self, f: &impl Fn(&str) -> Option<String>) -> Layout {
         match self {
             Layout::Split(split) => Layout::Split(SplitLayout {

package/src/rust/lib.rs

@@ -95,6 +95,7 @@ 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/SaveWorkspaceOptions.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";
@@ -109,6 +110,7 @@ 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 {SaveWorkspaceOptions} from "../../src/ts/ts-rs/SaveWorkspaceOptions.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";