@perspective-dev/viewer 5.3.1 → 5.4.0

package/src/rust/config/mod.rs

@@ -15,7 +15,6 @@
 
 mod column_config_schema;
 mod columns_config;
-mod css_scale;
 mod datetime_column_style;
 mod export_method;
 mod kvpair;
@@ -30,7 +29,6 @@ mod workspace_config;
 
 pub use column_config_schema::*;
 pub use columns_config::*;
-pub use css_scale::*;
 pub use datetime_column_style::*;
 pub use export_method::*;
 pub use number_series_style::*;

package/src/rust/config/workspace_config.rs

@@ -14,7 +14,8 @@ use std::collections::BTreeMap;
 
 use perspective_client::config::Filter;
 
-use crate::config::{CssKind, PanelViewerConfig, ViewerConfigInitial};
+use crate::config::{PanelViewerConfig, ViewerConfigInitial};
+use crate::utils::CssKind;
 
 /// The workspace config format (`{version, active?, layout, panels}`) —
 /// the multi-panel counterpart of the single-panel [`ViewerConfig`] — as

package/src/rust/custom_elements/debug_plugin.rs

@@ -66,16 +66,7 @@ impl PerspectiveDebugPluginElement {
     }
 
     /// Delegates to `draw()` VIRTUALLY — through the JS element's `draw`
-    /// property, never `self.draw(view)` (Rust static dispatch). This
-    /// element is the documented base class for custom plugins
-    /// (`class MyPlugin extends
-    /// customElements.get("perspective-viewer-plugin")`), whose contract is
-    /// "`update()` defaults to dispatch to `draw()`" — a
-    /// subclass overriding only `draw` must receive `update`-path repaints
-    /// (`BindDisposition::Unchanged`/`Adopted` runs,
-    /// `PLUGIN_DRAW_INVARIANT_PLAN.md`); the static call bypassed the
-    /// override and repainted the Debug CSV instead (the
-    /// `view_lifecycle.spec` regression).
+    /// property, never `self.draw(view)` (Rust static dispatch).
     pub fn update(&self, view: &perspective_js::View) -> ApiFuture<()> {
         clone!(self.elem, view);
         ApiFuture::new(async move {

package/src/rust/custom_elements/mod.rs

@@ -13,8 +13,5 @@
 //! Each file in `custom_elements` exports a single struct which will be the
 //! public [`wasm_bindgen`] API to a JavaScript Custom Element.
 
-pub mod copy_dropdown;
 pub mod debug_plugin;
-pub mod export_dropdown;
-pub mod modal;
 pub mod viewer;

package/src/rust/custom_elements/viewer.rs

@@ -512,31 +512,13 @@ impl PerspectiveViewerElement {
                         .expect("just-reserved panel is present")
                 });
 
-                // Carrying `Some(notify)` marks this load as the reservation's
-                // owner — the only call that may place or discard it below.
                 (panel, Some(self.layout_changed_notify()))
             },
         };
 
-        // A `Table` payload targets this panel's engines; a `Client` registers
-        // inertly against it. Selecting the panel here (not at construction)
-        // keeps the registry race safe — by `load()` time real plugins have
-        // registered.
         let session = panel.session;
         let renderer = panel.renderer;
-
-        // Open the pending-load window SYNCHRONOUSLY, at the call site — this
-        // is what fixes the ordering. The payload's RESET disposition (a
-        // `Table` resets the view; a `Client` does not) is unknown until the
-        // promise resolves, but the window's POSITION on the config-commit
-        // stream is fixed NOW. A `restore()` a caller fires immediately after
-        // this unawaited `load()` (the React prop-binding pattern, which has
-        // no async ordering guarantees) commits INTO this window's journal and
-        // is replayed over the reset base if the payload proves to be a
-        // `Table` — so a moved-async reset can no longer clobber a later
-        // commit. See `SESSION_CONFIG_COHERENCE_PLAN.md`.
         let generation = session.begin_pending_load();
