@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/renderer/dispatch.rs

@@ -25,7 +25,7 @@ use web_sys::*;
 
 use super::activate::*;
 use super::limits::*;
-use super::{ContextPin, RenderContext, Renderer, SUBPIXEL_EPSILON};
+use super::{ContextPin, GeometryCmd, RenderContext, Renderer, SUBPIXEL_EPSILON};
 use crate::js::plugin::*;
 use crate::session::FreshView;
 use crate::utils::*;
@@ -133,19 +133,8 @@ impl Renderer {
     }
 
     pub async fn resize(&self) -> ApiResult<()> {
-        let draw_mutex = self.draw_lock();
-        let timer = self.render_timer();
-        draw_mutex
-            .debounce_with(|_guard| async move {
-                set_timeout(timer.get_throttle()).await?;
-                let Some(jsplugin) = self.active_plugin() else {
-                    return Ok(());
-                };
-                self.stamp_active(&jsplugin);
-                jsplugin.resize().await?;
-                Ok(())
-            })
-            .await
+        self.0.geometry_cmd.set(Some(GeometryCmd::Measure));
+        self.geometry_task().await.map(|_| ())
     }
 
     /// Public one-shot resize to explicit dimensions (`viewer.resize({
@@ -190,62 +179,100 @@ impl Renderer {
         width: f64,
         height: f64,
     ) -> ApiResult<Option<js_sys::Function>> {
-        let draw_mutex = self.draw_lock();
-        draw_mutex
+        self.0.geometry_cmd.set(Some(GeometryCmd::Presize {
+            translate,
+            width,
+            height,
+        }));
+
+        self.geometry_task().await
+    }
+
+    /// Run the LATEST queued [`GeometryCmd`] on the geometry debounce slot.
+    async fn geometry_task(&self) -> ApiResult<Option<js_sys::Function>> {
+        let timer = self.render_timer();
+        self.0
+            .geometry_slot
+            .clone()
             .debounce_with(|_guard| async move {
-                let Some(plugin) = self.active_plugin() else {
+                let Some(cmd) = self.0.geometry_cmd.take() else {
                     return Ok(None);
                 };
 
-                self.stamp_active(&plugin);
-                self.clear_presize()?;
-                let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
-                let rect = main_panel.get_bounding_client_rect();
-                let size_changed = (height - rect.height()).abs() > SUBPIXEL_EPSILON
-                    || (width - rect.width()).abs() > SUBPIXEL_EPSILON;
-
-                let (dx, dy) = translate.unwrap_or((0.0, 0.0));
-                let moved = dx.abs() > SUBPIXEL_EPSILON || dy.abs() > SUBPIXEL_EPSILON;
-                if !size_changed && !moved {
-                    return Ok(None);
+                match cmd {
+                    GeometryCmd::Measure => {
+                        set_timeout(timer.get_throttle()).await?;
+                        let Some(jsplugin) = self.active_plugin() else {
+                            return Ok(None);
+                        };
+
+                        self.stamp_active(&jsplugin);
+                        jsplugin.resize().await?;
+                        Ok(None)
+                    },
+                    GeometryCmd::Presize {
+                        translate,
+                        width,
+                        height,
+                    } => self.run_presize(translate, width, height).await,
                 }
+            })
+            .await
+    }
+
+    async fn run_presize(
+        &self,
+        translate: Option<(f64, f64)>,
+        width: f64,
+        height: f64,
+    ) -> ApiResult<Option<js_sys::Function>> {
+        let Some(plugin) = self.active_plugin() else {
+            return Ok(None);
+        };
 
-                if plugin.capabilities().presize {
-                    if size_changed {
-                        return plugin.presize(width, height).await;
-                    }
+        self.stamp_active(&plugin);
+        self.clear_presize()?;
+        if plugin.capabilities().presize {
+            return plugin.presize(width, height).await;
+        }
 
-                    return Ok(None);
-                }
+        let main_panel: &web_sys::HtmlElement = plugin.unchecked_ref();
+        let rect = main_panel.get_bounding_client_rect();
+        let size_changed = (height - rect.height()).abs() > SUBPIXEL_EPSILON
+            || (width - rect.width()).abs() > SUBPIXEL_EPSILON;
 
-                if size_changed {
-                    main_panel
-                        .style()
-                        .set_property("width", &format!("{width}px"))?;
-                    main_panel
-                        .style()
-                        .set_property("height", &format!("{height}px"))?;
-                }
+        let (dx, dy) = translate.unwrap_or((0.0, 0.0));
+        let moved = dx.abs() > SUBPIXEL_EPSILON || dy.abs() > SUBPIXEL_EPSILON;
+        if !size_changed && !moved {
+            return Ok(None);
+        }
 
-                if moved {
-                    main_panel
-                        .style()
-                        .set_property("transform", &format!("translate({dx}px, {dy}px)"))?;
-                }
+        if size_changed {
+            main_panel
+                .style()
+                .set_property("width", &format!("{width}px"))?;
+            main_panel
+                .style()
+                .set_property("height", &format!("{height}px"))?;
+        }
 
-                if size_changed {
-                    let result = plugin.resize().await;
-                    if translate.is_none() {
-                        main_panel.style().set_property("width", "")?;
-                        main_panel.style().set_property("height", "")?;
-                    }
+        if moved {
+            main_panel
+                .style()
+                .set_property("transform", &format!("translate({dx}px, {dy}px)"))?;
+        }
 
-                    result?;
-                }
+        if size_changed {
+            let result = plugin.resize().await;
+            if translate.is_none() {
+                main_panel.style().set_property("width", "")?;
+                main_panel.style().set_property("height", "")?;
+            }
 
-                Ok(None)
-            })
-            .await
+            result?;
+        }
+
+        Ok(None)
     }
 
     /// Remove the inline presize styles applied by [`Self::presize_with_box`].

