ggrust 0.2.0__tar.gz → 0.2.1__tar.gz

{ggrust-0.2.0 → ggrust-0.2.1}/Cargo.lock

@@ -448,7 +448,7 @@ dependencies = [
 
 [[package]]
 name = "ggrust-core"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "ahash",
  "arrow-array",
@@ -470,7 +470,7 @@ dependencies = [
 
 [[package]]
 name = "ggrust-python"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "ggrust-core",
  "pyo3",

{ggrust-0.2.0 → ggrust-0.2.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/ggrust-core", "crates/ggrust-python"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/datavil/ggrust"

{ggrust-0.2.0 → ggrust-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ggrust
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Scientific/Engineering :: Visualization

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/build.rs

@@ -35,7 +35,7 @@ use crate::scale::number_format::{ExponentStyle, NumberFormat};
 use crate::scale::style::spec::{StyleScaleSpec, style_scale_specs};
 use crate::scale::style::{LegendEntry, StyleScale, default_mapper};
 use crate::scale::{AxisScaleSpec, PositionScale, PositionScales, position_scales};
-use crate::scene::{Group, Node, PerItem, Rect, Rects, Scene};
+use crate::scene::{Group, LAYER_ROLE, Node, PerItem, Rect, Rects, Scene};
 use crate::spec::{
     Aesthetic, DataSource, GuideOptions, GuideSpec, LayerSpec, Mapping, MappingAnnotation,
     MappingValue, Options, PlotSpec, SeriesAnnotation, TooltipsSpec, Value,
@@ -139,6 +139,9 @@ pub fn build_plot_with(spec: &PlotSpec, data: &PlotData, interactive: bool) -> R
             ..Interaction::default()
         };
         plot.interaction(&arrangement, &mut interaction, &mut warnings)?;
+        if let Some(zoom) = &interaction.zoom {
+            zoom.check_layer_labels("ggtoolbar")?;
+        }
         Some(interaction)
     } else {
         None
@@ -949,14 +952,16 @@ impl PreparedPlot {
             let Some((layers, tile_x, tile_y)) = self.tiles.get(tile) else {
                 continue;
             };
-            for (layer, setup) in layers.iter().zip(&self.tooltip_setups) {
-                jobs.push((rect, tile_x, tile_y, layer, setup));
+            let indices = toggle_indices(layers);
+            for ((layer, setup), index) in layers.iter().zip(&self.tooltip_setups).zip(indices) {
+                jobs.push((rect, tile_x, tile_y, index, layer, setup));
             }
         }
-        let layer_interaction = |&(rect, tile_x, tile_y, layer, setup): &(
+        let layer_interaction = |&(rect, tile_x, tile_y, layer_index, layer, setup): &(
             Rect,
             &PositionScale,
             &PositionScale,
+            usize,
             &PreparedLayer,
             &LayerTooltipSetup,
         ),
@@ -1031,6 +1036,7 @@ impl PreparedPlot {
             };
             Ok(Some(LayerInteraction {
                 panel: LayerInteraction::panel_of(rect),
+                layer: layer_index,
                 lookup,
                 targets,
                 content,
@@ -1091,7 +1097,22 @@ impl PreparedPlot {
             scales.windows(2).all(|pair| pair[0].0 == pair[1].0),
             scales.windows(2).all(|pair| pair[0].1 == pair[1].1),
         );
-        ZoomPlot { tiles, shared }
+        let geoms = self
+            .tiles
+            .first()
+            .map(|(layers, _, _)| {
+                layers
+                    .iter()
+                    .filter(|layer| !layer.companion)
+                    .map(|layer| layer.geom.name())
+                    .collect()
+            })
+            .unwrap_or_default();
+        ZoomPlot {
+            tiles,
+            shared,
+            geoms,
+        }
     }
 
     /// Draw the plot as laid out by `arrangement`: everything but the background
@@ -1111,9 +1132,21 @@ impl PreparedPlot {
                     .geom
                     .draw(&draw_layer, &panel.oriented(layer.y_oriented))
             });
-            let mut layer_nodes = Vec::new();
-            for nodes in drawn {
-                layer_nodes.extend(nodes?);
+            let mut layer_nodes: Vec<Node> = Vec::new();
+            for (nodes, layer) in drawn.into_iter().zip(layers) {
+                let nodes = nodes?;
+                if layer.companion
+                    && let Some(Node::Group(group)) = layer_nodes.last_mut()
+                {
+                    group.nodes.extend(nodes);
+                    continue;
+                }
+                layer_nodes.push(Node::Group(Group {
+                    clip: None,
+                    role: Some(LAYER_ROLE),
+                    anchor: None,
+                    nodes,
+                }));
             }
             Ok(layer_nodes)
         };
@@ -1540,6 +1573,26 @@ struct PreparedLayer {
     styles: Styles,
     /// `show_legend` (default: the geom's).
     show_legend: bool,
+    /// Drawn on behalf of the layer before it: the outlier points the Python
+    /// `geom_boxplot` adds as a second spec layer. It shares that layer's group
+    /// and toggle (`ggtb(layers=...)`), so toggle indices count the layers the
+    /// user added.
+    companion: bool,
+}
+
+/// The toggle index (`ggtb(layers=...)`) of every layer: companion layers take
+/// the index of the layer they belong to.
+fn toggle_indices(layers: &[PreparedLayer]) -> Vec<usize> {
+    let mut next = 0;
+    layers
+        .iter()
+        .map(|layer| {
+            if !layer.companion || next == 0 {
+                next += 1;
+            }
+            next - 1
+        })
+        .collect()
 }
 
 /// Stage 1 of a layer: look up geom/stat/position, validate options, fetch the
@@ -2138,12 +2191,15 @@ fn compute_layer(
         y_oriented,
         mapping_paths,
         show_legend: spec.show_legend.unwrap_or(geom.shows_legend()),
+        companion: layer_stat(spec).is_some_and(|stat| stat.name() == "boxplot_outlier"),
         warnings,
     })
 }
 
 /// A layer after [`compute_layer`]: positions scaled, stat and position applied.
 struct ComputedLayer {
+    /// See [`PreparedLayer::companion`].
+    companion: bool,
     /// Layer options with aliases normalised (`colour` -> `color`).
     options: Options,
     path: String,
@@ -2206,6 +2262,7 @@ fn style_layer(
             y_span: layer.y_span,
             styles,
             show_legend: layer.show_legend,
+            companion: layer.companion,
         },
         warnings,
     ))

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/grid.rs

@@ -81,6 +81,12 @@ pub fn build_figure_with(
                 nodes,
             };
             scene.validate()?;
+            if let Some(zoom) = collected
+                .as_ref()
+                .and_then(|(interaction, _)| interaction.zoom.as_ref())
+            {
+                zoom.check_layer_labels("ggtoolbar")?;
+            }
             let interaction = collected.map(|(interaction, notes)| {
                 for note in notes {
                     if !warnings.contains(&note) {

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/layout/zoom.rs

@@ -72,6 +72,9 @@ pub struct Zoom {
     pub size_zoomin: f64,
     /// Every plot of the figure (one, or the plots of a grid), in drawing order.
     pub plots: Vec<ZoomPlot>,
+    /// Layer visibility toggles (`ggtb(layers=...)`): `None` without them,
+    /// else the user's labels as (label, layer index), possibly empty.
+    pub layer_labels: Option<Vec<(String, usize)>>,
 }
 
 /// One plot: its panels zoom together on the axes they share.
@@ -82,6 +85,8 @@ pub struct ZoomPlot {
     /// Whether every panel has the same horizontal / vertical scale (facets with
     /// fixed scales): zooming one panel then zooms all of them on that axis.
     pub shared: (bool, bool),
+    /// The geom of each layer, in layer order (the default toggle labels).
+    pub geoms: Vec<&'static str>,
 }
 
 /// One panel.
@@ -160,8 +165,107 @@ impl Zoom {
             size_basis,
             size_zoomin,
             plots: Vec::new(),
+            layer_labels: parse_layer_labels(toolbar.layers.as_ref(), &format!("{path}.layers"))?,
         }))
     }
+
+    /// The toggle label of every layer of `plot`, or `None` without toggles:
+    /// the user's label, else the geom name, numbered from its second unlabelled
+    /// use (`point`, `point 2`). `geom_imshow` layers (geom `image`) read `imshow`.
+    pub fn layer_toggle_labels(&self, plot: &ZoomPlot) -> Option<Vec<String>> {
+        let named = self.layer_labels.as_ref()?;
+        let mut seen: Vec<(&str, usize)> = Vec::new();
+        let labels = plot
+            .geoms
+            .iter()
+            .enumerate()
+            .map(|(index, geom)| {
+                if let Some((label, _)) = named.iter().find(|(_, layer)| *layer == index) {
+                    return label.clone();
+                }
+                let geom = if *geom == "image" { "imshow" } else { geom };
+                let count = match seen.iter_mut().find(|(name, _)| *name == geom) {
+                    Some((_, count)) => {
+                        *count += 1;
+                        *count
+                    }
+                    None => {
+                        seen.push((geom, 1));
+                        1
+                    }
+                };
+                match count {
+                    1 => geom.to_string(),
+                    _ => format!("{geom} {count}"),
+                }
+            })
+            .collect();
+        Some(labels)
+    }
+
+    /// Check, once every plot is collected, that each labelled layer index
+    /// exists in at least one plot; `path` locates `ggtb` in error messages.
+    pub fn check_layer_labels(&self, path: &str) -> crate::Result<()> {
+        let Some(named) = &self.layer_labels else {
+            return Ok(());
+        };
+        let count = self
+            .plots
+            .iter()
+            .map(|plot| plot.geoms.len())
+            .max()
+            .unwrap_or(0);
+        match named.iter().find(|(_, layer)| *layer >= count) {
+            Some((label, layer)) => Err(crate::Error::spec(
+                format!("{path}.layers.{label}"),
+                format!(
+                    "layer index {layer} does not exist; the plot has {count} layer(s), \
+                     indexed from 0 in the order they were added"
+                ),
+            )),
+            None => Ok(()),
+        }
+    }
+}
+
+/// `ggtb(layers=...)`: `true` gives toggles with default labels, `false` or
+/// nothing none, an object maps labels to layer indices.
+fn parse_layer_labels(
+    value: Option<&crate::spec::Value>,
+    path: &str,
+) -> crate::Result<Option<Vec<(String, usize)>>> {
+    use crate::spec::Value;
+    let accepted = "use true, false, or a dict of labels to layer indices such as {\"spots\": 1}";
+    match value {
+        None | Some(Value::Null) | Some(Value::Bool(false)) => Ok(None),
+        Some(Value::Bool(true)) => Ok(Some(Vec::new())),
+        Some(Value::Object(entries)) => {
+            let mut labels: Vec<(String, usize)> = Vec::new();
+            for (label, index) in entries {
+                let Some(layer) = index.as_u64().and_then(|value| usize::try_from(value).ok())
+                else {
+                    return Err(crate::Error::spec(
+                        format!("{path}.{label}"),
+                        format!("{index} is not a layer index; use an integer >= 0"),
+                    ));
+                };
+                if let Some((other, _)) = labels.iter().find(|(_, existing)| *existing == layer) {
+                    return Err(crate::Error::spec(
+                        format!("{path}.{label}"),
+                        format!(
+                            "layer {layer} is already labelled '{other}'; give each layer one label"
+                        ),
+                    ));
+                }
+                labels.push((label.clone(), layer));
+            }
+            Ok(Some(labels))
+        }
+        Some(other) => Err(crate::Error::spec(
+            path,
+            format!("{other} is not accepted; {accepted}"),
+        )),
+    }
 }
 
 /// Placeholder text of a generated label template.

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/render/html.rs

@@ -187,7 +187,11 @@ fn zoom_json(zoom: &Zoom, scene: &Scene) -> Value {
                     })
                 })
                 .collect();
-            json!({ "tiles": tiles, "shared": [plot.shared.0, plot.shared.1] })
+            let mut value = json!({ "tiles": tiles, "shared": [plot.shared.0, plot.shared.1] });
+            if let Some(labels) = zoom.layer_toggle_labels(plot) {
+                value["layers"] = json!(labels);
+            }
+            value
         })
         .collect();
     json!({

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/render/svg.rs

@@ -16,8 +16,9 @@ use super::canvas;
 use crate::parallel;
 use crate::scene::geometry::{ClipBox, is_drawable_marker, is_drawable_stroke, is_drawable_width};
 use crate::scene::{
-    Bitmap, Color, Group, HorizontalAlign, Image, MarkerPart, Node, Orientation, Path, PerItem,
-    Points, Rect, Rects, SUPERSCRIPT_RISE, SUPERSCRIPT_SCALE, Scene, Stroke, Text, VerticalAlign,
+    Bitmap, Color, Group, HorizontalAlign, Image, LAYER_ROLE, MarkerPart, Node, Orientation, Path,
+    PerItem, Points, Rect, Rects, SUPERSCRIPT_RISE, SUPERSCRIPT_SCALE, Scene, Stroke, Text,
+    VerticalAlign,
 };
 use crate::text::{CSS_FONT_FAMILY, FontFamily, measure, single_line};
 
@@ -273,6 +274,11 @@ impl SvgWriter {
     }
 
     fn group(&mut self, group: &Group) {
+        if group.role == Some(LAYER_ROLE) && group.clip.is_none() && !self.zoomable {
+            // Static output draws layer groups inline.
+            self.nodes(&group.nodes);
+            return;
+        }
         if let Some((x, y)) = group
             .anchor
             .filter(|_| group.clip.is_none() && group.role.is_none())

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/scene/mod.rs

@@ -101,14 +101,23 @@ impl Scene {
     }
 }
 
+/// Role of the group holding one layer's marks in a panel (one per layer, in
+/// layer order, empty when the layer draws nothing): the HTML runtime hides and
+/// shows layers by it (`ggtb(layers=...)`). Static output draws it inline.
+pub const LAYER_ROLE: &str = "layer";
+
 impl Group {
-    /// The children, with anchored groups ([`Group::anchor`]) replaced by their
-    /// own children: what is drawn, in order.
+    /// The children, with anchored groups ([`Group::anchor`]) and layer groups
+    /// ([`LAYER_ROLE`]) replaced by their own children: what is drawn, in order.
     pub fn flattened(&self) -> Vec<&Node> {
         fn walk<'a>(nodes: &'a [Node], flat: &mut Vec<&'a Node>) {
             for node in nodes {
                 match node {
-                    Node::Group(group) if group.anchor.is_some() => walk(&group.nodes, flat),
+                    Node::Group(group)
+                        if group.anchor.is_some() || group.role == Some(LAYER_ROLE) =>
+                    {
+                        walk(&group.nodes, flat)
+                    }
                     other => flat.push(other),
                 }
             }

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/spec/plot.rs

@@ -216,7 +216,7 @@ pub struct CaptionSpec {
     pub unsupported: Options,
 }
 
-/// `ggtb(size_basis=..., size_zoomin=...)`.
+/// `ggtb(size_basis=..., size_zoomin=..., layers=...)`.
 #[derive(Debug, Clone, Default, PartialEq, Deserialize)]
 #[serde(default)]
 pub struct ToolbarSpec {
@@ -224,6 +224,9 @@ pub struct ToolbarSpec {
     pub size_basis: Option<String>,
     /// How symbol sizes react to zoom-in; `-1` means unlimited growth.
     pub size_zoomin: Option<f64>,
+    /// Layer visibility toggles (a ggrust extension): `true`, or an object of
+    /// labels to layer indices (`{"spots": 1}`). Parsed by `Zoom::from_spec`.
+    pub layers: Option<super::Value>,
     /// Keys no component consumes.
     #[serde(flatten)]
     pub unsupported: Options,

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/src/tooltip/mod.rs

@@ -214,6 +214,9 @@ pub struct LayerInteraction {
     /// The panel, `[x, y, width, height]` in scene pixels: axis tooltips sit on
     /// its edges, anchored tooltips in its corners.
     pub panel: [f64; 4],
+    /// The layer's toggle index in its plot (`ggtb(layers=...)`, layers as the user
+    /// added them): hidden layers do not answer the cursor.
+    pub layer: usize,
     /// How targets are found.
     pub lookup: Lookup,
     /// The targets.
@@ -320,6 +323,7 @@ mod tests {
         let interaction = Interaction {
             layers: vec![LayerInteraction {
                 panel: [0.0, 0.0, 10.0, 10.0],
+                layer: 0,
                 lookup: Lookup::Nearest,
                 targets: HoverTargets::Points {
                     x: vec![1.0],

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/tests/build_lines.rs

@@ -225,7 +225,7 @@ fn intercepts_train_the_scales() {
             .groups_with_role("panel")
             .into_iter()
             .filter_map(|group| {
-                group.nodes.iter().find_map(|node| match node {
+                group.flattened().into_iter().find_map(|node| match node {
                     Node::Points(points) => Some(points.x[1]),
                     _ => None,
                 })
@@ -318,7 +318,7 @@ fn blank_draws_nothing_but_trains_the_scales() {
         frame(vec![0.0, 10.0], vec![0.0, 10.0], vec!["a", "a"]),
     );
     assert!(built.warnings.is_empty(), "{:?}", built.warnings);
-    assert!(panel(&built).nodes.is_empty());
+    assert!(panel(&built).flattened().is_empty());
     // The axis shows the data range, so tick labels exist.
     let has_text = built
         .scene

{ggrust-0.2.0 → ggrust-0.2.1}/crates/ggrust-core/tests/build_point.rs

@@ -66,8 +66,8 @@ fn panel(built: &BuiltPlot) -> &Group {
 
 fn points(built: &BuiltPlot) -> &Points {
     panel(built)
-        .nodes
-        .iter()
+        .flattened()
+        .into_iter()
         .find_map(|node| match node {
             Node::Points(points) => Some(points),
             _ => None,

{ggrust-0.2.0 → ggrust-0.2.1}/js/ggrust.js

@@ -11,7 +11,8 @@
 // The SVG is complete without this script: notebooks that do not run JavaScript
 // (GitHub, nbviewer) still show the static plot.
 // With `ggtb()` it also adds lets-plot's toolbar (pan, rubber band zoom,
-// centerpoint zoom, reset) and zooms panels: see "Zoom and pan" below.
+// centerpoint zoom, reset) and zooms panels: see "Zoom and pan" below. With
+// `ggtb(layers=...)` the toolbar also hides and shows layers: see "Layer toggles".
 // Dense point batches (more than 50k markers) arrive as base64 typed arrays
 // and are stamped on a canvas inside their SVG placeholder: see "Canvas points".
 //
@@ -238,7 +239,7 @@
   function lookup(plot, x, y) {
     var best = null;
     plot.layers.forEach(function (layer) {
-      if (!inPanel(layer, x, y)) {
+      if (layer.hidden || !inPanel(layer, x, y)) {
         return;
       }
       var result = search(layer, x, y);
@@ -530,6 +531,7 @@
     var width = layer.canvas.width, height = layer.canvas.height;
     context.setTransform(1, 0, 0, 1, 0, 0);
     context.clearRect(0, 0, width, height);
+    if (layer.hidden) return;
     var direct = layer.styles.length > MAX_SPRITES;
     if (!direct && layer.sprites.k !== k) layer.sprites = { k: k };
     var hs = h.scale * ratio, ho = h.offset * ratio, vs = v.scale * ratio, vo = v.offset * ratio;
@@ -976,7 +978,9 @@
   // with their anchor, everything else is scaled.
   function collectMarks(container, marks) {
     for (var child = container.firstElementChild; child; child = child.nextElementSibling) {
-      if (child.getAttribute("class") === "ggrust-canvas") {
+      if (child.getAttribute("class") === "layer") {
+        collectMarks(child, marks); // one layer's marks (see "Layer toggles")
+      } else if (child.getAttribute("class") === "ggrust-canvas") {
         if (child.ggrustCanvas) marks.push({ kind: "canvas", layer: child.ggrustCanvas });
       } else if (child.getAttribute("class") === "ggrust-points") {
         for (var m = child.firstElementChild; m; m = m.nextElementSibling) {
@@ -994,7 +998,8 @@
       } else if (child.tagName.toLowerCase() === "g" && child.querySelector(".ggrust-points,.ggrust-canvas,[data-anchor]")) {
         collectMarks(child, marks);
       } else {
-        marks.push({ kind: "shape", element: child });
+        // A shape may carry its own transform (a mirrored image): zoom composes with it.
+        marks.push({ kind: "shape", element: child, transform: child.getAttribute("transform") });
       }
     }
   }
@@ -1049,8 +1054,13 @@
       }
       var e = mark.element;
       if (mark.kind === "shape") {
-        if (reset) e.removeAttribute("transform");
-        else e.setAttribute("transform", matrix);
+        var own = mark.transform;
+        if (reset) {
+          if (own) e.setAttribute("transform", own);
+          else e.removeAttribute("transform");
+        } else {
+          e.setAttribute("transform", own ? matrix + " " + own : matrix);
+        }
         return;
       }
       var x = h.scale * mark.x + h.offset, y = v.scale * mark.y + v.offset;
@@ -1382,9 +1392,88 @@
       if (plot.zoom.tool) selectTool(plot, plot.zoom.tool);
       resetViews(plot);
     });
+    if (plot.zoom.plots.some(function (zoomPlot) { return zoomPlot.layers; })) {
+      layersMenu(plot, bar);
+    }
     plot.root.insertBefore(holder, plot.svg);
   }
 
+  // -- Layer toggles (`ggtb(layers=...)`, a ggrust extension) --
+  //
+  // Every panel holds one `g.layer` per layer, in layer order (empty when the
+  // layer draws nothing). Hiding layer i of a plot hides that group in each of
+  // its panels, stops its canvas points from drawing and its tooltip targets
+  // from answering. Each plot of a grid has its own list; legends stay.
+
+  var LAYERS_ICON = icon('<path fill-rule="evenodd" d="M8,1.5 1.5,5 8,8.5 14.5,5ZM8,2.64 12.39,5 8,7.36 3.61,5Z"/>' +
+    '<path d="M2.24,7.6 1.76,8.48 8,11.84 14.24,8.48 13.76,7.6 8,10.7Z"/>' +
+    '<path d="M2.24,10.6 1.76,11.48 8,14.84 14.24,11.48 13.76,10.6 8,13.7Z"/>');
+
+  function layerGroup(tile, index) {
+    var panel = childByClass(tile.element, "panel");
+    var count = 0;
+    for (var child = panel ? panel.firstElementChild : null; child; child = child.nextElementSibling) {
+      if (child.getAttribute("class") === "layer" && count++ === index) return child;
+    }
+    return null;
+  }
+
+  function setLayerVisible(plot, zoomPlot, index, visible) {
+    zoomPlot.hidden[index] = !visible;
+    zoomPlot.tiles.forEach(function (tile) {
+      var group = layerGroup(tile, index);
+      if (group) {
+        group.style.display = visible ? "" : "none";
+        var holders = group.querySelectorAll("foreignObject.ggrust-canvas");
+        for (var i = 0; i < holders.length; i++) {
+          if (holders[i].ggrustCanvas) holders[i].ggrustCanvas.hidden = !visible;
+        }
+      }
+      (plot.layers || []).forEach(function (entry) {
+        if (entry.layer === index && samePanel(entry.panel, tile.spec.panel)) entry.hidden = !visible;
+      });
+      tile.dirty = true; // redraws its canvas points at the current view
+    });
+    if (plot.overlay) show(plot, null);
+    schedule(plot);
+  }
+
+  function layersMenu(plot, bar) {
+    var menu = element("div", "position:absolute;top:34px;left:50%;transform:translateX(-50%);z-index:2;" +
+      "display:none;box-sizing:border-box;min-width:120px;padding:6px 8px;background-color:rgba(255, 255, 255, 0.97);" +
+      "border:" + BAR_BORDER + ";border-radius:10px;box-shadow:0 2px 8px rgba(0, 0, 0, 0.12);" +
+      "font:12px sans-serif;color:" + BUTTON_SELECTED + ";text-align:left;white-space:nowrap;", bar);
+    menu.className = "ggrust-layers";
+    var listed = plot.zoom.plots.filter(function (zoomPlot) { return zoomPlot.layers; });
+    plot.zoom.plots.forEach(function (zoomPlot, plotIndex) {
+      if (!zoomPlot.layers) return;
+      if (listed.length > 1) {
+        var heading = element("div", "margin:4px 0 2px 0;font-weight:bold;color:" + BUTTON_STROKE + ";", menu);
+        heading.textContent = "Plot " + (plotIndex + 1);
+      }
+      zoomPlot.layers.forEach(function (label, index) {
+        var row = element("label", "display:flex;align-items:center;gap:6px;padding:2px 0;cursor:pointer;", menu);
+        var box = element("input", "margin:0;cursor:pointer;", row);
+        box.type = "checkbox";
+        box.checked = !zoomPlot.hidden[index];
+        box.addEventListener("change", function () { setLayerVisible(plot, zoomPlot, index, box.checked); });
+        element("span", "", row).textContent = label;
+      });
+    });
+    var toggle = button("Layers", LAYERS_ICON, bar, function () {
+      var open = menu.style.display === "none";
+      menu.style.display = open ? "block" : "none";
+      setButton(toggle, open);
+    });
+    bar.insertBefore(toggle, bar.children[TOOLS.length]); // after the zoom tools, before Reset
+    document.addEventListener("mousedown", function (event) {
+      if (menu.style.display !== "none" && !bar.contains(event.target)) {
+        menu.style.display = "none";
+        setButton(toggle, false);
+      }
+    });
+  }
+
   // Set up zoom/pan when the engine wrote a zoom payload (`ggtb()`).
   function attachZoom(plot) {
     var data = plot.root.querySelector("script.ggrust-zoom");
@@ -1404,6 +1493,8 @@
       plots: payload.plots.map(function (zoomPlot) {
         return {
           shared: zoomPlot.shared,
+          layers: zoomPlot.layers || null,
+          hidden: [],
           tiles: zoomPlot.tiles.map(function (spec) {
             var tile = { spec: spec, element: tileElements[next++] || null };
             tile.views = { h: spec.horizontal.domain.slice(), v: spec.vertical.domain.slice() };