@perspective-dev/viewer 5.1.0 → 5.3.0

package/src/rust/tasks/pipeline.rs

@@ -285,12 +285,12 @@ pub(crate) async fn locked_run(
 
             let view_config_snapshot = session.get_view_config().clone();
             let plugin_config_changed =
-                renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config);
+                renderer.update_plugin_config(&view_config_snapshot, spec.plugin_config)?;
             let columns_config_changed = renderer.update_columns_configs(
                 &view_config_snapshot,
                 &session,
                 spec.columns_config,
-            );
+            )?;
 
             let changed = plugin_config_changed || columns_config_changed;
             if changed || plugin_swapped {

package/src/rust/tasks/presize_panels.rs

@@ -131,11 +131,14 @@ pub async fn presize_visible_panels_grown(
     presize_visible_panels_scaled(workspace, elem, width_ratio, height_ratio).await
 }
 
-/// Pre-size each visible plugin to its SHRUNK post-open cell *before* the
-/// settings pane mounts (P2), using the open-state geometry deltas cached at
-/// the last close (`(layout_area.w − mpc.w, main_column.h − mpc.h)` — the pane
-/// and divider width and the docked status-bar height, both stable across a
-/// close/open cycle since the pane width persists in the override).
+/// Pre-size each visible plugin to its cell SHRUNK by `(delta_w, delta_h)` —
+/// GROWN when a delta is negative — *before* the layout change commits. Used
+/// by the settings-pane open (P2, deltas `(layout_area.w − mpc.w,
+/// main_column.h − mpc.h)` cached at the last close — the pane and divider
+/// width and the docked status-bar height, both stable across a close/open
+/// cycle since the pane width persists in the override) and by the
+/// column-settings pin toggle and docked-drawer mount/unmount (signed delta
+/// measured live at toggle time).
 pub async fn presize_visible_panels_open(
     workspace: &Workspace,
     elem: &web_sys::HtmlElement,
@@ -199,6 +202,7 @@ async fn presize_visible_panels_scaled(
         return StagedPresents::default();
     }
 
+    let mpc = shadow_rect(elem, "#main_panel_container");
     let mut last_chrome: Option<(f64, f64)> = None;
     let targets = workspace
         .panels()
@@ -222,6 +226,23 @@ async fn presize_visible_panels_scaled(
 
             last_chrome = chrome.or(last_chrome);
             let (cw, ch) = last_chrome.unwrap_or(super::CHROME_FALLBACK);
+
+            // Per axis, chrome can never exceed the container's
+            // non-plugin remainder: with no sibling panel on that axis,
+            // `mpc − box` IS the exact chrome, while the frame-margin
+            // measurement overcounts (margins that overlap container
+            // padding) — the source of a ~2px target miss that pushed
+            // every commit past the plugin transport's ±0.5px resize
+            // dedupe, costing an extra corrective render. With siblings
+            // the remainder is large and the measured chrome wins.
+            let (cw, ch) = match &mpc {
+                Some(mpc) => (
+                    cw.min((mpc.width() - plugin_box.width()).max(0.0)),
+                    ch.min((mpc.height() - plugin_box.height()).max(0.0)),
+                ),
+                None => (cw, ch),
+            };
+
             let w = ((plugin_box.width() + cw) * width_ratio - cw).max(0.0);
             let h = ((plugin_box.height() + ch) * height_ratio - ch).max(0.0);
             Some((panel, w, h))
@@ -300,6 +321,24 @@ pub fn measure_settings_open_deltas(elem: &web_sys::HtmlElement) -> Option<(f64,
     ))
 }
 
+/// The signed `#main_panel_container` width delta a column-settings pin
+/// toggle will cause: the docked `#modal_panel`'s flex box spans its drawer
+/// child plus the overlapping divider (`drawer.right − divider.left`, the
+/// same span in both modes since `.pinned` reparents nothing) — PINNING
+/// takes it from the main column (positive, shrink), UNPINNING releases it
+/// back (negative, grow). `None` when the drawer isn't mounted.
+pub fn measure_column_settings_pin_delta(
+    elem: &web_sys::HtmlElement,
+    is_pinned: bool,
+) -> Option<f64> {
+    let drawer = shadow_rect(elem, "#modal_panel > .split-panel-child:first-child")?;
+    let divider_left = shadow_rect(elem, "#modal_panel > .split-panel-divider")
+        .map(|r| r.left())
+        .unwrap_or_else(|| drawer.left());
+    let width = (drawer.right() - divider_left).max(0.0);
+    Some(if is_pinned { -width } else { width })
+}
+
 /// The frame chrome a plugin's grid cell has that the plugin itself doesn't
 /// occupy, as `(width, height)` px: margin + border + titlebar. Measured live
 /// from a `regular-layout-frame` and its plugin — robust to theme/CSS changes —

package/src/rust/tasks/reset_all.rs

@@ -61,11 +61,11 @@ pub fn reset_all(
 
         presentation.reset_available_themes(None).await;
         if all {
-            // Clear this panel's own per-panel theme so it reverts to inheriting
-            // the (reset-to-default) host theme — `reset_theme` only resets the
-            // host, which an explicitly-themed panel would otherwise override.
-            renderer.set_theme(None);
+            // Put this panel back on the registry default CONCRETELY —
+            // `reset_theme` only resets the host, which an explicitly-themed
+            // panel would otherwise keep overriding.
             presentation.reset_theme().await?;
+            renderer.set_theme(presentation.get_default_theme_name().await);
         }
 
         // For `all = true`, route the bucket clears through `restore_and_render`'s

package/src/rust/tasks/restore_and_render.rs

@@ -18,6 +18,7 @@ use futures::Future;
 use perspective_client::clone;
 
 use super::pipeline::{RunOrigin, RunSpec, locked_run};
+use super::update_theme::seed_panel_theme;
 use crate::config::{OptionalUpdate, ViewerConfigUpdate};
 use crate::presentation::Presentation;
 use crate::renderer::Renderer;
@@ -70,11 +71,6 @@ pub fn restore_and_render(
             session.set_title(None);
         }
 
-        // Mirror a config-carried theme onto the host attribute (the shared
-        // chrome). The restyle a theme change requires is owned by the
-        // MUTATION SITES (`restorePanel`'s own-theme tail, the theme-picker
-        // task), not here — this run's own draw below already stamps the new
-        // effective theme before the plugin's first style read.
         match theme_name {
             OptionalUpdate::SetDefault => {
                 let current_name = presentation.get_selected_theme_name().await;
@@ -83,59 +79,31 @@ pub fn restore_and_render(
                 }
             },
             OptionalUpdate::Update(x) => {
-                // No pre-resolution gate: `set_theme_name` stamps the host
-                // attribute SYNCHRONOUSLY before its registry await and
-                // no-ops on literal equality itself. The old
-                // `get_selected_theme_name().await` guard was precisely
-                // the former-theme window on a cold registry — the host
-                // held the old attribute until stylesheet parsing (and
-                // everything queued behind it) resolved.
                 presentation.set_theme_name(Some(&x)).await?;
             },
             _ => {},
         };
 
-        // Resolve the target plugin here (pure — needed now for
-        // `set_update_column_defaults`), but COMMIT it only inside the locked
-        // run below, atomically with the view rebind it belongs to. No swap
-        // intent may exist outside that run: an unrelated run that wins the
-        // lock first (e.g. a `table_updated` redraw) must observe either the
-        // fully-old or fully-new world, never a staged half of this one.
         let resolved_plugin = renderer.resolve_plugin_update(&plugin);
         if let Some((_, metadata)) = &resolved_plugin {
             session.set_update_column_defaults(&mut view_config, metadata);
         } else {
-            // Same-plugin (or plugin-less) restore: `resolve_plugin_update`
-            // returns `None`, but the plugin-advised `group_rollup_mode`
-            // must STILL be enforced against the active plugin's metadata —
-            // `restorePanel`'s table-change reset wipes the committed mode,
-            // and nothing else on this path would restore it, leaving a
-            // flat-only chart (Treemap / Sunburst) rendering rollup
-            // subtotal rows. Rollup only; the full column-defaults pass is
-            // reserved for plugin swaps, where `columns` genuinely needs
-            // re-defaulting.
-            session.set_update_rollup_defaults(&mut view_config, &renderer.metadata());
+            let metadata = if renderer.active_plugin().is_none() {
+                renderer
+                    .resolve_plugin_update(&OptionalUpdate::SetDefault)
+                    .map(|(_, metadata)| metadata)
+                    .unwrap_or_else(|| renderer.metadata())
+            } else {
+                renderer.metadata()
+            };
+
+            session.set_update_rollup_defaults(&mut view_config, &metadata);
         }
 
         let plugin_idx = resolved_plugin.map(|(idx, _)| idx);
-
-        // The config COMMIT: synchronous, validated, atomic (I1/I4). Under
-        // I2/I3 committing before the lock is safe — whichever queued run
-        // snapshots next picks it up, and this run's own snapshot (taken
-        // inside the lock below) can only be this commit or fresher.
         session.commit_view_config(view_config)?;
-
-        // Spinner accounting (RAII): held to the end of this restore —
-        // INCLUDING the deferred-draw exit (no table yet → no
-        // `bind_snapshot`), which under the old edge-counted scheme
-        // stranded the `StatusIndicator` spinner permanently.
         let _run_token = session.begin_config_run();
-
-        // Awaits theme-registry init, so the stamp below can never observe a
-        // pre-init (empty) theme set on a cold first load. Seeds this
-        // panel's renderer default-theme cache, which every locked draw
-        // stamps the effective theme from.
-        renderer.set_default_theme(presentation.get_default_theme_name().await);
+        seed_panel_theme(&presentation, &renderer).await;
         locked_run(&session, &renderer, RunSpec {
             origin,
             plugin_idx,
@@ -146,6 +114,11 @@ pub fn restore_and_render(
         })
         .await?;
 
+        if renderer.needs_restyle() {
+            renderer.restyle_all().await?;
+        }
+
+        presentation.publish_theme_config().await?;
         Ok(())
     })
 }

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,16 @@ pub(crate) enum RestoreMode {
     Fresh,
 }
 