package/src/rust/renderer.rs

@@ -53,6 +53,22 @@ use crate::utils::*;
 /// presize paths.
 pub(crate) const SUBPIXEL_EPSILON: f64 = 0.5;
 
+/// One queued geometry task for the [`RendererData::geometry_slot`] runner.
+/// `Measure` re-measures the plugin's live box (reactive resize); `Presize`
+/// renders an anticipated box ahead of a layout commit. A later command
+/// subsumes an earlier unconsumed one: `Measure` reflects whatever geometry
+/// has committed by run time, and `Presize` anticipates the NEXT commit —
+/// callers issue them in commit order.
+#[derive(Clone, Copy)]
+pub(crate) enum GeometryCmd {
+    Measure,
+    Presize {
+        translate: Option<(f64, f64)>,
+        width: f64,
+        height: f64,
+    },
+}
+
 /// Everything a plugin may read back during its render, all belonging to
 /// one snapshot (invariant I5). Built once per bound `View` by the render
 /// pipeline and CACHED on the `Renderer`; pinning it for a run is an `Rc`
@@ -104,6 +120,20 @@ pub struct RendererData {
     /// [`Renderer::presize_with_box`] presize calls.
     presize_pending: Cell<u32>,
 
+    /// Debounce slot for geometry tasks (`resize` / presize), separate from
+    /// the default slot data-update redraws coalesce on. Invariant: a
+    /// geometry request must never resolve via a parked DATA task — a
+    /// pending update's redraw renders at the worker's current dimensions
+    /// and cannot subsume a size change (the drag-during-updates permanent
+    /// skew).
+    geometry_slot: DebounceSlot,
+
+    /// Latest-wins parameter cell for the geometry slot, consumed by the
+    /// runner AT RUN TIME under the lock. Parameters live here rather than
+    /// in runner captures so a parked runner can never act on a stale
+    /// target when later calls coalesced onto it.
+    geometry_cmd: Cell<Option<GeometryCmd>>,
+
     /// Fires after every draw/update with the computed render limits.
     pub on_render_limits_changed: RefCell<Option<Callback<RenderLimits>>>,
 
@@ -221,6 +251,7 @@ impl Deref for RendererData {
 
 impl Renderer {
     pub fn new(viewer_elem: &HtmlElement) -> Self {
+        let draw_lock = DebounceMutex::default();
         Self(Rc::new(RendererData {
             plugin_data: RefCell::new(RendererMutData {
                 viewer_elem: viewer_elem.clone(),
@@ -231,7 +262,9 @@ impl Renderer {
                 timer: MovingWindowRenderTimer::default(),
                 plugin_states: HashMap::default(),
             }),
-            draw_lock: Default::default(),
+            geometry_slot: draw_lock.slot(),
+            geometry_cmd: Cell::new(None),
+            draw_lock,
             plugin_changed: Default::default(),
             style_changed: Default::default(),
             reset_changed: Default::default(),

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/drag_drop_update.rs

@@ -96,9 +96,27 @@ pub impl ViewConfig {
                 config.filter.retain(|x| x.column() != column);
                 update.filter = Some(config.filter.clone());
             },
+            DragEffect::Move(
+                DragTarget::WindowSource
+                | DragTarget::WindowOrderBy
+                | DragTarget::WindowPartitionBy,
+            ) => {
+                // Staged origins (window-editor pills) have nothing to remove
+                // HERE - the editor's draft is not part of the view config
+                // this update mutates. The open `WindowEditor` observes the
+                // same `drop_received` event and clears the origin slot in
+                // its draft, completing the move.
+            },
         }
 
         match drop {
+            DragTarget::WindowSource
+            | DragTarget::WindowOrderBy
+            | DragTarget::WindowPartitionBy => {
+                // Unreachable: staged drops never build config updates
+                // (`DragTarget::is_staged` is excluded by every committing
+                // `drop_received` subscriber).
+            },
             DragTarget::Active => {
                 if !is_swap_to_after_last {
                     if is_to_swap || is_from_required {

package/src/rust/session/metadata.rs

@@ -69,6 +69,7 @@ pub struct SessionMetadataState {
     edit_port: f64,
     view_schema: Option<HashMap<String, ColumnType>>,
     expr_meta: Option<SessionViewExpressionMetadata>,
+    window_schema: HashMap<String, ColumnType>,
 }
 
 impl SessionMetadata {
@@ -95,6 +96,41 @@ impl SessionMetadata {
         Ok(())
     }
 
+    /// Records the pre-aggregation types of the config's window columns, so
+    /// `get_column_table_type` resolves them like any other derived column.
+    pub(super) fn update_windows(
+        &mut self,
+        windows: &perspective_client::config::Windows,
+    ) -> ApiResult<()> {
+        let window_schema = windows
+            .iter()
+            .filter_map(|(name, w)| {
+                let source = self.get_column_table_type(&w.column)?;
+                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();
+        self.as_mut().unwrap().window_schema = window_schema;
+        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
@@ -212,6 +248,19 @@ impl SessionMetadata {
         self.as_ref().map(|meta| &meta.column_names)
     }
 
+    pub fn is_column_window(&self, name: &str) -> bool {
+        self.as_ref()
+            .map(|meta| meta.window_schema.contains_key(name))
+            .unwrap_or_default()
+    }
+
+    pub fn get_window_columns(&self) -> impl Iterator<Item = &'_ String> {
+        self.as_ref()
+            .map(|meta| meta.window_schema.keys())
+            .into_iter()
+            .flatten()
+    }
+
     pub fn is_column_expression(&self, name: &str) -> bool {
         let is_expr: Option<bool> = try {
             self.as_ref()?
@@ -253,14 +302,18 @@ impl SessionMetadata {
     pub fn get_column_table_type(&self, name: &str) -> Option<ColumnType> {
         try {
             let meta = self.as_ref()?;
-            meta.table_schema.get(name).cloned().or_else(|| {
-                meta.expr_meta
-                    .as_ref()?
-                    .expressions
-                    .expression_schema
-                    .get(name)
-                    .cloned()
-            })?
+            meta.table_schema
+                .get(name)
+                .cloned()
+                .or_else(|| {
+                    meta.expr_meta
+                        .as_ref()?
+                        .expressions
+                        .expression_schema
+                        .get(name)
+                        .cloned()
+                })
+                .or_else(|| meta.window_schema.get(name).cloned())?
         }
     }
 
@@ -282,7 +335,9 @@ impl SessionMetadata {
     /// expressions.
     pub fn locator_name_or_default(&self, locator: &ColumnLocator) -> String {
         match locator {
-            ColumnLocator::Table(s) | ColumnLocator::Expression(s) => s.clone(),
+            ColumnLocator::Table(s) | ColumnLocator::Expression(s) | ColumnLocator::Window(s) => {
+                s.clone()
+            },
             ColumnLocator::NewExpression => self.make_new_column_name(None),
         }
     }

package/src/rust/session/replace_expression_update.rs

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

package/src/rust/session.rs

@@ -806,11 +806,11 @@ impl Session {
     }
 
     /// SYNC name validation for a candidate config (I4): every referenced
-    /// column must be a table column or an expression present in the
-    /// candidate itself (syntactic presence — server-side compilability is a
-    /// run property, not a commit property). Skipped when no table is bound
-    /// yet: the config rides along until `load()` binds one, and the engine
-    /// surfaces any residual error on that run.
+    /// column must be a table column, or an expression or window column
+    /// present in the candidate itself (syntactic presence — server-side
+    /// compilability is a run property, not a commit property). Skipped
+    /// when no table is bound yet: the config rides along until `load()`
+    /// binds one, and the engine surfaces any residual error on that run.
     fn validate_names(&self, config: &ViewConfig) -> ApiResult<()> {
         let table_columns = self.all_columns();
         if table_columns.is_empty() {
@@ -819,6 +819,7 @@ impl Session {
 
         let mut allowed: HashSet<&str> = table_columns.iter().map(|x| x.as_str()).collect();
         allowed.extend(config.expressions.0.keys().map(|x| x.as_str()));
+        allowed.extend(config.windows.keys().map(|x| x.as_str()));
         let named = config
             .columns
             .iter()
@@ -1144,6 +1145,7 @@ impl Session {
         let view = table.view(Some(view_config.into())).await?;
         let view_schema = view.schema().await?;
         self.metadata_mut().update_view_schema(&view_schema)?;
+        self.metadata_mut().update_windows(&effective.windows)?;
         let on_stats = Callback::from({
             let this = self.clone();
             move |stats| this.update_stats(stats)

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

@@ -0,0 +1,155 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ 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 perspective_client::clone;
+use perspective_client::config::{Filter, ViewConfigUpdate, WindowSpec};
+
+use super::apply_and_render;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab, OpenColumnSettings, Presentation};
+use crate::renderer::Renderer;
+use crate::session::Session;
+use crate::*;
+
+fn reopen(presentation: &Presentation, name: String) {
+    presentation.set_open_column_settings(Some(OpenColumnSettings {
+        locator: Some(ColumnLocator::Window(name)),
+        tab: Some(ColumnSettingsTab::Window),
+    }));
+}
+
+/// Insert `spec` into the session's windows as `name` (replacing any spec
+/// under the same key) and re-render. After the render completes, opens the
+/// column-settings drawer on the new window column.
+pub fn save_window(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    name: String,
+    spec: WindowSpec,
+) -> ApiResult<()> {
+    let presentation = presentation.clone();
+    let task = {
+        let mut windows = session.get_view_config().windows.clone();
+        windows.insert(name.clone(), spec);
+        apply_and_render(session, renderer, ViewConfigUpdate {
+            windows: Some(windows),
+            ..Default::default()
+        })
+    }?;
+
+    ApiFuture::spawn(async move {
+        task.await?;
+        reopen(&presentation, name);
+        Ok(())
+    });
+
+    Ok(())
+}
+
+/// Replace the window at `old_name` with `spec` and re-render. A rename
+/// rewrites every config reference to the old name - `columns`, `group_by`,
+/// `split_by`, `sort`, `filter` and the `aggregates` key - so usage follows
+/// the column, as expression renames do.
+pub fn update_window(
+    session: &Session,
+    renderer: &Renderer,
+    presentation: &Presentation,
+    old_name: String,
+    new_name: String,
+    spec: WindowSpec,
+) {
+    clone!(session, renderer, presentation);
+    ApiFuture::spawn(async move {
+        let update = {
+            let config = session.get_view_config().clone();
+            let mut windows = config.windows.clone();
+            windows.remove(&old_name);
+            windows.insert(new_name.clone(), spec);
+
+            let rename = |col: &String| -> String {
+                if col == &old_name {
+                    new_name.clone()
+                } else {
+                    col.clone()
+                }
+            };
+
+            let mut update = ViewConfigUpdate {
+                windows: Some(windows),
+                ..Default::default()
+            };
+
+            if old_name != new_name {
+                update.columns = Some(
+                    config
+                        .columns
+                        .iter()
+                        .map(|col| col.as_ref().map(rename))
+                        .collect(),
+                );
+                update.group_by = Some(config.group_by.iter().map(&rename).collect());
+                update.split_by = Some(config.split_by.iter().map(&rename).collect());
+                update.sort = Some(
+                    config
+                        .sort
+                        .iter()
+                        .map(|sort| {
+                            let mut sort = sort.clone();
+                            sort.0 = rename(&sort.0);
+                            sort
+                        })
+                        .collect(),
+                );
+                update.filter = Some(
+                    config
+                        .filter
+                        .iter()
+                        .map(|filter| {
+                            if filter.column() == old_name {
+                                Filter::new(new_name.as_str(), filter.op(), filter.term().clone())
+                            } else {
+                                filter.clone()
+                            }
+                        })
+                        .collect(),
+                );
+                update.aggregates = Some(
+                    config
+                        .aggregates
+                        .iter()
+                        .map(|(col, agg)| (rename(col), agg.clone()))
+                        .collect(),
+                );
+            }
+
+            update
+        };
+
+        apply_and_render(&session, &renderer, update)?.await?;
+        reopen(&presentation, new_name);
+        Ok(())
+    });
+}
+
+/// Remove the window named `name` from the session and re-render.
+pub fn delete_window(session: &Session, renderer: &Renderer, name: &str) -> ApiResult<()> {
+    let mut windows = session.get_view_config().windows.clone();
+    windows.remove(name);
+    let config = ViewConfigUpdate {
+        windows: Some(windows),
+        ..ViewConfigUpdate::default()
+    };
+
+    let task = apply_and_render(session, renderer, config)?;
+    ApiFuture::spawn(task);
+    Ok(())
+}

package/src/rust/tasks/mod.rs

@@ -27,6 +27,7 @@ mod copy_export;
 mod create_panel;
 mod dismiss_render_warning;
 mod edit_expression;
+mod edit_window;
 mod eject;
 mod pipeline;
 mod presize_panels;
@@ -58,6 +59,7 @@ pub use self::copy_export::*;
 pub(crate) use self::create_panel::*;
 pub use self::dismiss_render_warning::*;
 pub use self::edit_expression::*;
+pub use self::edit_window::*;
 pub use self::eject::*;
 pub use self::pipeline::*;
 pub use self::presize_panels::*;