-
         clone!(self.workspace, self.presentation);
         Ok(ApiFuture::new_throttled(async move {
             let _effect = effect;

package/src/rust/js/plugin.rs

@@ -30,92 +30,6 @@ extern "C" {
     pub type JsPerspectiveViewer;
 
     /// A `<perspective-viewer>` plugin custom element.
-    ///
-    /// # Capability tiers
-    ///
-    /// Only `get_static_config`, `draw`, `save`/`restore` and `delete` are
-    /// REQUIRED. Every other method is optional — detected once per element
-    /// tag ([`PluginCapabilities`], methods live on the class prototype) —
-    /// with a defined host fallback, so a minimal plugin renders correctly
-    /// and each added method buys performance or polish, never correctness:
-    ///
-    /// | method     | host fallback when absent                              |
-    /// |------------|--------------------------------------------------------|
-    /// | `update`   | `draw` — every repaint is a full render (such plugins  |
-    /// |            | must NOT treat `draw` as a state-reset license)        |
-    /// | `resize`   | no-op — CSS reflows the box; next dispatch repaints    |
-    /// | `restyle`  | no-op — the plugin re-reads CSS at its next render     |
-    /// | `clear`    | no-op                                                  |
-    /// | `deselect` | no-op                                                  |
-    /// | `presize`  | held style-override presize (`Renderer` resize paths)  |
-    /// | `render`   | image export reports unsupported                       |
-    ///
-    /// # Call discipline
-    ///
-    /// Plugin implementations assume the host NEVER overlaps calls on the
-    /// same element: each of the rendering methods (`draw`, `update`,
-    /// `render`, `clear`, `resize`) and `delete` must run to completion
-    /// before the next begins. Every call site must therefore hold that
-    /// plugin's per-`Renderer` draw lock, witnessed by
-    /// [`crate::utils::RenderGuard`] — the guard-taking dispatch helpers
-    /// (`Renderer::draw_fresh`/`update_bound`,
-    /// `renderer::activate::activate_plugin`) and the already-locked
-    /// `render_task`/`update_lazy`/`resize`/`restyle_all`/`dispose`
-    /// entrypoints do not compile from an unlocked context. Synchronous
-    /// calls (`restore`, `restyle`, the schema queries) are exempt, though
-    /// `restyle` should ride inside a locked restyle-then-update sequence
-    /// (see `Renderer::restyle_all`).
-    ///
-    /// # Dispatch semantics (`PLUGIN_DRAW_INVARIANT_PLAN.md`, amended
-    /// 2026-07-16)
-    ///
-    /// The host invokes `draw` **iff there is a NEW `View` for this
-    /// plugin** — `bind_view` REBUILT the engine `View`, or a
-    /// freshly-selected plugin element owes its first paint of the bound
-    /// one — so implementations may treat `draw` as "new data shape"
-    /// (reset zoom/scroll/domain state). The witness enforcing this is
-    /// [`crate::session::FreshView`], which only the rebuild and
-    /// first-paint paths mint.
-    ///
-    /// `update` is a repaint of the SAME `View`, invoked iff a
-    /// plugin-visible SOURCE changed — one of exactly six: (1) data
-    /// (`View::on_update`), (2) an adopted placeholder-config delta,
-    /// (3) a genuinely CHANGED `plugin_config`/`columns_config` the host
-    /// just delivered via `restore` (so `update`-after-`restore` is the
-    /// sanctioned delivery pairing), (4) genuinely changed CSS vars just
-    /// applied via `restyle` (`Renderer::restyle_all`, or the fused
-    /// stale-capture restyle immediately preceding a dispatch inside
-    /// `draw_view` — gated by `Renderer::needs_restyle`), (5) a
-    /// render-limits change (warning dismissed), (6) an explicit PUBLIC
-    /// element-API call that reconciled as a no-op
-    /// ([`crate::tasks::RunOrigin::Public`] — the documented
-    /// `viewer.restore({})` refresh affordance). An INTERNAL run that
-    /// changed none of these dispatches nothing.
-    ///
-    /// `resize` is geometry/chrome only, from retained state (and is also
-    /// the activation-chrome nudge — implementations should no-op it
-    /// while hidden).
-    ///
-    /// `restore`/`save` are state transfer, NOT rendering: plugins must
-    /// not render internally from them, and must not call host APIs from
-    /// inside `restore` (a `restore`-triggered `restorePanel` echo is how
-    /// the initial-load double render happened — user gestures may echo,
-    /// host-delivered restores must not). (The built-in `Debug` plugin's
-    /// own `resize()` delegating to its `draw()` is plugin-INTERNAL and
-    /// exempt.)
-    ///
-    /// # Render-callable contract (invariant I5,
-    /// `SESSION_CONFIG_COHERENCE_PLAN.md`)
-    ///
-    /// From inside `draw`/`update`/`render`/`resize`, a plugin may call
-    /// back into its host `<perspective-viewer>` ONLY the per-panel
-    /// snapshot getters — `getViewConfigPanel`, `getTablePanel`,
-    /// `getClientPanel`, `getEditPortPanel` — which answer from the run's
-    /// pinned `RenderContext`, so plugin-visible state always equals the
-    /// snapshot being drawn, never a fresher in-flight commit.
-    /// Lock-acquiring host methods (`savePanel`, `restorePanel`, `flush`,
-    /// `download`/`export`/`copy`, …) DEADLOCK on the non-reentrant draw
-    /// lock if called from a render and are forbidden.
     #[derive(Clone)]
     pub type JsPerspectiveViewerPlugin;
 

package/src/rust/lib.rs

@@ -26,9 +26,6 @@
     clippy::fallible_impl_from,
     clippy::unneeded_field_pattern
 )]
-// Holding a `Ref` across an `await` is the sibling footgun of the config
-// write-back race this crate was rearchitected against (see
-// `SESSION_CONFIG_COHERENCE_PLAN.md`) — deny, don't warn.
 #![deny(clippy::await_holding_refcell_ref)]
 
 #[cfg(feature = "llm-agent")]
@@ -49,6 +46,7 @@ mod session;
 
 #[doc(hidden)]
 pub mod tasks;
+pub mod ui;
 pub mod utils;
 mod workspace;
 
@@ -61,9 +59,7 @@ use std::cell::RefCell;
 use perspective_js::utils::*;
 use wasm_bindgen::prelude::*;
 
-use crate::custom_elements::copy_dropdown::CopyDropDownMenuElement;
 use crate::custom_elements::debug_plugin::PerspectiveDebugPluginElement;
-use crate::custom_elements::export_dropdown::ExportDropDownMenuElement;
 use crate::custom_elements::viewer::PerspectiveViewerElement;
 use crate::utils::define_web_component;
 
@@ -71,19 +67,21 @@ use crate::utils::define_web_component;
 const TS_APPEND_CONTENT: &'static str = r#"
 import type {
     ColumnType,
-    TableInitOptions,
     ColumnWindow,
-    ViewWindow,
-    TypedArrayWindow,
-    OnUpdateOptions,
+    DeleteOptions,
+    Features,
     JoinOptions,
+    OnRemoveData,
+    OnUpdateData,
+    OnUpdateOptions,
+    Scalar,
+    SystemInfo,
+    TableInitOptions,
+    TypedArrayWindow,
     UpdateOptions,
-    DeleteOptions,
     ViewConfig,
     ViewConfigUpdate,
-    SystemInfo,
-    Scalar,
-    Features,
+    ViewWindow,
 } from "@perspective-dev/client";
 
 export type * from "../../src/ts/ts-rs/ViewerConfig.d.ts";
@@ -107,6 +105,7 @@ 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";
@@ -177,8 +176,6 @@ pub fn js_get_worker_url() -> Result<web_sys::Url, JsValue> {
 pub fn bootstrap_web_components(psp: &JsValue) {
     define_web_component::<PerspectiveViewerElement>(psp);
     define_web_component::<PerspectiveDebugPluginElement>(psp);
-    define_web_component::<CopyDropDownMenuElement>(psp);
-    define_web_component::<ExportDropDownMenuElement>(psp);
 }
 
 /// Defining the web components needs an extern struct to reference the

package/src/rust/presentation/column_locator.rs

@@ -12,6 +12,8 @@
 
 use std::fmt::Display;
 
+use crate::ui::TabItem;
+
 /// Locates a view column.
 /// Table columns are those defined on the table, but their types will reflect
 /// the view type, not the table type.
@@ -110,10 +112,4 @@ impl OpenColumnSettings {
     }
 }
 
-pub trait ColumnTab: PartialEq + Display + Clone + Default + 'static {}
-
-impl ColumnTab for String {}
-
-impl ColumnTab for &'static str {}
-
-impl ColumnTab for ColumnSettingsTab {}
+impl TabItem for ColumnSettingsTab {}

package/src/rust/presentation.rs

@@ -11,7 +11,6 @@
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
 mod column_locator;
-pub mod drag_helpers;
 mod props;
 mod sheets;
 
@@ -28,13 +27,14 @@ use yew::html::ImplicitClone;
 use yew::prelude::*;
 
 pub use self::column_locator::{
-    ColumnLocator, ColumnSettingsTab, ColumnSettingsTarget, ColumnTab, OpenColumnSettings,
+    ColumnLocator, ColumnSettingsTab, ColumnSettingsTarget, OpenColumnSettings,
 };
-use self::drag_helpers::DragTargetState;
-pub use self::drag_helpers::{DragDropContainer, DragEndCallback};
 pub use self::props::{DragDropProps, PresentationProps};
-use crate::config::{CssKind, NamedValue, assign_palette_names};
-use crate::utils::*;
+pub use crate::ui::{DragDropContainer, DragEndCallback};
+use crate::ui::{
+    DragTargetState, PointerDownCallback, clear_document_selection, closest_draggable,
+};
+use crate::utils::{CssKind, NamedValue, assign_palette_names, *};
 
 #[derive(Clone, Debug)]
 struct DragFrom {
@@ -73,14 +73,7 @@ pub struct PresentationHandle {
     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
-    /// is expensive and must wait for `document.styleSheets`). Sync-readable
-    /// (a `RefCell`, never borrowed across an await) so synchronous paths
-    /// ("stamp with commit" — panel creation, theme mutation sites) can
-    /// derive the registry default without awaiting registry init; derived
-    /// values (e.g. the default theme = first registered) are computed from
-    /// it on demand, never mirrored.
+    /// explicitly when CORS prevents detection.
     themes: RefCell<Option<Vec<String>>>,
 
     /// Single-flight guard for the stylesheet parse that populates
@@ -91,12 +84,6 @@ pub struct PresentationHandle {
 
     /// Whether the host's theme was ever EXPLICITLY chosen — authored as a
     /// `theme` attribute, or set by name through [`Self::set_theme_name`].
-    ///
-    /// `false` means the host merely displays the registry default, which
-    /// [`Self::reset_themes`] is free to move; `true` pins the selection
-    /// until it leaves the registry. The `theme` attribute alone cannot
-    /// carry this, because `init` stamps it unconditionally so the document
-    /// cascade has a theme to match.
     theme_selected: Cell<bool>,
 
     palette: RefCell<BTreeMap<String, String>>,
@@ -126,32 +113,22 @@ pub struct PresentationHandle {
     /// dragged element from the shadow tree.
     host_dragend: RefCell<Option<DragEndCallback>>,
 
+    /// Host-level `pointerdown` listener that clears a stale page selection
+    /// before it can turn a row drag into a browser selection drag.
+    host_pointerdown: RefCell<Option<PointerDownCallback>>,
+
     source_dragend: RefCell<Option<(web_sys::EventTarget, DragEndCallback)>>,
 
     /// IntersectionObserver-based fallback for the drag image, kept alive for
     /// the duration of the drag.
     drag_target: RefCell<Option<DragTargetState>>,
 
-    /// `(open, announce)` — `announce` says this toggle is the SOLE carrier
-    /// of the config change (a user gesture: toolbar, `toggleConfig`), so
-    /// the element must emit `toggle-settings` + a config-update for it. An
-    /// API restore's toggle is announced by its own view-config commit
-    /// dispatch instead — announcing here too would double-emit, the first
-    /// carrying the intermediate config (settings flipped, view fields not
-    /// yet committed).
     pub settings_open_changed: PubSub<(bool, bool)>,
-
-    /// Injected callback from the root component, replacing the former
-    /// `is_workspace_changed: PubSub` field.
     pub on_is_workspace_changed: RefCell<Option<Callback<bool>>>,
     pub settings_before_open_changed: PubSub<bool>,
     pub column_settings_open_changed: PubSub<(bool, Option<String>)>,
     pub theme_config_updated: PubSub<(PtrEqRc<Vec<String>>, Option<usize>)>,
     pub on_eject: PubSub<()>,
-
-    /// Fires for status-bar / main-panel pointer events that target the
-    /// statusbar element. `wire_element_events` formats the `PointerEvent`'s
-    /// `type_()` into a `perspective-statusbar-{type}` `CustomEvent` name.
     pub statusbar_pointer_event: PubSub<PointerEvent>,
 }
 
@@ -202,10 +179,12 @@ impl Presentation {
             on_dragstart: Default::default(),
             on_dragend: Default::default(),
             host_dragend: Default::default(),
+            host_pointerdown: Default::default(),
             source_dragend: Default::default(),
             drag_target: Default::default(),
         }));
 
+        theme.register_host_pointerdown();
         ApiFuture::spawn(theme.clone().init());
         theme
     }
@@ -577,18 +556,53 @@ impl Presentation {
         }
     }
 
-    pub fn set_drag_image(&self, event: &DragEvent) -> ApiResult<()> {
+    /// Claim a `dragstart` for the column drag machinery, returning `false`
+    /// (cancelling the native drag) when it did not originate on a
+    /// `draggable="true"` row or installation failed.
+    pub fn set_drag_image(&self, event: &DragEvent) -> bool {
+        match self.try_set_drag_image(event) {
+            Ok(true) => true,
+            Ok(false) => {
+                event.prevent_default();
+                if let Err(e) = clear_document_selection() {
+                    web_sys::console::warn_1(&e.into());
+                }
+
+                false
+            },
+            Err(e) => {
+                event.prevent_default();
+                web_sys::console::warn_1(&e.into());
+                false
+            },
+        }
+    }
+
+    fn try_set_drag_image(&self, event: &DragEvent) -> ApiResult<bool> {
         event.stop_propagation();
+        let Some(original) = closest_draggable(event) else {
+            return Ok(false);
+        };
+
+        let is_row_drag = event
+            .target()
+            .and_then(|target| target.dyn_into::<Node>().ok())
+            .map(|target| original.is_same_node(Some(&target)))
+            .unwrap_or(false);
+
+        if !is_row_drag {
+            return Ok(false);
+        }
+
         self.register_source_dragend(event)?;
         if let Some(dt) = event.data_transfer() {
             dt.set_drop_effect("move");
         }
 
-        let original: HtmlElement = event.target().into_apierror()?.unchecked_into();
         let elem: HtmlElement = original
             .children()
             .get_with_index(0)
-            .unwrap()
+            .into_apierror()?
             .clone_node_with_deep(true)?
             .unchecked_into();
 
@@ -612,7 +626,7 @@ impl Presentation {
             Ok(())
         });
 
-        Ok(())
+        Ok(true)
     }
 
     /// Is the drag/drop state currently in `action`?
@@ -695,6 +709,22 @@ impl Presentation {
         Ok(())
     }
 
+    fn register_host_pointerdown(&self) {
+        let closure = Closure::wrap(Box::new(move |event: PointerEvent| {
+            if closest_draggable(&event).is_some()
+                && let Err(e) = clear_document_selection()
+            {
+                web_sys::console::warn_1(&e.into());
+            }
+        }) as Box<dyn FnMut(PointerEvent)>);
+
+        self.viewer_elem
+            .add_event_listener_with_callback("pointerdown", closure.as_ref().unchecked_ref())
+            .unwrap();
+
+        *self.host_pointerdown.borrow_mut() = Some(closure);
+    }
+
     fn register_host_dragend(&self) {
         if let Some(prev) = self.host_dragend.borrow_mut().take() {
             let _ = self

package/src/rust/queries/hosted_tables.rs

@@ -0,0 +1,38 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 crate::workspace::Workspace;
+
+/// Every hosted `Table` name per loaded `Client`, as `(client name, sorted
+/// table names)` in registration order.
+pub async fn fetch_hosted_tables(workspace: &Workspace) -> Vec<(String, Vec<String>)> {
+    let clients = workspace.clients();
+    let mut tables = Vec::with_capacity(clients.len());
+    for client in clients {
+        let mut names = match client.get_hosted_table_names().await {
+            Ok(names) => names,
+            Err(err) => {
+                tracing::warn!(
+                    "Failed to list tables for `Client` \"{}\": {err}",
+                    client.get_name()
+                );
+
+                vec![]
+            },
+        };
+
+        names.sort_unstable();
+        tables.push((client.get_name().to_owned(), names));
+    }
+
+    tables
+}

package/src/rust/queries/mod.rs

@@ -28,6 +28,7 @@ pub mod export_app;
 mod exports;
 mod fetch_column_stats;
 mod get_viewer_config;
+mod hosted_tables;
 mod is_invalid_drop;
 mod palette_set;
 mod plugin_column_styles;
@@ -40,6 +41,7 @@ pub use self::export_app::*;
 pub use self::exports::*;
 pub use self::fetch_column_stats::*;
 pub use self::get_viewer_config::*;
+pub use self::hosted_tables::*;
 pub use self::is_invalid_drop::*;
 pub use self::palette_set::*;
 pub use self::plugin_column_styles::*;

package/src/rust/queries/palette_set.rs

@@ -12,8 +12,8 @@
 
 use std::collections::BTreeMap;
 
-use crate::config::{CssKind, CssLiteralUse, NamedValue, assign_palette_names};
 use crate::presentation::Presentation;
+use crate::utils::{CssKind, CssLiteralUse, NamedValue, assign_palette_names};
 use crate::workspace::{PanelId, Workspace};
 
 /// Every CSS literal in use across the workspace, as `(panel id, use)`,

package/src/rust/renderer/activate.rs

@@ -51,9 +51,7 @@ pub fn mount_plugin(
 }
 
 /// Given an async `task` which draws `plugin`, [`mount_plugin`] it, then run
-/// `task`. Requires the [`RenderGuard`] lock witness — plugin dispatch
-/// outside a locked run does not compile (invariants I3/I6 of the merge;
-/// see `SESSION_CONFIG_COHERENCE_PLAN.md`).
+/// `task`.
 pub async fn activate_plugin<T>(
     _guard: &RenderGuard,
     viewer: &HtmlElement,