+/// Where a failed restore's error goes.
+#[derive(Clone, Copy)]
+pub(crate) enum RestoreErrors {
+    // Raise errors in the UI.
+    Publish,
+
+    // Report only in the API.
+    Suppress,
+}
+
 pub(crate) async fn bind_table_task(
     session: &Session,
     workspace: &Workspace,
@@ -50,22 +57,26 @@ pub(crate) async fn bind_table_task(
 }
 
 /// Apply a [`ViewerConfigUpdate`] to a single panel and re-draw — the one
-/// pipeline shared by `restorePanel` (an existing panel), whole-element
-/// `restoreWorkspace`, and `addPanel` (both fresh panels).
+/// pipeline shared by `restorePanel` (an existing panel), `restoreWorkspace`,
+/// and `addPanel` (both fresh panels).
 pub(crate) async fn restore_panel(
     session: &Session,
     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);
     match &update.theme {
         OptionalUpdate::Update(theme) => renderer.set_theme_stamped(Some(theme.clone())),
-        OptionalUpdate::SetDefault => renderer.set_theme_stamped(None),
+        // `SetDefault` resolves to a CONCRETE registry default here, rather
+        // than clearing the panel's theme — nothing downstream re-resolves.
+        OptionalUpdate::SetDefault => {
+            renderer.set_theme_stamped(presentation.get_default_theme_name().await)
+        },
         OptionalUpdate::Missing => {},
     }
 
@@ -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,15 +140,20 @@ 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?;
 
     if fresh {
         renderer.resize().await.unwrap_or_log();
-    } else if renderer.needs_restyle() {
-        renderer.restyle_all().await?;
     }
 
     Ok(())

package/src/rust/tasks/set_edit_mode.rs

@@ -34,7 +34,9 @@ pub fn set_edit_mode(session: &Session, renderer: &Renderer, mode: &str) {
         serde_json::Value::String(mode.to_owned()),
     );
 
-    let changed = renderer.update_plugin_config(&view_config, OptionalUpdate::Update(map));
+    let changed = renderer
+        .update_plugin_config(&view_config, OptionalUpdate::Update(map))
+        .unwrap_or_default();
     clone!(session, renderer);
     ApiFuture::spawn(async move {
         if changed {

package/src/rust/tasks/sync_update_panels.rs

@@ -46,8 +46,11 @@ pub fn sync_update_panels(
         panels,
         global_filters,
         masters,
+        palette,
     } = update.into_serde_ext()?;
 
+    let palette = validate_palette(palette.unwrap_or_default())
+        .map_err(|e| ApiError::from(JsValue::from_str(&e)))?;
     let old_ids = this.workspace.panel_ids();
 
     // Phase 1 — models only, NO renders and NO draws
@@ -55,20 +58,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 +84,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));
@@ -108,6 +95,8 @@ pub fn sync_update_panels(
         }
     }
 
+    this.presentation.set_palette(palette)?;
+
     // Phase 2 — stage the remapped layout tree on the Workspace
     if let Some(layout) = layout {
         this.workspace
@@ -129,13 +118,17 @@ pub fn sync_update_panels(
     }
 
     if let Some(app) = this.root.borrow().as_ref() {
+        // Silent (`announce: false`): each restored panel's own view-config
+        // commit dispatch announces the config, settings field included.
         app.send_message(PerspectiveViewerMsg::ToggleSettingsInit(
             Some(SettingsUpdate::Update(sidebar_open)),
+            false,
             None,
         ));
     }
 
     let masters = masters
+        .unwrap_or_default()
         .into_iter()
         .filter_map(|saved| match id_map.get(&saved) {
             Some(fresh) => Some(PanelId::from(fresh.as_str())),
@@ -147,6 +140,7 @@ pub fn sync_update_panels(
         .collect::<Vec<_>>();
 
     this.workspace.set_masters(masters);
-    this.workspace.set_global_filters(global_filters);
+    this.workspace
+        .set_global_filters(global_filters.unwrap_or_default());
     Ok((contents, eject_tasks))
 }

package/src/rust/tasks/update_theme.rs

@@ -19,20 +19,21 @@ use crate::presentation::Presentation;
 use crate::renderer::Renderer;
 use crate::workspace::Workspace;
 
-/// Re-seed every panel renderer's cached registry default theme from the
-/// (awaited, so initialized) theme registry, returning the default name.
-/// Every consumer of `Renderer::needs_restyle` after a registry-affecting
-/// change must run this first — a cold cache compares against `None`.
-pub(crate) async fn seed_default_themes(
-    presentation: &Presentation,
-    workspace: &Workspace,
-) -> Option<String> {
-    let default = presentation.get_default_theme_name().await;
-    for panel in workspace.panels() {
-        panel.renderer.set_default_theme(default.clone());
+/// Give `renderer` the concrete registry default IF it has none yet — the
+/// cold-boot case, where the panel was created before the registry first
+/// parsed and `active_theme_name_sync` had nothing to resolve. Only ever
+/// FILLS IN, never overwrites, so it cannot repaint a themed panel.
+pub(crate) async fn seed_panel_theme(presentation: &Presentation, renderer: &Renderer) {
+    if renderer.theme().is_none() {
+        renderer.set_theme(presentation.get_default_theme_name().await);
     }
+}
 
-    default
+/// [`seed_panel_theme`] for every panel.
+pub(crate) async fn seed_default_themes(presentation: &Presentation, workspace: &Workspace) {
+    for panel in workspace.panels() {
+        seed_panel_theme(presentation, &panel.renderer).await;
+    }
 }
 
 /// Apply a theme change and restyle the affected panel's view.
@@ -59,14 +60,17 @@ pub fn update_theme(
     workspace: &Workspace,
     theme: Option<String>,
 ) {
-    // Per-panel: record the theme on the (active) renderer so this panel keeps
-    // it independent of which panel is active. `set_theme_name` below mirrors
-    // the same value onto the host `theme` attribute (driving the chrome), and
-    // MainPanel inlines this renderer's theme on its frame only when it
-    renderer.set_theme_stamped(theme.clone());
+    // A NAMED theme needs no registry, so it stamps SYNCHRONOUSLY — no await
+    // separates the caller's config commit from the attribute the document
+    // cascade styles. Only "reset to default" has to await the registry, and
+    // it records the resolved NAME, never an empty theme.
+    if let Some(name) = &theme {
+        renderer.set_theme_stamped(Some(name.clone()));
+    }
 
     let presentation = presentation.clone();
     let workspace = workspace.clone();
+    let renderer = renderer.clone();
     ApiFuture::spawn(async move {
         match theme {
             Some(name) => {
@@ -74,10 +78,10 @@ pub fn update_theme(
             },
             None => {
                 presentation.reset_theme().await?;
+                renderer.set_theme_stamped(presentation.get_default_theme_name().await);
             },
         }
 
-        seed_default_themes(&presentation, &workspace).await;
         let panels = workspace.panels();
         join_all(panels.iter().map(|panel| async move {
             if panel.renderer.needs_restyle() {
@@ -90,6 +94,7 @@ pub fn update_theme(
         .into_iter()
         .collect::<ApiResult<Vec<_>>>()?;
 
+        presentation.publish_theme_config().await?;
         Ok(())
     });
 }

package/src/rust/utils/css_vars.rs

@@ -0,0 +1,26 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use web_sys::Element;
+
+/// The computed value of custom property `name` on `elem`, trimmed, or
+/// `None` when undefined/empty.
+pub fn read_custom_property(elem: &Element, name: &str) -> Option<String> {
+    let value = web_sys::window()?
+        .get_computed_style(elem)
+        .ok()??
+        .get_property_value(name)
+        .ok()?;
+
+    let value = value.trim();
+    (!value.is_empty()).then(|| value.to_owned())
+}

package/src/rust/utils/mod.rs

@@ -18,6 +18,7 @@
 
 mod browser;
 mod completion;
+mod css_vars;
 mod custom_element;
 mod datetime;
 mod debounce;
@@ -35,6 +36,7 @@ mod tests;
 
 pub use browser::*;
 pub use completion::*;
+pub use css_vars::*;
 pub use custom_element::*;
 pub use datetime::*;
 pub use debounce::*;

package/src/rust/utils/spawn.rs

@@ -23,7 +23,7 @@ use perspective_js::utils::*;
 /// (invariant I6); use this only at event-listener leaves where no caller
 /// exists.
 pub fn spawn_owned(tag: &'static str, fut: impl Future<Output = ApiResult<()>> + 'static) {
-    ApiFuture::spawn(async move {
+    ApiFuture::spawn_named(tag, async move {
         if let Err(e) = fut.await.ignore_view_delete() {
             tracing::error!("[{}] unhandled task error: {}", tag, e);
         }