diff --git a/crates/engine/src/cmd/pivot.rs b/crates/engine/src/cmd/pivot.rs
index 1451e2dab3..6ea64cd692 100644
--- a/crates/engine/src/cmd/pivot.rs
+++ b/crates/engine/src/cmd/pivot.rs
@@ -9,13 +9,13 @@ use std::sync::Arc;
 use gridcraft_core::{CellRef, RangeRef};
 use gridcraft_model::{
     Anchor, Cell, Chart, ChartKind, LegendPos, NumFmt, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs,
-    PivotSort, PivotTable, PivotValue, Sheet, StyleId, Workbook,
+    PivotSort, PivotTable, PivotValue, Sheet, SlicerSource, StyleId, Workbook,
 };
 use serde_json::{Value as Json, json};
 
 use super::{
-    CommandSpec, Ctx, EngineError, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok, str_param,
-    u32_param,
+    CommandSpec, Ctx, EngineError, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, has_doc, ok, split_sheet,
+    str_param, u32_param,
 };
 use crate::pivot as pv;
 use crate::selection::current_region;
@@ -28,6 +28,8 @@ mod params;
 
 use charts::{insert_pivot_chart, recommended};
 use create::{insert_pivot, options, show_details, summarize_table};
+#[cfg(test)]
+use fields::has_connected_slicer;
 use fields::{add_field, calculated_field, fields, list, move_field, remove_field, value_settings};
 use layout::{change_source, collapse, delete, filter, grand_totals, group, layout, refresh, refresh_all, sort};
 
diff --git a/crates/engine/src/cmd/pivot/create.rs b/crates/engine/src/cmd/pivot/create.rs
index 5a65609c3b..6372baaebc 100644
--- a/crates/engine/src/cmd/pivot/create.rs
+++ b/crates/engine/src/cmd/pivot/create.rs
@@ -90,7 +90,7 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result<Json> {
         None
     } else {
         let d = s.doc()?;
-        let (sh, body) = crate::cmd::split_sheet(&dest);
+        let (sh, body) = super::split_sheet(&dest);
         let si = match sh {
             Some(n) => d.wb.sheet_index(&n).ok_or_else(|| bad("insert.pivotTable", format!("no sheet named `{n}`")))?,
             None => active,
@@ -334,7 +334,7 @@ pub(super) fn pivot_json(wb: &Workbook, si: usize, pt: &PivotTable) -> Json {
         "rows": pt.rows.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
         "columns": pt.columns.iter().map(|f| json!({"field": f.source_col, "sort": sort_name(f.sort), "group": group_name(f.date_group), "collapsed": f.collapsed_items})).collect::<Vec<_>>(),
         "values": pt.values.iter().map(|v| json!({"field": v.source_col, "func": func_name(v.func), "name": v.name, "showAs": show_as_name(v.show_as), "numberFormat": v.number_format})).collect::<Vec<_>>(),
-        "filters": pt.filters.iter().map(|f| json!({"field": f.source_col, "selected": f.selected, "report": !in_axes(pt, &f.source_col)})).collect::<Vec<_>>(),
+        "filters": pt.filters.iter().map(|f| json!({"field": f.source_col, "selected": f.selected, "report": !f.hidden && !in_axes(pt, &f.source_col)})).collect::<Vec<_>>(),
         "layout": layout_name(pt.layout),
         "grandTotalsRows": pt.grand_totals_rows,
         "grandTotalsCols": pt.grand_totals_cols,
diff --git a/crates/engine/src/cmd/pivot/fields.rs b/crates/engine/src/cmd/pivot/fields.rs
index 48c25657ce..241a06b15b 100644
--- a/crates/engine/src/cmd/pivot/fields.rs
+++ b/crates/engine/src/cmd/pivot/fields.rs
@@ -1,8 +1,8 @@
 use super::create::pivot_json;
 use super::params::{area_param, func_param, position_param, show_as_param};
 use super::{
-    Json, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotShowAs, PivotTable, PivotValue, Result, Session, Workbook, bad,
-    bool_param, edit, find_pivot, json, ok, other, pv, str_param, u32_param,
+    Json, PivotCalcField, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotShowAs, PivotTable, PivotValue, Result, Session, SlicerSource,
+    Workbook, bad, bool_param, edit, find_pivot, json, ok, other, pv, str_param, u32_param,
 };
 
 // ---------------------------------------------------------------- layout editing (pure)
@@ -128,11 +128,16 @@ pub(super) fn add_to_area(pt: &mut PivotTable, src: &pv::Source, placement: Area
             if pt.rows.len() + pt.columns.len() >= pv::MAX_AXIS_FIELDS && !in_axes(pt, &field) {
                 return Err(other(format!("A PivotTable can have at most {} row and column fields.", pv::MAX_AXIS_FIELDS)));
             }
-            let existing = take_from_axes(pt, &field).unwrap_or_else(|| PivotField { source_col: field.clone(), ..Default::default() });
-            // A report filter that selects nothing in particular goes away; a selection stays
-            // as the field's hidden items.
+            let held = pt.filters.iter().find(|f| f.source_col.eq_ignore_ascii_case(&field)).map(|f| pt.filter_group(f)).unwrap_or_default();
+            for f in pt.filters.iter_mut().filter(|f| f.source_col.eq_ignore_ascii_case(&field)) {
+                f.date_group = held;
+            }
+            let existing =
+                take_from_axes(pt, &field).unwrap_or_else(|| PivotField { source_col: field.clone(), date_group: held, ..Default::default() });
+            // A report filter that selects nothing in particular goes away; a selection stays as the field's hidden items.
             pt.filters.retain(|f| !(f.source_col.eq_ignore_ascii_case(&field) && f.selected.is_none()));
             insert_axis_field(pt, area == "rows", existing, position);
+            pt.normalize_filter_groups();
         }
         "values" => {
             if pt.values.len() >= pv::MAX_VALUE_FIELDS {
@@ -155,11 +160,16 @@ pub(super) fn add_to_area(pt: &mut PivotTable, src: &pv::Source, placement: Area
             pt.values.insert(at, v);
         }
         _ => {
-            take_from_axes(pt, &field);
+            // The field keeps its date grouping (a cache field's) in the Filters area.
             let existing = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
+            let group = match existing.and_then(|i| pt.filters.get(i)) {
+                Some(f) => pt.filter_group(f),
+                None => pt.field_group(&field),
+            };
+            take_from_axes(pt, &field);
             let entry = match existing {
-                Some(i) => pt.filters.remove(i),
-                None => PivotFilter { source_col: field, selected: None },
+                Some(i) => PivotFilter { hidden: false, date_group: group, ..pt.filters.remove(i) },
+                None => PivotFilter { source_col: field, selected: None, hidden: false, date_group: group },
             };
             let at = position.unwrap_or(pt.filters.len()).min(pt.filters.len());
             pt.filters.insert(at, entry);
@@ -168,11 +178,26 @@ pub(super) fn add_to_area(pt: &mut PivotTable, src: &pv::Source, placement: Area
     Ok(())
 }
 
-/// Removes `field` from an area; returns the source field it referred to.
-fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str) -> Result<String> {
+/// Whether a slicer on any sheet connects to this PivotTable and field.
+pub(super) fn has_connected_slicer(wb: &Workbook, sheet: usize, pt: &PivotTable, field: &str) -> bool {
+    let Some(sheet_name) = wb.sheet(sheet).map(|sh| sh.name.as_str()) else { return false };
+    wb.sheets.iter().any(|sh| {
+        sh.slicers.iter().any(|sl| match &sl.source {
+            SlicerSource::Pivot { pivots, field: slicer_field, .. } if slicer_field.eq_ignore_ascii_case(field) => {
+                pivots.iter().any(|p| p.sheet.eq_ignore_ascii_case(sheet_name) && p.name.eq_ignore_ascii_case(&pt.name))
+            }
+            _ => false,
+        })
+    })
+}
+
+fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str, keep_slicer: bool) -> Result<String> {
     match area {
         "rows" | "columns" => {
             let rows = area == "rows";
+            let held = keep_slicer
+                .then(|| pt.filters.iter().find(|x| x.source_col.eq_ignore_ascii_case(field)).map(|x| (x.selected.clone(), pt.filter_group(x))))
+                .flatten();
             let list = if rows { &mut pt.rows } else { &mut pt.columns };
             let i = list
                 .iter()
@@ -180,8 +205,14 @@ fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str) ->
                 .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the {area} area")))?;
             let f = list.remove(i);
             shift_values(pt, rows, i, false);
-            pt.filters.retain(|x| !x.source_col.eq_ignore_ascii_case(&f.source_col));
-            Ok(f.source_col)
+            let source = f.source_col;
+            pt.filters.retain(|x| !x.source_col.eq_ignore_ascii_case(&source));
+            if let Some((selected, date_group)) = held
+                && (selected.is_some() || date_group != PivotDateGroup::None)
+            {
+                pt.filters.push(PivotFilter { source_col: source.clone(), selected, hidden: true, date_group });
+            }
+            Ok(source)
         }
         "values" => {
             let i = pt
@@ -196,7 +227,7 @@ fn remove_from_area(cmd: &str, pt: &mut PivotTable, field: &str, area: &str) ->
             let i = pt
                 .filters
                 .iter()
-                .position(|f| f.source_col.eq_ignore_ascii_case(field) && !in_axes(pt, &f.source_col))
+                .position(|f| f.source_col.eq_ignore_ascii_case(field) && !f.hidden && !in_axes(pt, &f.source_col))
                 .ok_or_else(|| bad(cmd, format!("`{field}` isn't in the filters area")))?;
             Ok(pt.filters.remove(i).source_col)
         }
@@ -251,7 +282,7 @@ pub(super) fn fields(s: &mut Session, p: &Json) -> Result<Json> {
                 if pt.values.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) {
                     areas.push("values");
                 }
-                if pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(h)) && !in_axes(pt, h) {
+                if pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(h) && !f.hidden) && !in_axes(pt, h) {
                     areas.push("filters");
                 }
                 json!({
@@ -385,15 +416,20 @@ pub(super) fn remove_field(s: &mut Session, p: &Json) -> Result<Json> {
         Some(a) => Some(area_param(C, Some(a))?),
         None => None,
     };
+    let (si, pi) = find_pivot(s, p)?;
+    let keep_slicer = {
+        let d = s.doc()?;
+        d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).is_some_and(|pt| has_connected_slicer(&d.wb, si, pt, &field))
+    };
     update(s, p, |pt, _, _| {
         match area {
             Some(a) => {
-                remove_from_area(C, pt, &field, a)?;
+                remove_from_area(C, pt, &field, a, keep_slicer)?;
             }
             None => {
                 let mut any = false;
                 for a in ["rows", "columns", "values", "filters"] {
-                    any |= remove_from_area(C, pt, &field, a).is_ok();
+                    any |= remove_from_area(C, pt, &field, a, keep_slicer).is_ok();
                 }
                 if !any {
                     return Err(bad(C, format!("`{field}` isn't in the PivotTable")));
@@ -410,6 +446,11 @@ pub(super) fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
     let from = area_param(C, str_param(p, "from"))?;
     let to = area_param(C, str_param(p, "to"))?;
     let pos = position_param(p);
+    let keep_slicer = {
+        let d = s.doc()?;
+        let (si, pi) = find_pivot(s, p)?;
+        d.wb.sheet(si).and_then(|sh| sh.pivots.get(pi)).is_some_and(|pt| has_connected_slicer(&d.wb, si, pt, &field))
+    };
     update(s, p, |pt, src, _| {
         if is_values_field(src, &field) {
             return move_values_field(C, pt, from, to, pos);
@@ -443,7 +484,7 @@ pub(super) fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
                     let i = pt
                         .filters
                         .iter()
-                        .position(|f| f.source_col.eq_ignore_ascii_case(&field))
+                        .position(|f| f.source_col.eq_ignore_ascii_case(&field) && !f.hidden && !in_axes(pt, &f.source_col))
                         .ok_or_else(|| bad(C, format!("`{field}` isn't in the filters area")))?;
                     let f = pt.filters.remove(i);
                     let at = pos.unwrap_or(pt.filters.len()).min(pt.filters.len());
@@ -452,22 +493,15 @@ pub(super) fn move_field(s: &mut Session, p: &Json) -> Result<Json> {
             }
             return Ok(json!({}));
         }
-        // Keep axis settings (sort, grouping) when moving between rows and columns.
-        let kept = pt.rows.iter().chain(pt.columns.iter()).find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
-        let hidden = pt.filters.iter().find(|f| f.source_col.eq_ignore_ascii_case(&field)).cloned();
-        let src_field = remove_from_area(C, pt, &field, from)?;
+        // Values in or out: the field leaves its area. Between Rows, Columns and Filters it moves
+        // the way addField moves it, keeping its axis settings, date grouping and filter
+        // selection (`from` is only checked).
+        let src_field = if from == "values" || to == "values" {
+            remove_from_area(C, pt, &field, from, keep_slicer)?
+        } else {
+            remove_from_area(C, &mut pt.clone(), &field, from, keep_slicer)?
+        };
         add_to_area(pt, src, AreaPlacement { cmd: C, field: &src_field, area: to, func: None, name: None, position: pos })?;
-        if matches!(to, "rows" | "columns") {
-            let list = if to == "rows" { &mut pt.rows } else { &mut pt.columns };
-            if let (Some(k), Some(slot)) = (kept, list.iter_mut().find(|f| f.source_col.eq_ignore_ascii_case(&src_field))) {
-                *slot = k;
-            }
-            if let Some(h) = hidden.filter(|h| h.selected.is_some())
-                && !pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(&src_field))
-            {
-                pt.filters.push(h);
-            }
-        }
         Ok(json!({"field": src_field, "to": to}))
     })
 }
diff --git a/crates/engine/src/cmd/pivot/layout.rs b/crates/engine/src/cmd/pivot/layout.rs
index 9b6a9527e8..e728b29033 100644
--- a/crates/engine/src/cmd/pivot/layout.rs
+++ b/crates/engine/src/cmd/pivot/layout.rs
@@ -1,5 +1,5 @@
 use super::create::source_param;
-use super::fields::{canonical, in_axes, shift_values, update};
+use super::fields::{canonical, shift_values, update};
 use super::params::{group_param, layout_name};
 use super::{
     Chart, Json, PivotDateGroup, PivotField, PivotFilter, PivotLayout, PivotSort, PivotTable, Result, Session, bad, bool_param, edit, find_pivot,
@@ -33,22 +33,17 @@ pub(super) fn filter(s: &mut Session, p: &Json) -> Result<Json> {
     };
     update(s, p, |pt, src, _| {
         let field = canonical(C, src, &field)?;
-        let i = pt.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(&field));
-        match (i, selected) {
-            (Some(i), None) => {
-                if in_axes(pt, &field) {
-                    pt.filters.remove(i);
-                } else if let Some(f) = pt.filters.get_mut(i) {
-                    f.selected = None;
-                }
+        match pt.filters.iter().find(|f| f.source_col.eq_ignore_ascii_case(&field)) {
+            Some(f) => {
+                let group = pt.filter_group(f);
+                pt.set_filter(&field, selected, group);
             }
-            (Some(i), Some(sel)) => {
-                if let Some(f) = pt.filters.get_mut(i) {
-                    f.selected = Some(sel);
+            // A field in no area becomes a report filter.
+            None => {
+                if let Some(sel) = selected {
+                    pt.filters.push(PivotFilter { source_col: field.clone(), selected: Some(sel), ..PivotFilter::default() });
                 }
             }
-            (None, Some(sel)) => pt.filters.push(PivotFilter { source_col: field.clone(), selected: Some(sel) }),
-            (None, None) => {}
         }
         Ok(json!({"field": field}))
     })
@@ -269,7 +264,7 @@ pub(super) fn change_source(s: &mut Session, p: &Json) -> Result<Json> {
 pub(super) fn delete(s: &mut Session, p: &Json) -> Result<Json> {
     let (si, pi) = find_pivot(s, p)?;
     edit(s, |cx| {
-        // Its PivotCharts become ordinary charts.
+        // Its PivotCharts become ordinary charts, and its slicers lose it.
         let link = cx.wb.sheet(si).and_then(|sh| sh.pivots.get(pi).map(|pt| (sh.name.clone(), pt.name.clone())));
         if let Some((sheet, name)) = link {
             for i in 0..cx.wb.sheets.len() {
@@ -280,6 +275,7 @@ pub(super) fn delete(s: &mut Session, p: &Json) -> Result<Json> {
                     }
                 }
             }
+            crate::cmd::slicer::drop_pivot(&mut cx.wb, &sheet, &name);
         }
         pv::clear_output(&mut cx.wb, si, pi);
         let sh = cx.sheet_mut(si)?;
diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs
index 4e4f6870c5..bb618abbe9 100644
--- a/crates/engine/src/cmd/pivot/tests.rs
+++ b/crates/engine/src/cmd/pivot/tests.rs
@@ -143,6 +143,34 @@ fn date_grouping_by_quarter_and_month() {
     assert!(s.execute("pivot.group", json!({"field": "Region", "by": "years"})).is_err());
 }
 
+#[test]
+fn move_field_keeps_the_date_grouping() {
+    use gridcraft_model::PivotDateGroup;
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Date"], "values": ["Sales"]})).unwrap();
+    s.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
+    // Columns → Filters: the report filter keeps the months.
+    s.execute("pivot.moveField", json!({"field": "Date", "from": "columns", "to": "filters"})).unwrap();
+    let p = pt(&s);
+    assert!(p.columns.is_empty());
+    let f = p.filters.iter().find(|f| f.source_col == "Date").unwrap();
+    assert_eq!(p.filter_group(f), PivotDateGroup::Months);
+    // Filters → Rows: Date on rows grouped by the filter's grouping.
+    s.execute("pivot.moveField", json!({"field": "Date", "from": "filters", "to": "rows"})).unwrap();
+    let p = pt(&s);
+    assert_eq!(p.rows.iter().find(|f| f.source_col == "Date").map(|f| f.date_group), Some(PivotDateGroup::Months));
+    assert!(p.filters.is_empty());
+    assert!(find_row(&s, "Jan").is_some());
+    // Undo brings back the report filter with its months.
+    s.execute("edit.undo", json!({})).unwrap();
+    let p = pt(&s);
+    assert!(p.rows.iter().all(|f| f.source_col != "Date"));
+    assert_eq!(p.filters.first().map(|f| p.filter_group(f)), Some(PivotDateGroup::Months));
+    // Rows → Values takes the field off Rows.
+    s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "values"})).unwrap();
+    assert!(pt(&s).rows.is_empty());
+}
+
 #[test]
 fn filters_and_report_filter_rows() {
     let mut s = sales();
@@ -780,6 +808,293 @@ fn collapsed_column_items_count_as_one_column_group() {
     s.execute("pivot.addField", json!({"field": "Sub", "area": "columns"})).unwrap();
 }
 
+/// A slicer on `field` of the PivotTables `pivots` (names on the active sheet).
+fn add_pivot_slicer(s: &mut Session, id: u32, field: &str, pivots: &[&str]) {
+    use gridcraft_model::{Anchor, PivotSort, Slicer, SlicerCrossFilter, SlicerPivot, SlicerSource};
+    let d = s.doc_mut().unwrap();
+    let si = d.wb.active_sheet();
+    let sheet = d.wb.sheets[si].name.clone();
+    let sh = std::sync::Arc::make_mut(&mut d.wb).sheet_mut(si).unwrap();
+    sh.slicers.push(Slicer {
+        id,
+        source: SlicerSource::Pivot {
+            pivots: pivots.iter().map(|n| SlicerPivot { sheet: sheet.clone(), name: n.to_string() }).collect(),
+            field: field.into(),
+            sort: PivotSort::Asc,
+            cross_filter: SlicerCrossFilter::default(),
+            show_missing: true,
+        },
+        caption: field.into(),
+        anchor: Anchor { width: 150.0, height: 200.0, ..Anchor::default() },
+        columns: 1,
+        name: String::new(),
+        style: String::new(),
+        row_height: None,
+    });
+}
+
+/// The slicer's tiles as (label, selected).
+fn slicer_tiles(s: &Session, id: u32) -> Vec<(String, bool)> {
+    let d = s.doc().unwrap();
+    let sl = d.wb.active().unwrap().slicers.iter().find(|x| x.id == id).unwrap();
+    crate::cmd::slicer::slicer_items(&d.wb, d.wb.active_sheet(), sl).into_iter().map(|t| (t.label, t.selected)).collect()
+}
+
+#[test]
+fn pivot_slicer_selects_items_of_its_pivot_tables() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Region", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Region", &["PivotTable1"]);
+    add_pivot_slicer(&mut s, 2, "Product", &["PivotTable1"]);
+    // A slicer whose PivotTable is gone shows no tiles and ignores clicks.
+    add_pivot_slicer(&mut s, 3, "Region", &["Missing"]);
+    let tiles = slicer_tiles;
+    assert_eq!(tiles(&s, 1), vec![("East".into(), true), ("North".into(), true), ("West".into(), true)]);
+    assert!(tiles(&s, 3).is_empty());
+    assert!(s.execute("slicer.toggle", json!({"slicer": 3, "value": "East"})).is_err());
+
+    // A field on Rows: clicking a tile selects that item of the field and refreshes the table.
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "East"})).unwrap();
+    assert_eq!(tiles(&s, 1), vec![("East".into(), true), ("North".into(), false), ("West".into(), false)]);
+    let f = pt(&s).filters.into_iter().find(|f| f.source_col == "Region").unwrap();
+    assert_eq!((f.selected, f.hidden), (Some(vec!["East".to_string()]), false));
+    assert!(find_row(&s, "East").is_some());
+    assert!(find_row(&s, "North").is_none() && find_row(&s, "West").is_none());
+    s.execute("slicer.clear", json!({"slicer": 1})).unwrap();
+    assert!(pt(&s).filters.is_empty());
+    assert!(find_row(&s, "North").is_some());
+
+    // A field the table doesn't show: a hidden filter, with no report filter cell.
+    let anchor = pt(&s).anchor;
+    s.execute("slicer.toggle", json!({"slicer": 2, "value": "Apples"})).unwrap();
+    let f = pt(&s).filters.into_iter().find(|f| f.source_col == "Product").unwrap();
+    assert_eq!((f.selected, f.hidden), (Some(vec!["Apples".to_string()]), true));
+    assert_eq!(pt(&s).anchor, anchor, "a hidden filter adds no filter rows");
+    let total = find_row(&s, "Grand Total").map(|r| val(&s, &CellRef::new(r, anchor.col + 1).a1()).as_f64().unwrap()).unwrap();
+    assert!(total > 0.0 && total < TOTAL, "{total}");
+    s.execute("slicer.toggle", json!({"slicer": 2, "value": "Pears", "multi": true})).unwrap();
+    assert_eq!(tiles(&s, 2), vec![("Apples".into(), true), ("Pears".into(), true), ("Plums".into(), false)]);
+    s.execute("slicer.selectAll", json!({"slicer": 2})).unwrap();
+    assert!(pt(&s).filters.is_empty());
+}
+
+#[test]
+fn move_field_rejects_hidden_slicer_filter_as_filters_area() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Product", &["PivotTable1"]);
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Apples"})).unwrap();
+    assert!(s.execute("pivot.moveField", json!({"field": "Product", "from": "filters", "to": "filters"})).is_err());
+    let p = pt(&s);
+    let f = p.filters.iter().find(|f| f.source_col == "Product").unwrap();
+    assert!(f.hidden);
+}
+
+#[test]
+fn move_axis_to_values_keeps_slicer_selection_and_grouping() {
+    use gridcraft_model::PivotDateGroup;
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Date"], "values": ["Sales"]})).unwrap();
+    s.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Date", &["PivotTable1"]);
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Jan"})).unwrap();
+    let d = s.doc().unwrap();
+    assert!(super::has_connected_slicer(&d.wb, d.wb.active_sheet(), &pt(&s), "Date"));
+    let before = pt(&s);
+    let bf = before.filters.iter().find(|f| f.source_col == "Date").unwrap();
+    assert_eq!(before.filter_group(bf), PivotDateGroup::Months);
+    s.execute("pivot.moveField", json!({"field": "Date", "from": "columns", "to": "values"})).unwrap();
+    let p = pt(&s);
+    let f = p.filters.iter().find(|f| f.source_col == "Date").unwrap();
+    assert_eq!(f.selected, Some(vec!["Jan".to_string()]));
+    assert!(f.hidden);
+    assert_eq!(p.filter_group(f), PivotDateGroup::Months);
+    assert_eq!(slicer_tiles(&s, 1), months_on(&["Jan"]));
+    let mut removed = sales();
+    removed.execute("insert.pivotTable", json!({"rows": ["Region"], "columns": ["Date"], "values": ["Sales"]})).unwrap();
+    removed.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
+    add_pivot_slicer(&mut removed, 1, "Date", &["PivotTable1"]);
+    removed.execute("slicer.toggle", json!({"slicer": 1, "value": "Jan"})).unwrap();
+    removed.execute("pivot.removeField", json!({"field": "Date", "area": "columns"})).unwrap();
+    let rp = pt(&removed);
+    let rf = rp.filters.iter().find(|f| f.source_col == "Date").unwrap();
+    assert_eq!(rf.selected, Some(vec!["Jan".to_string()]));
+    assert!(rf.hidden);
+    assert_eq!(rp.filter_group(rf), PivotDateGroup::Months);
+}
+
+#[test]
+fn move_axis_to_values_drops_manual_axis_filter() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({"rows": ["Region"], "values": ["Sales"]})).unwrap();
+    s.execute("pivot.filter", json!({"field": "Region", "selected": ["East"]})).unwrap();
+    s.execute("pivot.moveField", json!({"field": "Region", "from": "rows", "to": "values"})).unwrap();
+    assert!(pt(&s).filters.iter().all(|f| f.source_col != "Region"));
+}
+#[test]
+fn pivot_slicer_on_grouped_dates_shows_the_groups() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Date", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    s.execute("pivot.group", json!({"field": "Date", "by": "quarters"})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Date", &["PivotTable1"]);
+    let quarters = |on: [bool; 4]| ["Qtr1", "Qtr2", "Qtr3", "Qtr4"].into_iter().zip(on).map(|(q, o)| (q.to_string(), o)).collect::<Vec<_>>();
+    assert_eq!(slicer_tiles(&s, 1), quarters([true; 4]));
+    // The PivotTable's filter selects groups, and the tiles show it.
+    s.execute("pivot.filter", json!({"field": "Date", "selected": ["Qtr1"]})).unwrap();
+    assert_eq!(slicer_tiles(&s, 1), quarters([true, false, false, false]));
+    // Clicking a tile filters the PivotTable to that group.
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Qtr3"})).unwrap();
+    assert_eq!(slicer_tiles(&s, 1), quarters([false, false, true, false]));
+    assert_eq!(text(&s, "A4"), "Qtr3");
+    assert_eq!(val(&s, "B4"), Value::Number(195.0));
+    assert_eq!(text(&s, "A5"), "Grand Total");
+}
+
+#[test]
+fn pivot_slicer_keeps_one_item_selected() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Region", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Region", &["PivotTable1"]);
+    for r in ["East", "North", "West"] {
+        s.execute("slicer.toggle", json!({"slicer": 1, "value": r, "multi": true})).unwrap();
+    }
+    // Ctrl-clicking the last selected item leaves it selected, as in Excel.
+    assert_eq!(slicer_tiles(&s, 1), vec![("East".into(), false), ("North".into(), false), ("West".into(), true)]);
+    let f = pt(&s).filters.into_iter().find(|f| f.source_col == "Region").unwrap();
+    assert_eq!(f.selected, Some(vec!["West".to_string()]));
+    assert!(find_row(&s, "West").is_some());
+}
+
+/// The package `bytes` with part `name` replaced by `edit` of it.
+fn edit_part(bytes: &[u8], name: &str, edit: impl Fn(&str) -> String) -> Vec<u8> {
+    use std::io::{Read, Write};
+    let mut zin = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+    let mut zout = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for i in 0..zin.len() {
+        let mut f = zin.by_index(i).unwrap();
+        let mut data = Vec::new();
+        f.read_to_end(&mut data).unwrap();
+        let part = f.name().to_string();
+        if part == name {
+            data = edit(&String::from_utf8(data).unwrap()).into_bytes();
+        }
+        zout.start_file(part, zip::write::SimpleFileOptions::default()).unwrap();
+        zout.write_all(&data).unwrap();
+    }
+    zout.finish().unwrap().into_inner()
+}
+fn save(s: &Session) -> Vec<u8> {
+    gridcraft_xlsx::write_xlsx(&s.doc().unwrap().wb).unwrap()
+}
+/// Opens `bytes` on the PivotTable's sheet and refreshes.
+fn reopen(s: &mut Session, bytes: &[u8]) {
+    s.execute("file.open", json!({"name": "x.xlsx", "base64": crate::io::base64_encode(bytes)})).unwrap();
+    s.execute("sheet.activate", json!({"sheet": "Sheet2"})).unwrap();
+    s.execute("data.refreshAll", json!({})).unwrap();
+}
+/// The active sheet's first slicer.
+fn first_slicer(s: &Session) -> u32 {
+    s.doc().unwrap().wb.active().unwrap().slicers[0].id
+}
+/// The value next to row label `label` in the PivotTable.
+fn sum_of(s: &Session, label: &str) -> Option<Value> {
+    let col = pt(s).last_range.unwrap().start.col + 1;
+    find_row(s, label).map(|r| val(s, &CellRef::new(r, col).a1()))
+}
+const MONTHS: [&str; 12] = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+fn months_on(on: &[&str]) -> Vec<(String, bool)> {
+    MONTHS.iter().map(|m| (m.to_string(), on.contains(m))).collect()
+}
+
+/// Excel's usual dashboard: a slicer on Date grouped by months, and a PivotTable by Region
+/// with Date in no area. The grouping belongs to the cache field, so the PivotTable filters
+/// by month, the tiles are months, and both survive a save.
+#[test]
+fn pivot_slicer_on_grouped_date_in_no_area_keeps_the_grouping() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Region", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Date", "area": "columns"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    s.execute("pivot.group", json!({"field": "Date", "by": "months"})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Date", &["PivotTable1"]);
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Jan"})).unwrap();
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Feb", "multi": true})).unwrap();
+    // Take Date out of the PivotTable's areas in the file, keeping the cache's grouping.
+    let bytes = edit_part(&save(&s), "xl/pivotTables/pivotTable1.xml", |x| {
+        let (a, b) = (x.find("<colFields").unwrap(), x.find("</colFields>").unwrap() + "</colFields>".len());
+        format!("{}{}", &x[..a], &x[b..]).replace(" axis=\"axisCol\"", "")
+    });
+    reopen(&mut s, &bytes);
+    assert!(pt(&s).columns.is_empty());
+    assert_eq!(slicer_tiles(&s, first_slicer(&s)), months_on(&["Jan", "Feb"]));
+    assert_eq!(sum_of(&s, "East"), Some(Value::Number(100.0)));
+    assert_eq!(sum_of(&s, "West"), Some(Value::Number(50.0)));
+    assert_eq!(sum_of(&s, "North"), None);
+    assert_eq!(sum_of(&s, "Grand Total"), Some(Value::Number(150.0)));
+
+    // A click filters by month, and the selection survives a save.
+    s.execute("slicer.toggle", json!({"slicer": first_slicer(&s), "value": "Mar", "multi": true})).unwrap();
+    assert_eq!(sum_of(&s, "East"), Some(Value::Number(220.0)));
+    let bytes = save(&s);
+    reopen(&mut s, &bytes);
+    assert_eq!(slicer_tiles(&s, first_slicer(&s)), months_on(&["Jan", "Feb", "Mar"]));
+    assert_eq!(sum_of(&s, "Grand Total"), Some(Value::Number(270.0)));
+    // Selecting everything keeps the months.
+    s.execute("slicer.selectAll", json!({"slicer": first_slicer(&s)})).unwrap();
+    assert_eq!(slicer_tiles(&s, first_slicer(&s)), months_on(&MONTHS));
+    assert_eq!(sum_of(&s, "Grand Total"), Some(Value::Number(TOTAL)));
+    let bytes = save(&s);
+    reopen(&mut s, &bytes);
+    assert_eq!(slicer_tiles(&s, first_slicer(&s)), months_on(&MONTHS));
+}
+
+/// With Date on Rows by quarters then months, the slicer lists the base cache field's months
+/// (as Excel's does), a click filters by month, and it's saved the same way in the slicer
+/// cache and the PivotTable.
+#[test]
+fn pivot_slicer_on_multi_level_dates_lists_the_base_level() {
+    let mut s = sales();
+    s.execute("insert.pivotTable", json!({})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Date", "area": "rows"})).unwrap();
+    s.execute("pivot.addField", json!({"field": "Sales", "area": "values"})).unwrap();
+    s.execute("pivot.group", json!({"field": "Date", "by": "quarters"})).unwrap();
+    {
+        let d = s.doc_mut().unwrap();
+        let si = d.wb.active_sheet();
+        let p = std::sync::Arc::make_mut(&mut d.wb).sheet_mut(si).unwrap().pivots.last_mut().unwrap();
+        p.rows.push(gridcraft_model::PivotField {
+            source_col: "Date".into(),
+            date_group: gridcraft_model::PivotDateGroup::Months,
+            ..Default::default()
+        });
+    }
+    s.execute("pivot.refresh", json!({})).unwrap();
+    add_pivot_slicer(&mut s, 1, "Date", &["PivotTable1"]);
+    assert_eq!(slicer_tiles(&s, 1), months_on(&MONTHS));
+    s.execute("slicer.toggle", json!({"slicer": 1, "value": "Mar"})).unwrap();
+    assert_eq!(slicer_tiles(&s, 1), months_on(&["Mar"]));
+    assert_eq!(sum_of(&s, "Qtr1"), Some(Value::Number(120.0)));
+    assert_eq!(sum_of(&s, "Mar"), Some(Value::Number(120.0)));
+    assert_eq!(sum_of(&s, "Qtr2"), None);
+    assert_eq!(sum_of(&s, "Grand Total"), Some(Value::Number(120.0)));
+
+    // The slicer cache selects the base field's Mar item (after `<1/1/2026` and Jan, Feb).
+    let bytes = save(&s);
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+    let mut cache = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("xl/slicerCaches/slicerCache1.xml").unwrap(), &mut cache).unwrap();
+    assert!(cache.contains("<i x=\"3\" s=\"1\"/>") && cache.matches("s=\"1\"").count() == 1, "{cache}");
+    reopen(&mut s, &bytes);
+    assert_eq!(slicer_tiles(&s, first_slicer(&s)), months_on(&["Mar"]));
+    assert_eq!(sum_of(&s, "Grand Total"), Some(Value::Number(120.0)));
+}
 #[test]
 fn inserting_or_deleting_lines_moves_the_pivot_with_its_cells() {
     let mut s = sales();
diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs
index 13956e35ce..388f5faa7c 100644
--- a/crates/engine/src/cmd/sheet/tabs.rs
+++ b/crates/engine/src/cmd/sheet/tabs.rs
@@ -134,6 +134,14 @@ pub(super) fn rename_sheet(s: &mut Session, p: &Json) -> Result<Json> {
                     ch.pivot = Some(crate::pivot::chart_link(&name, &pivot));
                 }
             }
+            // So does a slicer.
+            for sl in sh.slicers.iter_mut() {
+                if let gridcraft_model::SlicerSource::Pivot { pivots, .. } = &mut sl.source {
+                    for p in pivots.iter_mut().filter(|p| p.sheet.eq_ignore_ascii_case(&old)) {
+                        p.sheet = name.clone();
+                    }
+                }
+            }
         }
         for n in cx.wb.names.iter_mut() {
             if let Ok(e) = gridcraft_formula::parse_name(&n.formula) {
diff --git a/crates/engine/src/cmd/slicer.rs b/crates/engine/src/cmd/slicer.rs
index bd961c9d53..47ac6fbde6 100644
--- a/crates/engine/src/cmd/slicer.rs
+++ b/crates/engine/src/cmd/slicer.rs
@@ -1,12 +1,16 @@
-//! Slicers: on-sheet widgets that filter one column of a table by clicking value tiles.
+//! Slicers: on-sheet widgets that filter a table column or a PivotTable field by clicking value
+//! tiles.
 //!
-//! A slicer is a thin front-end over the existing filter machinery: its selection is written as a
-//! [`FilterCriterion::Values`] into the sheet's [`AutoFilter`] (over the table's range) and
-//! [`super::data::apply_filter`] hides the rows. Creating a slicer (`insert.slicer` /
-//! `table.insertSlicer`) selects everything, i.e. applies no filter.
+//! A slicer is a thin front-end over the existing filter machinery. A table slicer's selection is
+//! written as a [`FilterCriterion::Values`] into the sheet's [`AutoFilter`] (over the table's
+//! range) and [`super::data::apply_filter`] hides the rows. A PivotTable slicer's selection is each
+//! connected PivotTable's [`PivotFilter`] on the field, and the PivotTables are refreshed. Creating
+//! a slicer (`insert.slicer` / `table.insertSlicer`) selects everything, i.e. applies no filter.
 
 use gridcraft_core::CellRef;
-use gridcraft_model::{Anchor, AnchorMode, AutoFilter, FilterCriterion, Slicer, Workbook};
+use gridcraft_model::{Anchor, AnchorMode, AutoFilter, FilterCriterion, Slicer, SlicerPivot, SlicerSource, Workbook};
+
+use crate::pivot::{self as pv, SlicerTile};
 use serde_json::{Value as Json, json};
 
 use super::{
@@ -62,28 +66,82 @@ pub fn column_values(wb: &Workbook, sheet: usize, table: &str, column: &str) ->
     out
 }
 
-/// A slicer's tiles as `(value, selected)`, for the UI. `selected` is true for every tile when the
-/// slicer has no filter (`selected == None`).
-pub fn slicer_items(wb: &Workbook, sheet: usize, sl: &Slicer) -> Vec<(String, bool)> {
-    column_values(wb, sheet, &sl.table, &sl.column)
-        .into_iter()
-        .map(|v| {
-            let on = match &sl.selected {
-                None => true,
-                Some(set) => set.iter().any(|x| x.eq_ignore_ascii_case(&v)),
-            };
-            (v, on)
+/// A slicer's tiles, for the UI. Every tile is selected when the slicer has no filter.
+pub fn slicer_items(wb: &Workbook, sheet: usize, sl: &Slicer) -> Vec<SlicerTile> {
+    match &sl.source {
+        SlicerSource::Table { table, column, selected } => column_values(wb, sheet, table, column)
+            .into_iter()
+            .map(|v| {
+                let on = match selected {
+                    None => true,
+                    Some(set) => set.iter().any(|x| x.eq_ignore_ascii_case(&v)),
+                };
+                SlicerTile { key: v.clone(), label: v, selected: on, has_data: true }
+            })
+            .collect(),
+        SlicerSource::Pivot { pivots, field, sort, cross_filter, .. } => {
+            let Some((si, pi)) = slicer_pivots(wb, pivots).into_iter().next() else { return vec![] };
+            let Some(pt) = wb.sheet(si).and_then(|sh| sh.pivots.get(pi)) else { return vec![] };
+            pv::slicer_tiles(wb, pt, si, field, *sort, *cross_filter)
+        }
+    }
+}
+
+/// The connected PivotTables that exist, as (sheet, index).
+pub fn slicer_pivots(wb: &Workbook, pivots: &[SlicerPivot]) -> Vec<(usize, usize)> {
+    pivots
+        .iter()
+        .filter_map(|p| {
+            let si = wb.sheet_index(&p.sheet)?;
+            let pi = wb.sheet(si)?.pivots.iter().position(|t| t.name.eq_ignore_ascii_case(&p.name))?;
+            Some((si, pi))
         })
         .collect()
 }
 
+/// Sets `field`'s item selection (`None`: everything) on each PivotTable and refreshes them. A field
+/// outside Rows and Columns gets a hidden filter (no report filter cell), as an Excel slicer does.
+/// The labels are in the grouping of the field's base cache field, as the tiles are.
+fn set_pivot_selection(wb: &mut Workbook, pivots: &[(usize, usize)], field: &str, selected: Option<Vec<String>>) -> Result<()> {
+    for &(si, pi) in pivots {
+        let Some(pt) = wb.sheet_mut(si).and_then(|sh| sh.pivots.get_mut(pi)) else { continue };
+        let group = pt.field_group(field);
+        pt.set_filter(field, selected.clone(), group);
+        pv::refresh(wb, si, pi, false).map_err(EngineError::Other)?;
+    }
+    Ok(())
+}
+
+/// The selection after clicking `value` among `all`: a single click shows only that value (or,
+/// on the sole selected value, clears the filter); `multi` toggles it, except that the last
+/// selected value stays selected, as in Excel. Everything selected is the same as no filter.
+fn next_selection(current: Option<Vec<String>>, all: &[String], value: &str, multi: bool) -> Option<Vec<String>> {
+    if multi {
+        let mut set: Vec<String> = current.unwrap_or_else(|| all.to_vec());
+        match set.iter().position(|x| x.eq_ignore_ascii_case(value)) {
+            Some(pos) if set.len() > 1 => {
+                set.remove(pos);
+            }
+            Some(_) => {}
+            None => set.push(value.to_string()),
+        }
+        if set.len() == all.len() && all.iter().all(|a| set.iter().any(|x| x.eq_ignore_ascii_case(a))) { None } else { Some(set) }
+    } else {
+        match &current {
+            Some(set) if set.len() == 1 && set.iter().any(|x| x.eq_ignore_ascii_case(value)) => None,
+            _ => Some(vec![value.to_string()]),
+        }
+    }
+}
+
 /// Writes the slicer's current selection into the sheet filter and re-applies it.
 fn reapply_slicer(wb: &mut Workbook, sheet: usize, id: u32) {
     let info = wb.sheet(sheet).and_then(|sh| {
         let sl = sh.slicers.iter().find(|s| s.id == id)?;
-        let t = sh.tables.iter().find(|t| t.name.eq_ignore_ascii_case(&sl.table))?;
-        let ci = t.column_index(&sl.column)?;
-        Some((t.range, t.range.start.col + ci as u32, sl.selected.clone()))
+        let SlicerSource::Table { table, column, selected } = &sl.source else { return None };
+        let t = sh.tables.iter().find(|t| t.name.eq_ignore_ascii_case(table))?;
+        let ci = t.column_index(column)?;
+        Some((t.range, t.range.start.col + ci as u32, selected.clone()))
     });
     let Some((table_range, abs_col, selected)) = info else { return };
     {
@@ -139,12 +197,13 @@ fn insert_slicer(s: &mut Session, p: &Json) -> Result<Json> {
     let id = d.wb.next_object_id();
     let slicer = Slicer {
         id,
-        table,
-        column: column.clone(),
+        source: SlicerSource::Table { table, column: column.clone(), selected: None },
         caption: column,
         anchor: Anchor { cell: at, dx: 4.0, dy: 4.0, width, height, mode: AnchorMode::MoveOnly },
-        selected: None,
         columns,
+        name: String::new(),
+        style: String::new(),
+        row_height: None,
     };
     edit(s, |cx| {
         cx.sheet_mut(sheet)?.slicers.push(slicer);
@@ -168,37 +227,32 @@ fn slicer_toggle(s: &mut Session, p: &Json) -> Result<Json> {
     let value = str_param(p, "value").ok_or_else(|| bad("slicer.toggle", "missing `value`"))?.to_string();
     let multi = bool_param(p, "multi").unwrap_or(false);
     let sheet = s.doc()?.wb.active_sheet();
-    let (table, column, current) = {
+    let (new_selected, pivot) = {
         let d = s.doc()?;
         let sl = d.wb.active().and_then(|sh| sh.slicers.get(idx)).ok_or_else(|| bad("slicer.toggle", "no slicer"))?;
-        (sl.table.clone(), sl.column.clone(), sl.selected.clone())
-    };
-    let all = column_values(&s.doc()?.wb, sheet, &table, &column);
-    if !all.iter().any(|v| v.eq_ignore_ascii_case(&value)) {
-        return Err(bad("slicer.toggle", "value is not in the column"));
-    }
-    let new_selected: Option<Vec<String>> = if multi {
-        let mut set: Vec<String> = current.unwrap_or_else(|| all.clone());
-        match set.iter().position(|x| x.eq_ignore_ascii_case(&value)) {
-            Some(pos) => {
-                set.remove(pos);
-            }
-            None => set.push(value.clone()),
-        }
-        // Everything selected is the same as no filter.
-        if set.len() == all.len() && all.iter().all(|a| set.iter().any(|x| x.eq_ignore_ascii_case(a))) { None } else { Some(set) }
-    } else {
-        // Single click: show only this value; clicking the sole selected value clears the filter.
-        match &current {
-            Some(set) if set.len() == 1 && set.iter().any(|x| x.eq_ignore_ascii_case(&value)) => None,
-            _ => Some(vec![value.clone()]),
-        }
+        let tiles = slicer_items(&d.wb, sheet, sl);
+        let Some(tile) = tiles.iter().find(|t| t.label.eq_ignore_ascii_case(&value) || t.key.eq_ignore_ascii_case(&value)) else {
+            return Err(bad("slicer.toggle", "value is not one of the slicer's items"));
+        };
+        let all: Vec<String> = tiles.iter().map(|t| t.key.clone()).collect();
+        let current = (!tiles.iter().all(|t| t.selected)).then(|| tiles.iter().filter(|t| t.selected).map(|t| t.key.clone()).collect());
+        let new_selected = next_selection(current, &all, &tile.key, multi);
+        let pivot = match &sl.source {
+            SlicerSource::Pivot { pivots, field, .. } => Some((slicer_pivots(&d.wb, pivots), field.clone())),
+            SlicerSource::Table { .. } => None,
+        };
+        (new_selected, pivot)
     };
     edit(s, |cx| {
-        if let Some(sl) = cx.sheet_mut(sheet)?.slicers.get_mut(idx) {
-            sl.selected = new_selected;
+        match &pivot {
+            Some((targets, field)) => set_pivot_selection(&mut cx.wb, targets, field, new_selected)?,
+            None => {
+                if let Some(SlicerSource::Table { selected, .. }) = cx.sheet_mut(sheet)?.slicers.get_mut(idx).map(|sl| &mut sl.source) {
+                    *selected = new_selected;
+                }
+                reapply_slicer(&mut cx.wb, sheet, id);
+            }
         }
-        reapply_slicer(&mut cx.wb, sheet, id);
         cx.structural = true;
         Ok(Json::Null)
     })
@@ -207,36 +261,69 @@ fn slicer_toggle(s: &mut Session, p: &Json) -> Result<Json> {
 fn slicer_select_all(s: &mut Session, p: &Json) -> Result<Json> {
     let (idx, id) = find_slicer(s, p)?;
     let sheet = s.doc()?.wb.active_sheet();
+    let d = s.doc()?;
+    let pivot = d.wb.active().and_then(|sh| sh.slicers.get(idx)).and_then(|sl| match &sl.source {
+        SlicerSource::Pivot { pivots, field, .. } => Some((slicer_pivots(&d.wb, pivots), field.clone())),
+        SlicerSource::Table { .. } => None,
+    });
     edit(s, |cx| {
-        if let Some(sl) = cx.sheet_mut(sheet)?.slicers.get_mut(idx) {
-            sl.selected = None;
+        match &pivot {
+            Some((targets, field)) => set_pivot_selection(&mut cx.wb, targets, field, None)?,
+            None => {
+                if let Some(SlicerSource::Table { selected, .. }) = cx.sheet_mut(sheet)?.slicers.get_mut(idx).map(|sl| &mut sl.source) {
+                    *selected = None;
+                }
+                reapply_slicer(&mut cx.wb, sheet, id);
+            }
         }
-        reapply_slicer(&mut cx.wb, sheet, id);
         cx.structural = true;
         Ok(Json::Null)
     })
 }
 
+/// Deletes a slicer. A table slicer's filter is cleared; a PivotTable slicer leaves its
+/// PivotTables filtered, as Excel does.
 fn slicer_delete(s: &mut Session, p: &Json) -> Result<Json> {
     let (idx, id) = find_slicer(s, p)?;
     let sheet = s.doc()?.wb.active_sheet();
-    // Absolute column of the slicer, so its filter criterion can be removed too.
+    // Absolute column of a table slicer, so its filter criterion can be removed too.
     let abs_col = s.doc().ok().and_then(|d| {
         let sh = d.wb.active()?;
-        let sl = sh.slicers.get(idx)?;
-        let t = sh.tables.iter().find(|t| t.name.eq_ignore_ascii_case(&sl.table))?;
-        let ci = t.column_index(&sl.column)?;
+        let SlicerSource::Table { table, column, .. } = &sh.slicers.get(idx)?.source else { return None };
+        let t = sh.tables.iter().find(|t| t.name.eq_ignore_ascii_case(table))?;
+        let ci = t.column_index(column)?;
         Some(t.range.start.col + ci as u32)
     });
     edit(s, |cx| {
         let sh = cx.sheet_mut(sheet)?;
         sh.slicers.retain(|x| x.id != id);
-        if let (Some(abs), Some(af)) = (abs_col, sh.autofilter.as_mut()) {
-            let off = abs.saturating_sub(af.range.start.col);
-            af.criteria.retain(|(o, _)| *o != off);
+        if let Some(abs) = abs_col {
+            if let Some(af) = sh.autofilter.as_mut() {
+                let off = abs.saturating_sub(af.range.start.col);
+                af.criteria.retain(|(o, _)| *o != off);
+            }
+            super::data::apply_filter(&mut cx.wb, sheet);
         }
-        super::data::apply_filter(&mut cx.wb, sheet);
         cx.structural = true;
         Ok(Json::Null)
     })
 }
+
+/// Disconnects the PivotTable `name` on sheet `sheet` from its slicers; slicers left with no
+/// PivotTable are deleted (used when the PivotTable is deleted).
+pub(crate) fn drop_pivot(wb: &mut Workbook, sheet: &str, name: &str) {
+    let linked = |p: &SlicerPivot| p.sheet.eq_ignore_ascii_case(sheet) && p.name.eq_ignore_ascii_case(name);
+    let links = |sl: &Slicer| matches!(&sl.source, SlicerSource::Pivot { pivots, .. } if pivots.iter().any(linked));
+    for i in 0..wb.sheets.len() {
+        if !wb.sheet(i).is_some_and(|sh| sh.slicers.iter().any(links)) {
+            continue;
+        }
+        let Some(sh) = wb.sheet_mut(i) else { continue };
+        for sl in sh.slicers.iter_mut() {
+            if let SlicerSource::Pivot { pivots, .. } = &mut sl.source {
+                pivots.retain(|p| !linked(p));
+            }
+        }
+        sh.slicers.retain(|sl| !matches!(&sl.source, SlicerSource::Pivot { pivots, .. } if pivots.is_empty()));
+    }
+}
diff --git a/crates/engine/src/pivot.rs b/crates/engine/src/pivot.rs
index fb72492d5a..bd970bcf85 100644
--- a/crates/engine/src/pivot.rs
+++ b/crates/engine/src/pivot.rs
@@ -13,7 +13,7 @@ pub use gridcraft_core::quote_sheet;
 use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, split_sheet};
 use gridcraft_model::{
     BorderLine, BorderStyle, Cell, Chart, Color, Fill, HAlign, NumFmt, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotLayout, PivotShowAs,
-    PivotSort, PivotTable, PivotValue, Series, Style, StyleId, Workbook,
+    PivotSort, PivotTable, PivotValue, Series, SlicerCrossFilter, Style, StyleId, Workbook,
 };
 
 use crate::pivot_calc::CalcSet;
@@ -27,12 +27,11 @@ use charts::rebind_charts;
 pub use charts::{chart_link, chart_series, clear_output, links_to, parse_chart_link};
 use compute::compute_from;
 pub use compute::{NOT_A_VALUE_CELL, detail_cells, detail_records};
-pub use items::{distinct_labels, func_caption, item_label};
+pub use items::{SlicerTile, distinct_labels, func_caption, item_label, slicer_tiles};
 #[cfg(test)]
 use output::data_cols_exceed_sheet;
 pub use output::{CellKind, OutCell, Output, RowKind};
 use output::{cell_style, look};
-
 /// Largest source block read (cells).
 pub const MAX_SOURCE_CELLS: u64 = 10_000_000;
 /// Largest report written (cells).
diff --git a/crates/engine/src/pivot/compute.rs b/crates/engine/src/pivot/compute.rs
index 9ebf447376..96b49b4d9e 100644
--- a/crates/engine/src/pivot/compute.rs
+++ b/crates/engine/src/pivot/compute.rs
@@ -1,4 +1,4 @@
-use super::items::{Acc, FieldItems, build_tree, collect_siblings, is_collapsed, item_label};
+use super::items::{Acc, FieldItems, build_tree, collect_siblings, is_collapsed, item_label, selects};
 use super::output::{AggMap, CellKind, ColKind, ColSpec, Ctx, Grid, Line, LineKind, Output, RowKind, ValSrc, data_cols_exceed_sheet, flatten_cols};
 use super::{
     CalcSet, CellError, CellRef, HashMap, HashSet, MAX_AXIS_FIELDS, MAX_COLS, MAX_VALUE_FIELDS, PivotDateGroup, PivotField, PivotFilter, PivotFunc,
@@ -101,8 +101,8 @@ fn aggregate_record(
 ) -> Result<(), String> {
     for ((c, field, group, _), fmt) in input.filters.iter().zip(input.filter_fmts) {
         if let Some(selected) = &field.selected {
-            let label = item_label(input.wb, rec.get(*c).unwrap_or(&Value::Empty), *group, fmt);
-            if !selected.iter().any(|value| value.eq_ignore_ascii_case(&label)) {
+            let value = rec.get(*c).unwrap_or(&Value::Empty);
+            if !selects(selected, value, &item_label(input.wb, value, *group, fmt), *group) {
                 return Ok(());
             }
         }
@@ -380,15 +380,14 @@ fn show_value(definition: &PivotValue, raw: Value, lookup: &ValueLookup<'_>, con
 type ReportFilter<'a> = (usize, &'a PivotFilter, PivotDateGroup, bool);
 
 fn report_filters<'a>(pt: &'a PivotTable, src: &Source) -> (Vec<ReportFilter<'a>>, Vec<ReportFilter<'a>>) {
-    let axis_group =
-        |name: &str| pt.rows.iter().chain(pt.columns.iter()).find(|field| field.source_col.eq_ignore_ascii_case(name)).map(|field| field.date_group);
+    let on_axis = |name: &str| pt.rows.iter().chain(pt.columns.iter()).any(|f| f.source_col.eq_ignore_ascii_case(name));
     let filters: Vec<_> = pt
         .filters
         .iter()
         .filter_map(|filter| {
             let column = src.col(&filter.source_col)?;
-            let group = axis_group(&filter.source_col);
-            Some((column, filter, group.unwrap_or_default(), group.is_none()))
+            let group = pt.filter_group(filter);
+            Some((column, filter, group, !on_axis(&filter.source_col) && !filter.hidden))
         })
         .collect();
     let shown = filters.iter().copied().filter(|filter| filter.3).collect();
diff --git a/crates/engine/src/pivot/items.rs b/crates/engine/src/pivot/items.rs
index 1a39c59d97..621a96ad5b 100644
--- a/crates/engine/src/pivot/items.rs
+++ b/crates/engine/src/pivot/items.rs
@@ -1,4 +1,7 @@
-use super::{CellError, HashMap, MONTHS, Ordering, PivotDateGroup, PivotField, PivotFunc, PivotSort, Source, Value, Workbook, datetime_from_serial};
+use super::{
+    CellError, HashMap, MONTHS, Ordering, PivotDateGroup, PivotField, PivotFilter, PivotFunc, PivotSort, PivotTable, SlicerCrossFilter, Source,
+    Value, Workbook, datetime_from_serial, read_source,
+};
 
 // ---------------------------------------------------------------- items
 
@@ -107,6 +110,90 @@ pub fn distinct_labels(wb: &Workbook, src: &Source, col: usize, group: PivotDate
     items.into_iter().take(limit).map(|i| i.label).collect()
 }
 
+/// Whether a filter's selected labels take in a source value: by its label, or (outside a date
+/// grouping) a number by its plain number text, which is how files name number and date items.
+pub(super) fn selects(sel: &[String], v: &Value, label: &str, group: PivotDateGroup) -> bool {
+    if sel.iter().any(|s| s.eq_ignore_ascii_case(label)) {
+        return true;
+    }
+    match v.scalar() {
+        Value::Number(n) if group == PivotDateGroup::None => sel.contains(&gridcraft_core::number_to_text(n)),
+        _ => false,
+    }
+}
+
+/// A slicer tile: one item of a PivotTable field.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SlicerTile {
+    /// The item as shown (numbers and dates in the source format).
+    pub label: String,
+    /// The label a [`PivotFilter`] selects the item by: the plain number text for numbers (as
+    /// files store them), else the label.
+    pub key: String,
+    pub selected: bool,
+    /// Some source row with this item passes the PivotTable's other filters.
+    pub has_data: bool,
+}
+
+/// The items of `field` in `pt`'s source as slicer tiles: selection from the PivotTable's filter
+/// on the field, in `sort` order (`None`: source order), and with `cross` the items without data
+/// last or marked as Excel does. A date-grouped field's tiles are the groups of its base cache
+/// field (`Jan`…, the finest level), which is what Excel's slicer lists. A filter on another
+/// level of the field filters like another field's.
+pub fn slicer_tiles(wb: &Workbook, pt: &PivotTable, sheet: usize, field: &str, sort: PivotSort, cross: SlicerCrossFilter) -> Vec<SlicerTile> {
+    let Ok(src) = read_source(wb, &pt.source, sheet) else { return vec![] };
+    let Some(col) = src.col(field) else { return vec![] };
+    let fmt_of = |c: usize| src.formats.get(c).map(String::as_str).unwrap_or("General");
+    let group = pt.field_group(field);
+    let own_level = |f: &PivotFilter| f.source_col.eq_ignore_ascii_case(field) && pt.filter_group(f) == group;
+    let own = pt.filters.iter().find(|f| own_level(f)).and_then(|f| f.selected.as_deref());
+    let others: Vec<(usize, &[String], PivotDateGroup)> = pt
+        .filters
+        .iter()
+        .filter(|f| !own_level(f))
+        .filter_map(|f| Some((src.col(&f.source_col)?, f.selected.as_deref()?, pt.filter_group(f))))
+        .collect();
+    let mut fi = FieldItems::default();
+    let mut data: Vec<bool> = Vec::new();
+    for (i, r) in src.rows.iter().enumerate() {
+        let k = fi.intern(wb, r.get(col).unwrap_or(&Value::Empty), group, fmt_of(col), i) as usize;
+        if data.len() <= k {
+            data.resize(k + 1, false);
+        }
+        if !data[k]
+            && others.iter().all(|(c, sel, g)| {
+                let v = r.get(*c).unwrap_or(&Value::Empty);
+                selects(sel, v, &item_label(wb, v, *g, fmt_of(*c)), *g)
+            })
+        {
+            data[k] = true;
+        }
+        if fi.items.len() > 100_000 {
+            break;
+        }
+    }
+    let mut items: Vec<(Item, bool)> = fi.items.into_iter().zip(data).collect();
+    match sort {
+        PivotSort::Asc => items.sort_by(|a, b| cmp_items(&a.0, &b.0)),
+        PivotSort::Desc => items.sort_by(|a, b| cmp_items(&b.0, &a.0)),
+        PivotSort::None => {}
+    }
+    if cross == SlicerCrossFilter::ShowItemsWithDataAtTop {
+        items.sort_by_key(|(_, d)| !*d);
+    }
+    items
+        .into_iter()
+        .map(|(it, has_data)| {
+            let key = match &it.value {
+                Value::Number(n) => gridcraft_core::number_to_text(*n),
+                _ => it.label.clone(),
+            };
+            let selected = own.is_none_or(|sel| selects(sel, &it.value, &it.label, group));
+            SlicerTile { label: it.label, key, selected, has_data: has_data || cross == SlicerCrossFilter::None }
+        })
+        .collect()
+}
+
 // ---------------------------------------------------------------- aggregation
 
 #[derive(Clone, Debug, Default)]
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index f99f246df3..1376345f7d 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -1902,7 +1902,7 @@ fn slicer_filters_table() {
         let d = s.doc().unwrap();
         let sh = d.wb.active().unwrap();
         assert_eq!(sh.slicers.len(), 1);
-        assert_eq!(sh.slicers[0].column, "Region");
+        assert_eq!(sh.slicers[0].field(), "Region");
     }
 
     // Single-click "East": only the two East rows remain (West row 2 and North row 4 hidden).
@@ -1922,7 +1922,7 @@ fn slicer_filters_table() {
     // Clear restores everything.
     s.execute("slicer.clear", json!({"slicer": id})).unwrap();
     assert_eq!(hidden(&s), 0);
-    assert!(s.doc().unwrap().wb.active().unwrap().slicers[0].selected.is_none());
+    assert!(matches!(&s.doc().unwrap().wb.active().unwrap().slicers[0].source, gridcraft_model::SlicerSource::Table { selected: None, .. }));
 
     // Deleting the slicer drops it and clears its filter.
     s.execute("slicer.toggle", json!({"slicer": id, "value": "East"})).unwrap();
diff --git a/crates/model/src/features.rs b/crates/model/src/features.rs
index 2394319c33..8505863ebb 100644
--- a/crates/model/src/features.rs
+++ b/crates/model/src/features.rs
@@ -702,24 +702,99 @@ pub struct AutoFilter {
     pub criteria: Vec<(u32, FilterCriterion)>,
 }
 
-/// A slicer: an on-sheet filter widget bound to one column of a table. Clicking its value tiles
-/// sets that column's `FilterCriterion::Values` in the sheet's [`AutoFilter`] and re-applies it,
-/// so a slicer is just a visual front-end over the existing filter machinery.
+/// A slicer: an on-sheet filter widget whose value tiles drive an existing filter, so a slicer is
+/// just a visual front-end over the filter machinery (see [`SlicerSource`]).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Slicer {
     pub id: u32,
-    /// Name of the table this slicer filters.
-    pub table: String,
-    /// Header name of the filtered column within the table.
-    pub column: String,
-    /// Caption shown in the slicer header (defaults to the column name).
+    /// What the slicer filters, and where its selection lives.
+    #[serde(flatten)]
+    pub source: SlicerSource,
+    /// Caption shown in the slicer header (defaults to the column or field name).
     pub caption: String,
     pub anchor: Anchor,
-    /// Selected display values. `None` means every value (no filter from this slicer); an empty
-    /// list means nothing is selected (all rows hidden), matching Excel's "clear all buttons".
-    pub selected: Option<Vec<String>>,
     /// Number of button columns in the layout (Excel default 1).
     pub columns: u32,
+    /// The slicer's name (unique in a workbook; Excel's Slicer Settings "Name"). Empty: derived
+    /// from the caption when saved.
+    #[serde(default)]
+    pub name: String,
+    /// Slicer style name (`SlicerStyleLight1`…). Empty: the default style.
+    #[serde(default)]
+    pub style: String,
+    /// Button height in pixels; `None` uses the default.
+    #[serde(default)]
+    pub row_height: Option<f32>,
+}
+
+impl Slicer {
+    /// The column or field the slicer filters.
+    pub fn field(&self) -> &str {
+        match &self.source {
+            SlicerSource::Table { column, .. } => column,
+            SlicerSource::Pivot { field, .. } => field,
+        }
+    }
+}
+
+/// What a slicer filters.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum SlicerSource {
+    /// One column of a table: the selection is written as that column's
+    /// `FilterCriterion::Values` in the sheet's [`AutoFilter`] and re-applied.
+    Table {
+        /// Name of the table.
+        table: String,
+        /// Header name of the filtered column within the table.
+        column: String,
+        /// Selected display values. `None` means every value (no filter from this slicer); an
+        /// empty list means nothing is selected (all rows hidden), matching Excel's "clear all
+        /// buttons".
+        selected: Option<Vec<String>>,
+    },
+    /// One field of one or more PivotTables built from the same source. The selection is not
+    /// stored here: it is each PivotTable's [`PivotFilter`] on the field (its hidden items), so the
+    /// slicer and the PivotTables always agree.
+    Pivot {
+        /// The PivotTables it filters.
+        pivots: Vec<SlicerPivot>,
+        /// Source field (column header) name.
+        field: String,
+        /// Tile order: ascending, descending, or data source order (`PivotSort::None`).
+        #[serde(default)]
+        sort: PivotSort,
+        #[serde(default)]
+        cross_filter: SlicerCrossFilter,
+        /// Whether items no longer in the source are shown (Excel's "Show items deleted from the
+        /// data source"; kept for the file).
+        #[serde(default = "default_true")]
+        show_missing: bool,
+    },
+}
+
+fn default_true() -> bool {
+    true
+}
+
+/// A PivotTable a slicer filters: its sheet and name.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SlicerPivot {
+    pub sheet: String,
+    pub name: String,
+}
+
+/// How a slicer shows items that have no data under its PivotTables' other filters (Excel's
+/// "Visually indicate items with no data" options).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SlicerCrossFilter {
+    /// Items with no data aren't marked.
+    None,
+    /// Items with data first (the default).
+    #[default]
+    ShowItemsWithDataAtTop,
+    /// Items with no data stay in their place.
+    ShowItemsWithNoData,
 }
 
 #[cfg(test)]
diff --git a/crates/model/src/features/pivot.rs b/crates/model/src/features/pivot.rs
index b34015f4cd..dabaf63072 100644
--- a/crates/model/src/features/pivot.rs
+++ b/crates/model/src/features/pivot.rs
@@ -35,6 +35,19 @@ pub enum PivotDateGroup {
     Days,
 }
 
+impl PivotDateGroup {
+    /// Finest first: days, months, quarters, years, then ungrouped.
+    pub fn coarseness(self) -> u8 {
+        match self {
+            PivotDateGroup::Days => 0,
+            PivotDateGroup::Months => 1,
+            PivotDateGroup::Quarters => 2,
+            PivotDateGroup::Years => 3,
+            PivotDateGroup::None => 4,
+        }
+    }
+}
+
 /// A field placed in the Rows or Columns area.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
@@ -97,6 +110,15 @@ pub struct PivotFilter {
     pub source_col: String,
     /// Item labels shown; `None` = all.
     pub selected: Option<Vec<String>>,
+    /// For a field outside Rows and Columns: it filters the PivotTable without being a report
+    /// filter (no filter cell above the table). Set by a slicer on a field the PivotTable doesn't
+    /// show, and read from files as hidden items of such a field.
+    pub hidden: bool,
+    /// The date grouping `selected` is in, when it isn't the first Rows/Columns field's on the
+    /// column (`None`): a field in no area keeps its cache field's grouping here (ECMA-376 puts
+    /// `fieldGroup` on the cache field), and on a field grouped at several levels it names the
+    /// level filtered. See [`PivotTable::filter_group`].
+    pub date_group: PivotDateGroup,
 }
 
 /// A PivotTable: its definition plus where its output was last written. The output itself is
@@ -149,6 +171,74 @@ pub struct PivotCalcField {
     pub formula: String,
 }
 
+impl PivotTable {
+    fn axis(&self) -> impl Iterator<Item = &PivotField> {
+        self.rows.iter().chain(self.columns.iter())
+    }
+
+    /// The grouping a filter on `col` gets when it names none: the first Rows/Columns field's.
+    pub fn implied_group(&self, col: &str) -> PivotDateGroup {
+        self.axis().find(|f| f.source_col.eq_ignore_ascii_case(col)).map(|f| f.date_group).unwrap_or_default()
+    }
+
+    /// The date grouping a filter's labels are in.
+    pub fn filter_group(&self, f: &PivotFilter) -> PivotDateGroup {
+        if f.date_group == PivotDateGroup::None { self.implied_group(&f.source_col) } else { f.date_group }
+    }
+
+    /// Clears each filter's `date_group` where the first Rows/Columns field implies it, so one
+    /// filter has one representation.
+    pub fn normalize_filter_groups(&mut self) {
+        let implied: Vec<PivotDateGroup> = self.filters.iter().map(|f| self.implied_group(&f.source_col)).collect();
+        for (f, g) in self.filters.iter_mut().zip(implied) {
+            if f.date_group == g {
+                f.date_group = PivotDateGroup::None;
+            }
+        }
+    }
+
+    /// The grouping of `col`'s base cache field: the finest of its Rows/Columns fields' and its
+    /// filter's, as a cache groups the base field by the finest level. A slicer on `col` lists
+    /// these items.
+    pub fn field_group(&self, col: &str) -> PivotDateGroup {
+        let filter = self.filters.iter().filter(|f| f.source_col.eq_ignore_ascii_case(col)).map(|f| self.filter_group(f));
+        let axis = self.axis().filter(|f| f.source_col.eq_ignore_ascii_case(col)).map(|f| f.date_group);
+        axis.chain(filter).min_by_key(|g| g.coarseness()).unwrap_or_default()
+    }
+
+    /// Sets the filter on `col` to `selected` (`None`: everything) with its labels in `group`,
+    /// adding a hidden filter for a field in no area. Clearing a filter removes it, except a
+    /// report filter and a filter that holds the field's grouping (none of its Rows/Columns
+    /// fields has it), which keep `selected: None`.
+    pub fn set_filter(&mut self, col: &str, selected: Option<Vec<String>>, group: PivotDateGroup) {
+        let on_axis = self.axis().any(|f| f.source_col.eq_ignore_ascii_case(col));
+        let date_group = if group == self.implied_group(col) { PivotDateGroup::None } else { group };
+        let i = self.filters.iter().position(|f| f.source_col.eq_ignore_ascii_case(col));
+        match (i, selected) {
+            (Some(i), None) => {
+                let Some(f) = self.filters.get(i) else { return };
+                let grouping = f.date_group != PivotDateGroup::None
+                    && !self.axis().any(|a| a.source_col.eq_ignore_ascii_case(col) && a.date_group == f.date_group);
+                if grouping || !(on_axis || f.hidden) {
+                    if let Some(f) = self.filters.get_mut(i) {
+                        f.selected = None;
+                    }
+                } else {
+                    self.filters.remove(i);
+                }
+            }
+            (Some(i), Some(sel)) => {
+                if let Some(f) = self.filters.get_mut(i) {
+                    f.selected = Some(sel);
+                    f.date_group = date_group;
+                }
+            }
+            (None, Some(sel)) => self.filters.push(PivotFilter { source_col: col.to_string(), selected: Some(sel), hidden: !on_axis, date_group }),
+            (None, None) => {}
+        }
+    }
+}
+
 impl Default for PivotTable {
     fn default() -> Self {
         PivotTable {
diff --git a/crates/ui-egui/src/chartview.rs b/crates/ui-egui/src/chartview.rs
index 8adab4918c..05dcce9cbf 100644
--- a/crates/ui-egui/src/chartview.rs
+++ b/crates/ui-egui/src/chartview.rs
@@ -4,12 +4,29 @@
 use egui::epaint::{PathShape, PathStroke};
 use egui::{Align2, Color32, FontId, Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2};
 use gridcraft_chart::{HAlign, Prim, VAlign};
-use gridcraft_engine::model::{Anchor, ShapeKind, Sheet, Workbook};
+use gridcraft_engine::model::{Anchor, ShapeKind, Sheet, Slicer, Workbook};
+use std::collections::HashMap;
+use std::sync::{Arc, Weak};
 
 use crate::SheetApp;
 use crate::grid::Geo;
 use crate::theme::{self, Tokens};
 
+/// The slicer's tiles, computed once per workbook version. Every change to a document, undoable or
+/// not (recalculation, refresh), installs a new `Arc<Workbook>`; the cache holds a `Weak` to the one
+/// it was built from, so a new version is always told apart (the allocation, and so its address,
+/// stays reserved while the `Weak` lives) without a strong reference that would make the next edit's
+/// `Arc::make_mut` copy the whole workbook.
+fn cached_slicer_items<'a>(app: &'a mut SheetApp, wb: &Workbook, si: usize, sl: &Slicer) -> &'a [gridcraft_engine::pivot::SlicerTile] {
+    let cur = app.session.active().map(|d| Arc::downgrade(&d.wb));
+    let fresh = matches!((&app.grid.slicer_tiles, &cur), (Some((Some(built), _)), Some(cur)) if Weak::ptr_eq(built, cur));
+    if !fresh {
+        app.grid.slicer_tiles = None;
+    }
+    let (_, tiles) = app.grid.slicer_tiles.get_or_insert_with(|| (cur, HashMap::new()));
+    tiles.entry((si, sl.id)).or_insert_with(|| gridcraft_engine::cmd::slicer::slicer_items(wb, si, sl))
+}
+
 fn rgba(c: [u8; 4]) -> Color32 {
     Color32::from_rgba_unmultiplied(c[0], c[1], c[2], c[3])
 }
@@ -259,7 +276,7 @@ pub(crate) fn objects_hidden(wb: &Workbook) -> bool {
     wb.show_objects == gridcraft_engine::model::ShowObjects::None
 }
 
-pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) -> Vec<PaintedObject> {
+pub(crate) fn paint_objects(app: &mut SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) -> Vec<PaintedObject> {
     let mut painted = Vec::new();
     if objects_hidden(wb) {
         return painted;
@@ -397,11 +414,12 @@ pub struct SlicerLayout {
     pub tiles: Vec<Rect>,
 }
 
-pub fn slicer_layout(rect: Rect, z: f32, n: usize, columns: u32) -> SlicerLayout {
+/// `row_height`: the slicer's button height in pixels (`None`: the default).
+pub fn slicer_layout(rect: Rect, z: f32, n: usize, columns: u32, row_height: Option<f32>) -> SlicerLayout {
     let header_h = 26.0 * z;
     let pad = 6.0 * z;
     let gap = 3.0 * z;
-    let tile_h = 22.0 * z;
+    let tile_h = row_height.filter(|h| h.is_finite()).unwrap_or(22.0).clamp(8.0, 400.0) * z;
     let header = Rect::from_min_size(rect.min, vec2(rect.width(), header_h));
     let cb = 16.0 * z;
     let clear = Rect::from_min_size(pos2(header.right() - pad - cb, header.top() + (header_h - cb) / 2.0), vec2(cb, cb));
@@ -421,15 +439,15 @@ pub fn slicer_layout(rect: Rect, z: f32, n: usize, columns: u32) -> SlicerLayout
     SlicerLayout { header, clear, tiles }
 }
 
-fn paint_slicers(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) {
+fn paint_slicers(app: &mut SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) {
     let tk = theme::Tokens::get(p.ctx());
     for sl in &sh.slicers {
         let r = anchor_rect(geo, sh, &sl.anchor);
         if !r.intersects(p.clip_rect()) {
             continue;
         }
-        let items = gridcraft_engine::cmd::slicer::slicer_items(wb, si, sl);
-        let lay = slicer_layout(r, geo.z, items.len(), sl.columns);
+        let items = cached_slicer_items(app, wb, si, sl);
+        let lay = slicer_layout(r, geo.z, items.len(), sl.columns, sl.row_height);
         let radius = 4.0 * geo.z;
         // Card + soft shadow.
         p.rect_filled(r.translate(vec2(0.0, 1.5)), radius, Color32::from_black_alpha(18));
@@ -438,22 +456,28 @@ fn paint_slicers(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usiz
         // Header.
         p.rect_filled(lay.header, radius, tk.accent_soft);
         p.rect_filled(Rect::from_min_max(pos2(lay.header.left(), lay.header.bottom() - radius), lay.header.max), 0.0, tk.accent_soft);
-        let cap = if sl.caption.is_empty() { sl.column.clone() } else { sl.caption.clone() };
+        let cap = if sl.caption.is_empty() { sl.field().to_string() } else { sl.caption.clone() };
         p.text(lay.header.left_center() + vec2(8.0 * geo.z, 0.0), Align2::LEFT_CENTER, cap, theme::ui_bold(12.5 * geo.z), tk.accent_dark);
         // Clear-filter button (tinted when a filter is active).
-        let filtered = sl.selected.is_some();
+        let filtered = items.iter().any(|t| !t.selected);
         if let Some(icon) = crate::icons::from_name("filter") {
             crate::icons::paint(p, lay.clear, icon, if filtered { tk.accent } else { tk.text_dim });
         }
         // Value tiles.
-        for ((val, on), tr) in items.iter().zip(&lay.tiles) {
+        for (tile, tr) in items.iter().zip(&lay.tiles) {
             if !r.contains(tr.left_top()) {
                 continue; // overflowed the card; skip (no scroll yet)
             }
-            let (fill, fg) = if *on { (tk.accent, tk.on_accent) } else { (tk.hover, tk.text_dim) };
+            // Items with no data under the PivotTables' other filters are dimmed.
+            let (fill, fg) = match (tile.selected, tile.has_data) {
+                (true, true) => (tk.accent, tk.on_accent),
+                (true, false) => (tk.accent_soft, tk.text_dim),
+                (false, true) => (tk.hover, tk.text_dim),
+                (false, false) => (tk.window, tk.text_dim),
+            };
             p.rect_filled(*tr, 3.0 * geo.z, fill);
             let cp = p.with_clip_rect(tr.intersect(p.clip_rect()));
-            cp.text(tr.left_center() + vec2(6.0 * geo.z, 0.0), Align2::LEFT_CENTER, val, theme::ui_font(12.0 * geo.z), fg);
+            cp.text(tr.left_center() + vec2(6.0 * geo.z, 0.0), Align2::LEFT_CENTER, &tile.label, theme::ui_font(12.0 * geo.z), fg);
         }
         if app.selected_chart == Some(sl.id) {
             selection_frame(p, r);
@@ -469,7 +493,7 @@ pub enum SlicerAction {
 
 /// A click on a slicer's value tile or clear button, if any. A click elsewhere in a slicer returns
 /// `None` so the caller can treat it as a select/drag on the object.
-pub fn slicer_click(geo: &Geo, sh: &Sheet, wb: &Workbook, si: usize, p: Pos2) -> Option<(u32, SlicerAction)> {
+pub fn slicer_click(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, si: usize, p: Pos2) -> Option<(u32, SlicerAction)> {
     if !geo.cells.contains(p) || objects_hidden(wb) {
         return None;
     }
@@ -478,14 +502,14 @@ pub fn slicer_click(geo: &Geo, sh: &Sheet, wb: &Workbook, si: usize, p: Pos2) ->
         if !r.contains(p) {
             continue;
         }
-        let items = gridcraft_engine::cmd::slicer::slicer_items(wb, si, sl);
-        let lay = slicer_layout(r, geo.z, items.len(), sl.columns);
+        let items = cached_slicer_items(app, wb, si, sl);
+        let lay = slicer_layout(r, geo.z, items.len(), sl.columns, sl.row_height);
         if lay.clear.contains(p) {
             return Some((sl.id, SlicerAction::Clear));
         }
-        for ((val, _on), tr) in items.iter().zip(&lay.tiles) {
+        for (tile, tr) in items.iter().zip(&lay.tiles) {
             if r.contains(tr.left_top()) && tr.contains(p) {
-                return Some((sl.id, SlicerAction::Toggle(val.clone())));
+                return Some((sl.id, SlicerAction::Toggle(tile.key.clone())));
             }
         }
         return None; // inside this (topmost) slicer, but on its header/background → select/drag
@@ -534,3 +558,74 @@ pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(&'static s
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gridcraft_engine::model::{Anchor, PivotSort, Slicer, SlicerCrossFilter, SlicerPivot, SlicerSource};
+    use serde_json::json;
+
+    #[test]
+    fn slicer_tile_cache_refreshes_after_source_edit() {
+        let mut session = gridcraft_engine::Session::new();
+        session.new_workbook();
+        session
+            .execute("range.setValues", json!({"range": "A1:B4", "values": [["Region", "Sales"], ["East", 1], ["West", 2], ["North", 3]]}))
+            .unwrap();
+        session.execute("insert.pivotTable", json!({"source": "A1:B4", "destination": "D1", "rows": ["Region"], "values": ["Sales"]})).unwrap();
+        let mut app = SheetApp::new(session, Default::default());
+        {
+            let d = app.session.doc_mut().unwrap();
+            let sheet = d.wb.active_sheet();
+            let name = d.wb.sheet(sheet).unwrap().name.clone();
+            let pivot = d.wb.sheet(sheet).unwrap().pivots[0].name.clone();
+            let slicer = Slicer {
+                id: 100,
+                source: SlicerSource::Pivot {
+                    pivots: vec![SlicerPivot { sheet: name, name: pivot }],
+                    field: "Region".into(),
+                    sort: PivotSort::Asc,
+                    cross_filter: SlicerCrossFilter::default(),
+                    show_missing: true,
+                },
+                caption: "Region".into(),
+                anchor: Anchor::default(),
+                columns: 1,
+                name: String::new(),
+                style: String::new(),
+                row_height: None,
+            };
+            std::sync::Arc::make_mut(&mut d.wb).sheet_mut(sheet).unwrap().slicers.push(slicer);
+        }
+        let wb = app.session.active().unwrap().wb.clone();
+        let slicer = wb.active().unwrap().slicers[0].clone();
+        let strong = Arc::strong_count(&wb);
+        let before: Vec<_> = cached_slicer_items(&mut app, &wb, wb.active_sheet(), &slicer).iter().map(|x| x.label.clone()).collect();
+        assert_eq!(before, ["East", "North", "West"]);
+        // The cache holds no strong reference, so the next edit doesn't copy the workbook.
+        assert_eq!(Arc::strong_count(&wb), strong);
+
+        app.session.execute("cell.set", json!({"cell": "A2", "input": "South"})).unwrap();
+        let wb = app.session.active().unwrap().wb.clone();
+        let slicer = wb.active().unwrap().slicers[0].clone();
+        let after: Vec<_> = cached_slicer_items(&mut app, &wb, wb.active_sheet(), &slicer).iter().map(|x| x.label.clone()).collect();
+        assert_eq!(after, ["North", "South", "West"]);
+
+        // A source value that changes only on a manual recalculation (not undoable, so the
+        // document revision stays) still refreshes the tiles.
+        app.session.execute("cell.set", json!({"cell": "F1", "input": "West"})).unwrap();
+        app.session.execute("cell.set", json!({"cell": "A3", "input": "=F1"})).unwrap();
+        app.session.execute("formulas.calculationOptions", json!({"mode": "manual"})).unwrap();
+        app.session.execute("cell.set", json!({"cell": "F1", "input": "Central"})).unwrap();
+        let tiles = |app: &mut SheetApp| {
+            let wb = app.session.active().unwrap().wb.clone();
+            let slicer = wb.active().unwrap().slicers[0].clone();
+            cached_slicer_items(app, &wb, wb.active_sheet(), &slicer).iter().map(|x| x.label.clone()).collect::<Vec<_>>()
+        };
+        assert_eq!(tiles(&mut app), ["North", "South", "West"]);
+        let revision = app.session.active().unwrap().revision;
+        app.session.execute("formulas.calculateNow", json!({})).unwrap();
+        assert_eq!(app.session.active().unwrap().revision, revision);
+        assert_eq!(tiles(&mut app), ["Central", "North", "South"]);
+    }
+}
diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs
index c5e1dd4730..1c0da648ef 100644
--- a/crates/ui-egui/src/grid.rs
+++ b/crates/ui-egui/src/grid.rs
@@ -3,12 +3,14 @@
 //! formats, tables, comments, filters, sparklines, floating charts/pictures/shapes and the
 //! in-cell editor.
 
-use std::sync::Arc;
+use std::collections::HashMap;
+use std::sync::{Arc, Weak};
 
 use egui::{Align2, Color32, CursorIcon, FontId, Painter, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use gridcraft_engine::cf::{CfCache, CfLook};
 use gridcraft_engine::core::{CellRef, MAX_COLS, MAX_ROWS, RangeRef, Value, col_to_letters};
 use gridcraft_engine::model::{BorderLine, BorderStyle, Color, HAlign, LineIndex, PatternType, Sheet, Style, Underline, VAlign, Workbook};
+use gridcraft_engine::pivot::SlicerTile;
 use serde_json::json;
 
 use crate::SheetApp;
@@ -21,6 +23,8 @@ pub(crate) type PaneQuad = ((u32, u32), (u32, u32), Rect);
 type PagesCache = ((u64, u64, usize), Vec<(RangeRef, u32)>);
 /// Cached Show Details cells, keyed by (doc uid, revision, sheet, pivot).
 type DetailsCache = ((u64, u64, usize, usize), Option<std::collections::HashSet<(u32, u32)>>);
+/// Cached slicer tiles by (sheet, slicer id), with the workbook version they were computed from.
+type SlicerTilesCache = (Option<Weak<Workbook>>, HashMap<(usize, u32), Vec<SlicerTile>>);
 
 mod cell_paint;
 mod cursor;
@@ -216,6 +220,9 @@ pub struct GridState {
     pub pane: Option<String>,
     /// Ink stroke being drawn (sheet points).
     pub ink: Vec<[f32; 2]>,
+    /// Slicer tiles by (sheet, slicer id), with the workbook version they were computed from
+    /// (`None` without a document). Any other version, undoable or not, replaces them.
+    pub slicer_tiles: Option<SlicerTilesCache>,
     /// Page ranges for Page Break Preview, cached per (doc uid, revision, sheet).
     pub pages: Option<PagesCache>,
     /// The PivotTable Fields pane's `pivot.fields` answer, cached per (doc uid, revision, pivot):
diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs
index 4ffeaeb83d..aae315cc05 100644
--- a/crates/ui-egui/src/grid/interact.rs
+++ b/crates/ui-egui/src/grid/interact.rs
@@ -105,7 +105,7 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo
     if primary_clicked
         && !resp.drag_started()
         && let Some(p) = pos
-        && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p)
+        && let Some((id, act)) = crate::chartview::slicer_click(app, geo, sh, wb, wb.active_sheet(), p)
     {
         app.selected_chart = Some(id);
         match act {
diff --git a/crates/xlsx/src/drawing.rs b/crates/xlsx/src/drawing.rs
index 0668ca9d86..2c878d3988 100644
--- a/crates/xlsx/src/drawing.rs
+++ b/crates/xlsx/src/drawing.rs
@@ -181,6 +181,8 @@ pub fn read_drawing(cx: &mut Ctx<'_>, part: &str, sheet: &mut Sheet) -> Result<(
                         } else {
                             cx.warn(format!("chart {target} is missing from the package and was skipped ({part}, object {n})"));
                         }
+                    } else if crate::slicer::read_frame(cx, &sheet.name, gd, anchor) {
+                        // A slicer: joined with its slicer part and cache once the sheets are read.
                     } else if uri.contains("chartex") || uri.contains("chartEx") {
                         cx.warn(format!("a histogram, waterfall, treemap… chart without its chart part was skipped ({part}, object {n})"));
                     } else {
@@ -318,6 +320,8 @@ pub enum Obj<'a> {
     Image(&'a Image, String),
     Chart(&'a gridcraft_model::Chart, String),
     Shape(&'a Shape),
+    /// A PivotTable slicer and its (unique) name.
+    Slicer(&'a gridcraft_model::Slicer, String),
 }
 
 /// The drawing part for a sheet's objects (relationship ids already assigned).
@@ -366,6 +370,12 @@ pub fn write_drawing(sheet: &Sheet, theme: &Theme, objs: &[Obj<'_>]) -> String {
                     xfrm(&ch.anchor, "xdr:xfrm")
                 );
             }
+            Obj::Slicer(sl, name) => {
+                let (open, close) = anchor_open(sheet, &sl.anchor);
+                close_tag = close;
+                s.push_str(&open);
+                s.push_str(&crate::slicer::frame_xml(id, name, &xfrm(&sl.anchor, "xdr:xfrm"), &xfrm(&sl.anchor, "a:xfrm")));
+            }
             Obj::Shape(sh) => {
                 let (open, close) = anchor_open(sheet, &sh.anchor);
                 close_tag = close;
diff --git a/crates/xlsx/src/lib.rs b/crates/xlsx/src/lib.rs
index 650b228203..be33cc51ab 100644
--- a/crates/xlsx/src/lib.rs
+++ b/crates/xlsx/src/lib.rs
@@ -28,6 +28,7 @@ mod read;
 mod richdata;
 mod sheet_read;
 mod sheet_write;
+mod slicer;
 mod styles;
 mod tables;
 #[cfg(any(test, feature = "test-support"))]
diff --git a/crates/xlsx/src/pivot.rs b/crates/xlsx/src/pivot.rs
index 45a6188933..20ea0ff4dd 100644
--- a/crates/xlsx/src/pivot.rs
+++ b/crates/xlsx/src/pivot.rs
@@ -1,18 +1,17 @@
 //! PivotTables: pivot cache definitions and records (ECMA-376 Part 1 §18.10.1) and PivotTable
 //! definitions (§18.10.1.73), written from the model's [`PivotTable`]s and read back into them.
 //!
-//! Writing: one cache per PivotTable, with a records snapshot of the source list (omitted, with
-//! `saveData="0"`, for very large sources) and `refreshOnLoad="1"` so a reader recomputes the
-//! report from the source on open. Fields used on an axis get shared items (or, for date
-//! grouping, `fieldGroup` group items) so the table's `<items>` can refer to them. The report
-//! cells the engine wrote stay on the sheet as plain cells.
+//! Writing: one cache per PivotTable (the PivotTables a slicer connects share one), with a
+//! records snapshot of the source list (omitted, with `saveData="0"`, for very large sources) and
+//! `refreshOnLoad="1"` so a reader recomputes the report from the source on open. Fields used on
+//! an axis get shared items (or, for date grouping, `fieldGroup` group items) so the table's
+//! `<items>` can refer to them. The report cells the engine wrote stay on the sheet as plain cells.
 //!
 //! Reading: the cache's source and field names plus the table's areas, functions, show-values-as,
 //! layout flags, grand totals and style become a model [`PivotTable`]. Anything we don't model
 //! (OLAP sources, calculated fields, numeric grouping…) becomes a warning.
 
 use std::collections::HashMap;
-use std::fmt::Write as _;
 
 use gridcraft_core::date::datetime_from_serial;
 use gridcraft_core::{CellRef, DateSystem, RangeRef, Value, number_to_text};
@@ -29,9 +28,9 @@ use crate::xml::{El, esc_attr};
 mod read;
 mod write;
 
-pub use read::{CachesIn, read_pivots};
-pub use write::PivotWriter;
-
+pub use read::{CachesIn, NonSourceField, read_pivots};
+pub use write::{PivotSlicerInfo, PivotWriter};
+pub(crate) use write::{can_share, slicer_field_ok};
 pub const CT_PIVOT_TABLE: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml";
 pub const CT_PIVOT_CACHE_DEF: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml";
 pub const CT_PIVOT_CACHE_REC: &str = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml";
@@ -46,6 +45,8 @@ const MAX_ITEMS: usize = 1_048_576;
 const MAX_FIELDS: usize = 16_384;
 /// The `x14:dataField` extension (Excel 2010 show-values-as additions such as rank).
 const EXT_X14_DATA_FIELD: &str = "{E15A36E0-9728-4e99-A89B-3F7291B0FE68}";
+/// Extension carrying a cache's id for slicer caches.
+const EXT_X14_CACHE_ID: &str = "{725AE2AE-9491-48be-B2B4-4EB974FC3084}";
 const EXT_X14_PIVOT_TABLE: &str = "{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}";
 const NS_X14: &str = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
 
diff --git a/crates/xlsx/src/pivot/read.rs b/crates/xlsx/src/pivot/read.rs
index 134a8ab227..b3e4bf31cc 100644
--- a/crates/xlsx/src/pivot/read.rs
+++ b/crates/xlsx/src/pivot/read.rs
@@ -31,6 +31,8 @@ impl FieldIn {
 struct CacheIn {
     source: String,
     fields: Vec<FieldIn>,
+    /// `x14:pivotCacheDefinition pivotCacheId`: how slicer caches name the cache.
+    slicer_id: Option<u32>,
 }
 
 /// Workbook-level pivot cache lookup, filled from `<pivotCaches>`; caches are parsed once.
@@ -55,6 +57,53 @@ impl CachesIn {
         }
         CachesIn { by_id, parsed: HashMap::new(), next_id: 1 }
     }
+
+    /// Whether a slicer cache id resolves to a parsed PivotTable cache.
+    pub fn has_slicer_cache(&self, cache_id: u32) -> bool {
+        self.parsed.values().flatten().any(|c| c.slicer_id == Some(cache_id))
+    }
+
+    /// Item captions of field `field` in the cache a slicer cache names by `pivotCacheId`, in
+    /// shared item order (what the slicer cache's `<i x>` indices refer to), and the field's date
+    /// grouping. `None` for a grouping GridCraft can't compute.
+    pub fn slicer_labels(&self, cache_id: u32, field: &str) -> Option<(&[String], PivotDateGroup)> {
+        let cache = self.parsed.values().flatten().find(|c| c.slicer_id == Some(cache_id))?;
+        let f = cache.fields.iter().find(|f| f.database && same(&f.name, field))?;
+        let group = match &f.group {
+            None => PivotDateGroup::None,
+            Some((_, by, _)) => (*by)?,
+        };
+        Some((f.labels(), group))
+    }
+
+    /// What `field` names in the cache a slicer cache names by `pivotCacheId`, when it is not a
+    /// source column. `None` when it is one, or the cache isn't known.
+    pub fn slicer_non_source(&self, cache_id: u32, field: &str) -> Option<NonSourceField<'_>> {
+        let cache = self.parsed.values().flatten().find(|c| c.slicer_id == Some(cache_id))?;
+        if cache.fields.iter().any(|f| f.database && same(&f.name, field)) {
+            return None;
+        }
+        let base = cache
+            .fields
+            .iter()
+            .find(|f| same(&f.name, field))
+            .and_then(|f| f.group.as_ref())
+            .and_then(|(base, by, _)| by.and((*base).and_then(|b| cache.fields.get(b))))
+            .filter(|b| b.database);
+        Some(match base {
+            Some(b) => NonSourceField::DateLevel { base: &b.name },
+            None => NonSourceField::Other,
+        })
+    }
+}
+
+/// A slicer cache's source field that is not a source column of its pivot cache.
+pub enum NonSourceField<'a> {
+    /// A coarser date level, which Excel keeps in a field of its own when a date is grouped at
+    /// several levels ("Years" over "Date" grouped by years and months), grouping column `base`.
+    DateLevel { base: &'a str },
+    /// Another field (calculated, grouped in a way GridCraft can't compute) or none of that name.
+    Other,
 }
 
 fn item_label_el(e: &El, sys: DateSystem) -> String {
@@ -130,7 +179,9 @@ fn read_cache(cx: &mut Ctx<'_>, part: &str, sheet_name: &str) -> Option<CacheIn>
         cx.warn("a PivotTable's cache has no fields; kept as plain cells");
         return None;
     }
-    Some(CacheIn { source, fields })
+    let slicer_id =
+        x.child("extLst").and_then(|l| l.kids("ext").find_map(|e| e.child("pivotCacheDefinition"))).and_then(|d| d.attr_u32("pivotCacheId"));
+    Some(CacheIn { source, fields, slicer_id })
 }
 
 /// Reads the PivotTables related to a worksheet part.
@@ -280,7 +331,7 @@ fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<Pivo
                 if items.iter().any(|it| it.flag("h", false)) {
                     let shown: Vec<String> = items.iter().filter(|it| !it.flag("h", false)).filter_map(|it| lab(it)).collect();
                     if !filters.iter().any(|ff| same(&ff.source_col, &name)) {
-                        filters.push(PivotFilter { source_col: name.clone(), selected: Some(shown) });
+                        filters.push(PivotFilter { source_col: name.clone(), selected: Some(shown), hidden: false, date_group: group });
                     }
                 }
             }
@@ -291,7 +342,7 @@ fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<Pivo
     let mut page_filters = Vec::new();
     for p in &pages {
         let Some(i) = p.attr_i64("fld").filter(|i| *i >= 0).map(|i| i as usize) else { continue };
-        let Some((name, _)) = field_ref(cx, cache, i) else { continue };
+        let Some((name, group)) = field_ref(cx, cache, i) else { continue };
         let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
         let selected = if let Some(k) = p.attr_u32("item") {
             labels.get(k as usize).map(|l| vec![l.clone()])
@@ -307,7 +358,7 @@ fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<Pivo
                 })
             })
         };
-        page_filters.push(PivotFilter { source_col: name, selected });
+        page_filters.push(PivotFilter { source_col: name, selected, hidden: false, date_group: group });
     }
     let mut axis_filters = Vec::new();
     let (rows, rows_values) = axis(cx, &row_x, &mut axis_filters);
@@ -321,7 +372,31 @@ fn read_table(cx: &mut Ctx<'_>, x: &El, cache: &CacheIn, id: u32) -> Option<Pivo
         if pt.values_on_rows { rows_values.or_else(|| x.attr_u32("dataPosition").map(|p| p as usize)).filter(|p| *p < pt.rows.len()) } else { None };
     filters.extend(page_filters);
     filters.extend(axis_filters);
+    // Hidden items of a field in no area: a slicer's selection on a field the table doesn't show.
+    // A date-grouped cache field keeps its grouping, so the items are its groups.
+    let page_x: Vec<i64> = pages.iter().filter_map(|p| p.attr_i64("fld")).collect();
+    for (i, e) in pfs.iter().enumerate() {
+        let placed = [&row_x, &col_x, &page_x].iter().any(|l| l.contains(&(i as i64)));
+        let items = items_of(e);
+        if placed || !items.iter().any(|it| it.flag("h", false)) {
+            continue;
+        }
+        // Items of a grouping GridCraft can't compute could never match a source value.
+        if let Some(f) = cache.fields.get(i).filter(|f| matches!(f.group, Some((_, None, _)))) {
+            cx.warn(format!("PivotTable \"{}\": the filter on grouped field \"{}\" is not supported and was ignored", pt.name, f.name));
+            continue;
+        }
+        let Some((name, group)) = field_ref(cx, cache, i) else { continue };
+        if filters.iter().any(|f| same(&f.source_col, &name)) {
+            continue;
+        }
+        let labels = cache.fields.get(i).map(|f| f.labels().to_vec()).unwrap_or_default();
+        let shown =
+            items.iter().filter(|it| !it.flag("h", false)).filter_map(|it| it.attr_u32("x").and_then(|k| labels.get(k as usize)).cloned()).collect();
+        filters.push(PivotFilter { source_col: name, selected: Some(shown), hidden: true, date_group: group });
+    }
     pt.filters = filters;
+    pt.normalize_filter_groups();
 
     // Values.
     if let Some(df) = x.child("dataFields") {
diff --git a/crates/xlsx/src/pivot/write.rs b/crates/xlsx/src/pivot/write.rs
index a56bbf7078..87482ed1ca 100644
--- a/crates/xlsx/src/pivot/write.rs
+++ b/crates/xlsx/src/pivot/write.rs
@@ -1,4 +1,11 @@
-use super::*;
+use std::fmt::Write as _;
+
+use super::{
+    CT_PIVOT_CACHE_DEF, CT_PIVOT_CACHE_REC, CT_PIVOT_TABLE, CellRef, DateSystem, EXT_X14_CACHE_ID, EXT_X14_DATA_FIELD, EXT_X14_PIVOT_TABLE, HashMap,
+    Key, MAX_ITEMS, MAX_RECORD_CELLS, MAX_SOURCE_CELLS, MONTHS, NS_MAIN, NS_REL, NS_X14, Out, PivotDateGroup, PivotField, PivotFilter, PivotFunc,
+    PivotLayout, PivotShowAs, PivotSort, PivotTable, PivotValue, RangeRef, Rels, Value, Workbook, XML_DECL, datetime_from_serial, esc_attr,
+    func_caption, func_name, group_by_name, group_caption, iso, key, label, mdy, same,
+};
 
 #[derive(Default)]
 struct Stats {
@@ -87,13 +94,35 @@ impl CField {
     }
 }
 
-/// A cache built from a PivotTable's source.
+/// A cache built from the source of one or more PivotTables.
 struct Cache {
     fields: Vec<CField>,
-    /// Pivot field → cache field, by the pivot field's position in rows, then columns.
-    axis_map: Vec<Option<usize>>,
     source_xml: String,
     records: Option<(u64, String)>,
+    /// Fields slicers filter (written with items even off the axes).
+    slicer_fields: Vec<usize>,
+    /// The cache's id for slicer caches (`x14:pivotCacheDefinition pivotCacheId`).
+    slicer_id: Option<u32>,
+}
+
+/// A PivotTable's pivot field → cache field map, by the pivot field's position in rows, then
+/// columns.
+type AxisMap = Vec<Option<usize>>;
+
+/// What a slicer cache needs from a written PivotTable.
+pub struct PivotSlicerInfo {
+    /// The cache's `pivotCacheId`.
+    pub cache_id: u32,
+    pub fields: Vec<SlicerField>,
+}
+
+/// A cache field that a slicer filters.
+pub struct SlicerField {
+    pub name: String,
+    /// The captions its item indices refer to.
+    pub labels: Vec<String>,
+    /// The items are date groups, in date order.
+    pub grouped: bool,
 }
 
 /// PivotTables being written; the tables themselves are finished after the styles part (their
@@ -102,8 +131,17 @@ struct Cache {
 pub struct PivotWriter {
     /// (cache id, workbook-relative part name).
     caches: Vec<(u32, String)>,
+    /// The caches written, which the pending tables refer to.
+    built: Vec<Cache>,
+    /// PivotTables (sheet, index) whose shared cache an earlier table wrote: (cache id, index in
+    /// `built`, axis map).
+    shared: HashMap<(usize, usize), (u32, usize, AxisMap)>,
     pending: Vec<Pending>,
     tables: u32,
+    /// Slicer data of the caches that slicers filter, and (sheet, pivot index) → its index there
+    /// for each PivotTable written with such a cache.
+    infos: Vec<PivotSlicerInfo>,
+    slicer_info: HashMap<(usize, usize), usize>,
 }
 
 struct Pending {
@@ -111,40 +149,90 @@ struct Pending {
     sheet: usize,
     idx: usize,
     cache_id: u32,
-    cache: Cache,
+    /// Index in `PivotWriter::built`.
+    cache: usize,
+    axis_map: AxisMap,
 }
 
 impl PivotWriter {
     /// Writes the caches of a sheet's PivotTables and adds the sheet's relationships to its
-    /// PivotTable parts. Pivots whose source can't be resolved are not written.
+    /// PivotTable parts. Pivots whose source can't be resolved are not written. The PivotTables a
+    /// slicer connects get one cache, written with the first of them.
     pub fn add_sheet(&mut self, wb: &Workbook, si: usize, out: &mut Out, rels: &mut Rels) {
         let Some(sheet) = wb.sheet(si) else { return };
-        for (idx, pt) in sheet.pivots.iter().enumerate() {
-            let Some(cache) = build_cache(wb, pt, si) else { continue };
-            let n = self.caches.len() as u32 + 1;
-            let cache_part = format!("xl/pivotCache/pivotCacheDefinition{n}.xml");
-            let rec_rid = if let Some((count, xml)) = &cache.records {
-                let mut r = Rels::default();
-                let rid = r.add("pivotCacheRecords", &format!("pivotCacheRecords{n}.xml"));
-                out.part(&format!("xl/pivotCache/_rels/pivotCacheDefinition{n}.xml.rels"), None, r.xml().into_bytes());
-                let s = format!("{XML_DECL}<pivotCacheRecords xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\" count=\"{count}\">{xml}</pivotCacheRecords>");
-                out.part(&format!("xl/pivotCache/pivotCacheRecords{n}.xml"), Some(CT_PIVOT_CACHE_REC), s.into_bytes());
-                Some(rid)
-            } else {
-                None
+        for idx in 0..sheet.pivots.len() {
+            let (n, cache, axis_map) = match self.shared.remove(&(si, idx)) {
+                Some(x) => x,
+                None => {
+                    let Some(x) = self.write_cache(wb, si, idx, out) else { continue };
+                    x
+                }
             };
-            out.part(&cache_part, Some(CT_PIVOT_CACHE_DEF), cache_xml(&cache, rec_rid.as_deref(), wb.date_system).into_bytes());
-            self.caches.push((n, format!("pivotCache/pivotCacheDefinition{n}.xml")));
             self.tables += 1;
             let t = self.tables;
             rels.add("pivotTable", &format!("../pivotTables/pivotTable{t}.xml"));
             let mut tr = Rels::default();
             tr.add("pivotCacheDefinition", &format!("../pivotCache/pivotCacheDefinition{n}.xml"));
             out.part(&format!("xl/pivotTables/_rels/pivotTable{t}.xml.rels"), None, tr.xml().into_bytes());
-            self.pending.push(Pending { part: format!("xl/pivotTables/pivotTable{t}.xml"), sheet: si, idx, cache_id: n, cache });
+            self.pending.push(Pending { part: format!("xl/pivotTables/pivotTable{t}.xml"), sheet: si, idx, cache_id: n, cache, axis_map });
         }
     }
 
+    /// Writes the cache of PivotTable `idx` on sheet `si` (shared with the PivotTables its
+    /// slicers connect, which are recorded in `shared`); returns (cache id, index in `built`,
+    /// the table's axis map).
+    fn write_cache(&mut self, wb: &Workbook, si: usize, idx: usize, out: &mut Out) -> Option<(u32, usize, AxisMap)> {
+        let group = out.slicers.cache_group(si, idx).unwrap_or_else(|| vec![(si, idx)]);
+        let members: Vec<((usize, usize), &PivotTable)> =
+            group.iter().filter_map(|&(gs, gp)| Some(((gs, gp), wb.sheet(gs)?.pivots.get(gp)?))).collect();
+        let slicer_fields = out.slicers.fields_for(si, idx);
+        let tables: Vec<(&PivotTable, usize)> = members.iter().map(|((gs, _), pt)| (*pt, *gs)).collect();
+        let (mut cache, maps) = build_cache(wb, &tables, &slicer_fields)?;
+        let n = self.caches.len() as u32 + 1;
+        if !cache.slicer_fields.is_empty() {
+            cache.slicer_id = Some(n);
+            let fields = cache
+                .slicer_fields
+                .iter()
+                .filter_map(|&i| cache.fields.get(i))
+                .map(|f| SlicerField { name: f.name.clone(), labels: f.item_labels(), grouped: f.group.is_some() })
+                .collect();
+            for (key, _) in &members {
+                self.slicer_info.insert(*key, self.infos.len());
+            }
+            self.infos.push(PivotSlicerInfo { cache_id: n, fields });
+        }
+        let cache_part = format!("xl/pivotCache/pivotCacheDefinition{n}.xml");
+        let rec_rid = if let Some((count, xml)) = &cache.records {
+            let mut r = Rels::default();
+            let rid = r.add("pivotCacheRecords", &format!("pivotCacheRecords{n}.xml"));
+            out.part(&format!("xl/pivotCache/_rels/pivotCacheDefinition{n}.xml.rels"), None, r.xml().into_bytes());
+            let s = format!("{XML_DECL}<pivotCacheRecords xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\" count=\"{count}\">{xml}</pivotCacheRecords>");
+            out.part(&format!("xl/pivotCache/pivotCacheRecords{n}.xml"), Some(CT_PIVOT_CACHE_REC), s.into_bytes());
+            Some(rid)
+        } else {
+            None
+        };
+        out.part(&cache_part, Some(CT_PIVOT_CACHE_DEF), cache_xml(&cache, rec_rid.as_deref(), wb.date_system).into_bytes());
+        self.caches.push((n, format!("pivotCache/pivotCacheDefinition{n}.xml")));
+        let b = self.built.len();
+        self.built.push(cache);
+        let mut mine = None;
+        for ((key, _), map) in members.iter().zip(maps) {
+            if *key == (si, idx) {
+                mine = Some(map);
+            } else {
+                self.shared.insert(*key, (n, b, map));
+            }
+        }
+        Some((n, b, mine?))
+    }
+
+    /// Slicer data of the PivotTable `idx` on sheet `si`, when it was written for a slicer.
+    pub fn slicer_info(&self, si: usize, idx: usize) -> Option<&PivotSlicerInfo> {
+        self.slicer_info.get(&(si, idx)).and_then(|&i| self.infos.get(i))
+    }
+
     /// Adds the workbook relationships to the caches; returns the `<pivotCaches>` element (empty
     /// when there are none).
     pub fn workbook_xml(&self, wb_rels: &mut Rels) -> String {
@@ -179,9 +267,10 @@ impl PivotWriter {
 
     /// Writes the PivotTable parts. `fmt_id` maps a number format code to its styles id.
     pub fn finish(self, wb: &Workbook, out: &mut Out, fmt_id: &dyn Fn(&str) -> Option<u32>) {
-        for p in self.pending {
+        for p in &self.pending {
             let Some(pt) = wb.sheet(p.sheet).and_then(|s| s.pivots.get(p.idx)) else { continue };
-            let xml = table_xml(pt, p.idx, p.cache_id, &p.cache, fmt_id);
+            let Some(cache) = self.built.get(p.cache) else { continue };
+            let xml = table_xml(pt, p.idx, p.cache_id, cache, &p.axis_map, fmt_id);
             out.part(&p.part, Some(CT_PIVOT_TABLE), xml.into_bytes());
         }
     }
@@ -246,169 +335,119 @@ fn header_text(v: &Value) -> String {
     }
 }
 
-fn cache_fields(sh: &gridcraft_model::Sheet, r: RangeRef) -> Vec<CField> {
-    let mut fields: Vec<CField> = Vec::new();
-    // Lower-case names taken, and the next suffix for each header (linear for repeated headers).
-    let mut taken = std::collections::HashSet::new();
-    let mut next_suffix: HashMap<String, usize> = HashMap::new();
-    for (k, c) in (r.start.col..=r.end.col).enumerate() {
-        let mut h = header_text(&sh.value(CellRef::new(r.start.row, c)).scalar());
-        if h.is_empty() {
-            h = format!("Column{}", k + 1);
-        }
-        let mut n = h.clone();
-        let mut i = next_suffix.get(&h.to_lowercase()).copied().unwrap_or(2);
-        while taken.contains(&n.to_lowercase()) {
-            n = format!("{h}{i}");
-            i += 1;
-        }
-        next_suffix.insert(h.to_lowercase(), i);
-        taken.insert(n.to_lowercase());
-        fields.push(CField {
-            name: n,
-            col: Some(k as u32),
-            stats: Stats::default(),
-            items: vec![],
-            index: HashMap::new(),
-            itemized: false,
-            group: None,
-            formula: None,
-        });
-    }
-    fields
+/// Whether a slicer on `field` of `pt` can be written: the PivotTable's cache can be built and its
+/// source has the field.
+pub(crate) fn slicer_field_ok(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize, field: &str) -> bool {
+    let Some((si, r, _)) = resolve_source(wb, &pt.source, pivot_sheet, 0) else { return false };
+    let Some(sh) = wb.sheet(si) else { return false };
+    r.count() <= MAX_SOURCE_CELLS && (r.start.col..=r.end.col).any(|c| same(&header_text(&sh.value(CellRef::new(r.start.row, c)).scalar()), field))
 }
 
-fn group_cache_fields(fields: &mut Vec<CField>, axis: &[&PivotField], date_system: DateSystem) {
-    let find = |fields: &[CField], name: &str| fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
-    let groupable = |f: &CField| {
-        let s = &f.stats;
-        s.number
-            && !s.text
-            && !s.boolean
-            && !s.error
-            && datetime_from_serial(date_system, s.min).is_some()
-            && datetime_from_serial(date_system, s.max).is_some()
-    };
-    // (base column field, groupings fine → coarse)
-    let mut groupings: Vec<(usize, Vec<PivotDateGroup>)> = Vec::new();
-    for pf in axis {
-        let Some(b) = find(fields, &pf.source_col) else { continue };
-        if pf.date_group == PivotDateGroup::None || !fields.get(b).is_some_and(groupable) {
-            continue;
-        }
-        match groupings.iter_mut().find(|(x, _)| *x == b) {
-            Some((_, v)) => {
-                if !v.contains(&pf.date_group) {
-                    v.push(pf.date_group);
-                }
-            }
-            None => groupings.push((b, vec![pf.date_group])),
+/// Whether the PivotTables `members` (sheet, index) can be written with one pivot cache, as the
+/// PivotTables a slicer connects must be: they have the same source (written the same way) and
+/// the same calculated fields (a cache's calculated fields are read back into each of its
+/// tables), and a date-grouped field (which a cache groups for all its tables) has the same base
+/// grouping (the finest level, on the axes or by the filters) in every table that uses it,
+/// `slicer_fields` counting as used by all.
+pub(crate) fn can_share(wb: &Workbook, members: &[(usize, usize)], slicer_fields: &[String]) -> bool {
+    let pts: Vec<(&PivotTable, usize)> = members.iter().filter_map(|&(si, pi)| Some((wb.sheet(si)?.pivots.get(pi)?, si))).collect();
+    if pts.len() != members.len() {
+        return false;
+    }
+    let mut source: Option<(usize, RangeRef, String)> = None;
+    for (pt, si) in &pts {
+        let Some(here) = resolve_source(wb, &pt.source, *si, 0) else { return false };
+        if source.as_ref().is_some_and(|x| *x != here) {
+            return false;
         }
+        source = Some(here);
     }
-    let fineness = |g: &PivotDateGroup| match g {
-        PivotDateGroup::Days => 0,
-        PivotDateGroup::Months => 1,
-        PivotDateGroup::Quarters => 2,
-        PivotDateGroup::Years => 3,
-        PivotDateGroup::None => 4,
+    // The base grouping a table gives a column (finest of its axis fields' and its filter's).
+    let base = |pt: &PivotTable, col: &str| -> Option<PivotDateGroup> {
+        let axis = pt.rows.iter().chain(pt.columns.iter()).filter(|f| same(&f.source_col, col)).map(|f| f.date_group);
+        axis.chain(pt.filters.iter().filter(|f| same(&f.source_col, col)).map(|f| pt.filter_group(f))).min_by_key(|g| g.coarseness())
     };
-    for (b, list) in groupings.iter_mut() {
-        list.sort_by_key(fineness);
-        let (min, max) = fields.get(*b).map(|f| (f.stats.min, f.stats.max)).unwrap_or((0.0, 0.0));
-        let (start, end) = (min.floor(), max.floor() + 1.0);
-        let make = |by: PivotDateGroup| Group { by, base: *b, par: None, start, end, items: group_items(date_system, by, start, end) };
-        let mut prev = *b;
-        for (k, by) in list.iter().enumerate() {
-            if k == 0 {
-                if let Some(f) = fields.get_mut(*b) {
-                    f.group = Some(make(*by));
-                }
-                continue;
+    let uses = |pt: &PivotTable, col: &str| base(pt, col).is_some() || slicer_fields.iter().any(|f| same(f, col));
+    for (pt, _) in &pts {
+        let cols = pt.rows.iter().chain(pt.columns.iter()).map(|f| &f.source_col).chain(pt.filters.iter().map(|f| &f.source_col));
+        for col in cols {
+            let want = base(pt, col);
+            if want.is_some_and(|g| g != PivotDateGroup::None) && pts.iter().any(|(o, _)| uses(o, col) && base(o, col) != want) {
+                return false;
             }
-            let new = fields.len();
-            let caption = group_caption(*by);
-            let mut n = caption.to_string();
-            let mut i = 2;
-            while fields.iter().any(|f| same(&f.name, &n)) {
-                n = format!("{caption}{i}");
-                i += 1;
-            }
-            if let Some(g) = fields.get_mut(prev).and_then(|f| f.group.as_mut()) {
-                g.par = Some(new);
-            }
-            fields.push(CField {
-                name: n,
-                col: None,
-                stats: Stats::default(),
-                items: vec![],
-                index: HashMap::new(),
-                itemized: false,
-                group: Some(make(*by)),
-                formula: None,
-            });
-            prev = new;
         }
     }
+    let formula = |f: &str| f.trim().trim_start_matches('=').trim().to_lowercase();
+    let calc = |pt: &PivotTable| -> Vec<(String, String)> {
+        let mut v: Vec<(String, String)> = pt.calculated_fields.iter().map(|cf| (cf.name.trim().to_lowercase(), formula(&cf.formula))).collect();
+        v.sort();
+        v.dedup_by(|a, b| a.0 == b.0);
+        v
+    };
+    let first = pts.first().map(|(pt, _)| calc(pt)).unwrap_or_default();
+    pts.iter().all(|(pt, _)| calc(pt) == first)
 }
 
-fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cache> {
-    let (si, r, source_xml) = resolve_source(wb, &pt.source, pivot_sheet, 0)?;
+/// The cache of `tables` (PivotTable, its sheet), which [`can_share`] one, and each table's axis
+/// map. `slicer_fields`: fields slicers filter, which need shared items.
+fn build_cache(wb: &Workbook, tables: &[(&PivotTable, usize)], slicer_fields: &[String]) -> Option<(Cache, Vec<AxisMap>)> {
+    let (first, pivot_sheet) = tables.first()?;
+    let (si, r, source_xml) = resolve_source(wb, &first.source, *pivot_sheet, 0)?;
     if r.count() > MAX_SOURCE_CELLS {
         return None;
     }
     let sh = wb.sheet(si)?;
-    let mut fields = cache_fields(sh, r);
+    let (mut fields, rows) = source_fields_and_rows(sh, r);
     let find = |fields: &[CField], name: &str| fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
 
-    // Records (rows that aren't entirely blank), read once.
-    let mut rows: Vec<u32> = Vec::new();
-    if r.end.row > r.start.row {
-        for row in r.start.row + 1..=r.end.row {
-            let blank = (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(row, c)).scalar().is_empty());
-            if !blank {
-                rows.push(row);
+    // How dates are grouped, by the axis fields and the filters (a filtered field in no area keeps
+    // its grouping): per base column, the base field takes the finest grouping and coarser ones
+    // become extra (non-database) fields chained through `par`, as Excel lays them out.
+    let used: Vec<(&str, PivotDateGroup)> = tables
+        .iter()
+        .flat_map(|(pt, _)| {
+            let axis = pt.rows.iter().chain(pt.columns.iter()).map(|f| (f.source_col.as_str(), f.date_group));
+            axis.chain(pt.filters.iter().map(|f| (f.source_col.as_str(), pt.filter_group(f))))
+        })
+        .collect();
+    apply_date_groupings(&mut fields, &used, wb.date_system);
+    let mut axis_maps: Vec<AxisMap> = Vec::with_capacity(tables.len());
+    for (pt, _) in tables {
+        let mut axis_map: AxisMap = Vec::with_capacity(pt.rows.len() + pt.columns.len());
+        for pf in pt.rows.iter().chain(pt.columns.iter()) {
+            let Some(b) = find(&fields, &pf.source_col) else {
+                axis_map.push(None);
+                continue;
+            };
+            let grouped = fields.iter().position(|f| f.group.as_ref().is_some_and(|g| g.base == b && g.by == pf.date_group));
+            match grouped {
+                Some(i) if pf.date_group != PivotDateGroup::None => axis_map.push(Some(i)),
+                _ => {
+                    if let Some(f) = fields.get_mut(b)
+                        && f.group.is_none()
+                    {
+                        f.itemized = true;
+                    }
+                    axis_map.push(Some(b));
+                }
             }
         }
-    }
-    for &row in &rows {
-        for f in fields.iter_mut() {
-            let c = r.start.col + f.col.unwrap_or(0);
-            f.stats.add(&sh.value(CellRef::new(row, c)).scalar());
-        }
-    }
-
-    // Which fields are on an axis, and how dates are grouped: per base column, the base field
-    // takes the finest grouping and coarser ones become extra (non-database) fields chained
-    // through `par`, as Excel lays them out.
-    let axis: Vec<&PivotField> = pt.rows.iter().chain(pt.columns.iter()).collect();
-    group_cache_fields(&mut fields, &axis, wb.date_system);
-    let mut axis_map: Vec<Option<usize>> = Vec::with_capacity(axis.len());
-    for pf in &axis {
-        let Some(b) = find(&fields, &pf.source_col) else {
-            axis_map.push(None);
-            continue;
-        };
-        let grouped = fields.iter().position(|f| f.group.as_ref().is_some_and(|g| g.base == b && g.by == pf.date_group));
-        match grouped {
-            Some(i) if pf.date_group != PivotDateGroup::None => axis_map.push(Some(i)),
-            _ => {
-                if let Some(f) = fields.get_mut(b)
-                    && f.group.is_none()
-                {
-                    f.itemized = true;
-                }
-                axis_map.push(Some(b));
+        axis_maps.push(axis_map);
+        // Page fields (filters not on an axis) need items too.
+        for f in &pt.filters {
+            let on_axis = pt.rows.iter().chain(pt.columns.iter()).any(|a| same(&a.source_col, &f.source_col));
+            if !on_axis
+                && let Some(i) = find(&fields, &f.source_col)
+                && let Some(cf) = fields.get_mut(i)
+            {
+                cf.itemized = true;
             }
         }
     }
-    // Page fields (filters not on an axis) need items too.
-    for f in &pt.filters {
-        let on_axis = axis.iter().any(|a| same(&a.source_col, &f.source_col));
-        if !on_axis
-            && let Some(i) = find(&fields, &f.source_col)
-            && let Some(cf) = fields.get_mut(i)
-        {
-            cf.itemized = true;
+    let slicer_idx: Vec<usize> = slicer_fields.iter().filter_map(|n| find(&fields, n)).collect();
+    for &i in &slicer_idx {
+        if let Some(f) = fields.get_mut(i) {
+            f.itemized = true;
         }
     }
     for f in fields.iter_mut() {
@@ -457,7 +496,7 @@ fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cac
         None
     };
     // Calculated fields come after the database and grouping fields.
-    for cf in &pt.calculated_fields {
+    for cf in tables.iter().flat_map(|(pt, _)| pt.calculated_fields.iter()) {
         let f = cf.formula.trim();
         let f = f.strip_prefix('=').unwrap_or(f).trim();
         if cf.name.trim().is_empty() || f.is_empty() || fields.iter().any(|x| same(&x.name, &cf.name)) {
@@ -474,7 +513,7 @@ fn build_cache(wb: &Workbook, pt: &PivotTable, pivot_sheet: usize) -> Option<Cac
             formula: Some(f.to_string()),
         });
     }
-    Some(Cache { fields, axis_map, source_xml, records })
+    Some((Cache { fields, source_xml, records, slicer_fields: slicer_idx, slicer_id: None }, axis_maps))
 }
 
 fn group_items(sys: DateSystem, by: PivotDateGroup, start: f64, end: f64) -> Vec<String> {
@@ -604,47 +643,46 @@ fn cache_xml(c: &Cache, records_rid: Option<&str>, sys: DateSystem) -> String {
         }
         s.push_str("</cacheField>");
     }
-    s.push_str("</cacheFields></pivotCacheDefinition>");
+    s.push_str("</cacheFields>");
+    if let Some(id) = c.slicer_id {
+        let _ = write!(
+            s,
+            "<extLst><ext uri=\"{EXT_X14_CACHE_ID}\" xmlns:x14=\"{NS_X14}\"><x14:pivotCacheDefinition pivotCacheId=\"{id}\"/></ext></extLst>"
+        );
+    }
+    s.push_str("</pivotCacheDefinition>");
     s
 }
 
-struct PivotTableLayout<'a> {
-    row_fields: Vec<usize>,
-    column_fields: Vec<usize>,
-    hidden_fields: HashMap<usize, &'a PivotFilter>,
-    page_fields: Vec<(usize, &'a PivotFilter)>,
-    values: Vec<(usize, &'a PivotValue)>,
-}
-
-fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn Fn(&str) -> Option<u32>) -> String {
+fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, axis_map: &[Option<usize>], fmt_id: &dyn Fn(&str) -> Option<u32>) -> String {
     let find_db = |name: &str| c.fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
-    let row_fields: Vec<usize> = c.axis_map.iter().take(pt.rows.len()).filter_map(|x| *x).collect();
-    let column_fields: Vec<usize> = c.axis_map.iter().skip(pt.rows.len()).filter_map(|x| *x).collect();
-    // Filters: on an axis field → hidden items there; otherwise a page field.
+    let row_idx: Vec<usize> = axis_map.iter().take(pt.rows.len()).filter_map(|x| *x).collect();
+    let col_idx: Vec<usize> = axis_map.iter().skip(pt.rows.len()).filter_map(|x| *x).collect();
+    // Filters go on the cache field holding their items: the axis field at the filter's date
+    // level, else the field grouped at that level, else the base field. On a field in Rows or
+    // Columns, or a hidden filter (a slicer's), they're hidden items; otherwise a page field.
     let mut hidden: HashMap<usize, &PivotFilter> = HashMap::new();
     let mut pages: Vec<(usize, &PivotFilter)> = Vec::new();
     for f in &pt.filters {
-        let axis_pos = pt.rows.iter().chain(pt.columns.iter()).position(|a| same(&a.source_col, &f.source_col));
-        match axis_pos {
-            Some(p) => {
-                if let Some(Some(i)) = c.axis_map.get(p) {
-                    hidden.insert(*i, f);
-                }
-            }
-            None => {
-                if let Some(i) = find_db(&f.source_col)
-                    && !pages.iter().any(|(j, _)| *j == i)
-                {
-                    pages.push((i, f));
-                    hidden.insert(i, f);
-                }
-            }
+        let g = pt.filter_group(f);
+        let mut axis = pt.rows.iter().chain(pt.columns.iter());
+        let on_axis = axis.clone().any(|a| same(&a.source_col, &f.source_col));
+        let level = axis.position(|a| same(&a.source_col, &f.source_col) && a.date_group == g).and_then(|p| axis_map.get(p).copied().flatten());
+        let grouped = || {
+            let b = find_db(&f.source_col)?;
+            c.fields.iter().position(|cf| cf.group.as_ref().is_some_and(|gr| gr.base == b && gr.by == g))
+        };
+        let Some(i) = level.or_else(grouped).or_else(|| find_db(&f.source_col)) else { continue };
+        if on_axis || f.hidden {
+            hidden.insert(i, f);
+        } else if !pages.iter().any(|(j, _)| *j == i) {
+            pages.push((i, f));
+            hidden.insert(i, f);
         }
     }
     let find_calc = |name: &str| c.fields.iter().position(|f| f.formula.is_some() && same(&f.name, name));
-    let values: Vec<(usize, &PivotValue)> =
+    let vals: Vec<(usize, &PivotValue)> =
         pt.values.iter().filter_map(|v| find_db(&v.source_col).or_else(|| find_calc(&v.source_col)).map(|i| (i, v))).collect();
-    let layout = PivotTableLayout { row_fields, column_fields, hidden_fields: hidden, page_fields: pages, values };
 
     let compact = pt.layout == PivotLayout::Compact;
     let name = if pt.name.trim().is_empty() { format!("PivotTable{}", idx + 1) } else { pt.name.clone() };
@@ -680,16 +718,16 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
     let a = pt.anchor;
     let end = pt.last_range.map(|r| r.end).unwrap_or(a);
     let loc = RangeRef::new(a, CellRef::new(end.row.max(a.row), end.col.max(a.col)));
-    let k = layout.values.len();
+    let k = vals.len();
     // Σ Values (two or more value fields): its index among the written fields of its axis.
-    let (row_map, _) = c.axis_map.split_at(pt.rows.len().min(c.axis_map.len()));
+    let (row_map, _) = axis_map.split_at(pt.rows.len().min(axis_map.len()));
     let values_at = |map: &[Option<usize>], n: usize| pt.values_position.map_or(n, |p| map.iter().take(p).filter(|x| x.is_some()).count());
-    let row_values = (k > 1 && pt.values_on_rows).then(|| values_at(row_map, layout.row_fields.len()));
+    let row_values = (k > 1 && pt.values_on_rows).then(|| values_at(row_map, row_idx.len()));
     // In Columns Σ Values comes after the last field: the column layout doesn't place it elsewhere.
-    let col_values = (k > 1 && !pt.values_on_rows).then_some(layout.column_fields.len());
-    let first_data_row = if layout.column_fields.is_empty() { 1 } else { 1 + layout.column_fields.len() + usize::from(col_values.is_some()) };
-    let row_levels = layout.row_fields.len() + usize::from(row_values.is_some());
-    let first_data_col = if row_levels == 0 && layout.column_fields.is_empty() {
+    let col_values = (k > 1 && !pt.values_on_rows).then_some(col_idx.len());
+    let first_data_row = if col_idx.is_empty() { 1 } else { 1 + col_idx.len() + usize::from(col_values.is_some()) };
+    let row_levels = row_idx.len() + usize::from(row_values.is_some());
+    let first_data_col = if row_levels == 0 && col_idx.is_empty() {
         0
     } else if compact {
         1
@@ -697,23 +735,23 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
         row_levels.max(1)
     };
     // Two or more value fields in Columns alone: Excel 365 would add a `Values` caption row.
-    let hide_values_row = col_values.is_some() && layout.column_fields.is_empty();
+    let hide_values_row = col_values.is_some() && col_idx.is_empty();
     let first_header_row = usize::from(!hide_values_row);
     let _ = write!(
         s,
         "<location ref=\"{}\" firstHeaderRow=\"{first_header_row}\" firstDataRow=\"{first_data_row}\" firstDataCol=\"{first_data_col}\"",
         loc.a1()
     );
-    if !layout.page_fields.is_empty() {
-        let _ = write!(s, " rowPageCount=\"{}\" colPageCount=\"1\"", layout.page_fields.len());
+    if !pages.is_empty() {
+        let _ = write!(s, " rowPageCount=\"{}\" colPageCount=\"1\"", pages.len());
     }
     s.push_str("/>");
 
-    write_pivot_fields(&mut s, pt, c, &layout);
-    axis_fields_xml(&mut s, "rowFields", &layout.row_fields, row_values);
-    axis_fields_xml(&mut s, "colFields", &layout.column_fields, col_values);
-    write_page_fields(&mut s, c, &layout);
-    write_data_fields(&mut s, c, &layout, fmt_id);
+    write_pivot_fields(&mut s, pt, c, axis_map, &row_idx, &col_idx, &pages, &vals, &hidden);
+    axis_fields_xml(&mut s, "rowFields", &row_idx, row_values);
+    axis_fields_xml(&mut s, "colFields", &col_idx, col_values);
+    write_page_fields(&mut s, c, &pages);
+    write_data_fields(&mut s, c, &vals, &row_idx, &col_idx, fmt_id);
     s.push_str("<pivotTableStyleInfo");
     if !pt.style.is_empty() {
         let _ = write!(s, " name=\"{}\"", esc_attr(&pt.style));
@@ -729,20 +767,96 @@ fn table_xml(pt: &PivotTable, idx: usize, cache_id: u32, c: &Cache, fmt_id: &dyn
     s
 }
 
-fn axis_field<'a>(pt: &'a PivotTable, c: &Cache, i: usize) -> Option<&'a PivotField> {
-    let p = c.axis_map.iter().position(|x| *x == Some(i))?;
-    pt.rows.iter().chain(pt.columns.iter()).nth(p)
+fn apply_date_groupings(fields: &mut Vec<CField>, used: &[(&str, PivotDateGroup)], date_system: DateSystem) {
+    let find = |fields: &[CField], name: &str| fields.iter().position(|f| f.col.is_some() && same(&f.name, name));
+    let groupable = |f: &CField| {
+        let s = &f.stats;
+        s.number
+            && !s.text
+            && !s.boolean
+            && !s.error
+            && datetime_from_serial(date_system, s.min).is_some()
+            && datetime_from_serial(date_system, s.max).is_some()
+    };
+    // (base column field, groupings fine → coarse)
+    let mut groupings: Vec<(usize, Vec<PivotDateGroup>)> = Vec::new();
+    for &(col, by) in used {
+        let Some(b) = find(fields, col) else { continue };
+        if by == PivotDateGroup::None || !fields.get(b).is_some_and(groupable) {
+            continue;
+        }
+        match groupings.iter_mut().find(|(x, _)| *x == b) {
+            Some((_, v)) => {
+                if !v.contains(&by) {
+                    v.push(by);
+                }
+            }
+            None => groupings.push((b, vec![by])),
+        }
+    }
+    for (b, list) in groupings.iter_mut() {
+        list.sort_by_key(|g| g.coarseness());
+        let (min, max) = fields.get(*b).map(|f| (f.stats.min, f.stats.max)).unwrap_or((0.0, 0.0));
+        let (start, end) = (min.floor(), max.floor() + 1.0);
+        let make = |by: PivotDateGroup| Group { by, base: *b, par: None, start, end, items: group_items(date_system, by, start, end) };
+        let mut prev = *b;
+        for (k, by) in list.iter().enumerate() {
+            if k == 0 {
+                if let Some(f) = fields.get_mut(*b) {
+                    f.group = Some(make(*by));
+                }
+                continue;
+            }
+            let new = fields.len();
+            let caption = group_caption(*by);
+            let mut n = caption.to_string();
+            let mut i = 2;
+            while fields.iter().any(|f| same(&f.name, &n)) {
+                n = format!("{caption}{i}");
+                i += 1;
+            }
+            if let Some(g) = fields.get_mut(prev).and_then(|f| f.group.as_mut()) {
+                g.par = Some(new);
+            }
+            fields.push(CField {
+                name: n,
+                col: None,
+                stats: Stats::default(),
+                items: vec![],
+                index: HashMap::new(),
+                itemized: false,
+                group: Some(make(*by)),
+                formula: None,
+            });
+            prev = new;
+        }
+    }
 }
 
-fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &PivotTableLayout<'_>) {
+#[allow(clippy::too_many_arguments)]
+fn write_pivot_fields(
+    s: &mut String,
+    pt: &PivotTable,
+    c: &Cache,
+    axis_map: &[Option<usize>],
+    row_idx: &[usize],
+    col_idx: &[usize],
+    pages: &[(usize, &PivotFilter)],
+    vals: &[(usize, &PivotValue)],
+    hidden: &HashMap<usize, &PivotFilter>,
+) {
+    let axis_field = |i: usize| -> Option<&PivotField> {
+        let p = axis_map.iter().position(|x| *x == Some(i))?;
+        pt.rows.iter().chain(pt.columns.iter()).nth(p)
+    };
     let _ = write!(s, "<pivotFields count=\"{}\">", c.fields.len());
     for (i, f) in c.fields.iter().enumerate() {
         s.push_str("<pivotField");
-        let axis = if layout.row_fields.contains(&i) {
+        let axis = if row_idx.contains(&i) {
             Some("axisRow")
-        } else if layout.column_fields.contains(&i) {
+        } else if col_idx.contains(&i) {
             Some("axisCol")
-        } else if layout.page_fields.iter().any(|(j, _)| *j == i) {
+        } else if pages.iter().any(|(j, _)| *j == i) {
             Some("axisPage")
         } else {
             None
@@ -750,7 +864,7 @@ fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &Pivot
         if let Some(ax) = axis {
             let _ = write!(s, " axis=\"{ax}\"");
         }
-        if layout.values.iter().any(|(j, _)| *j == i) {
+        if vals.iter().any(|(j, _)| *j == i) {
             s.push_str(" dataField=\"1\"");
         }
         if f.formula.is_some() {
@@ -764,7 +878,7 @@ fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &Pivot
         if f.group.is_some() {
             s.push_str(" numFmtId=\"14\"");
         }
-        let filter = layout.hidden_fields.get(&i).copied();
+        let filter = hidden.get(&i).copied();
         let labels = f.item_labels();
         let is_page = axis == Some("axisPage");
         // Hidden items; never hide every item (a field needs one visible item).
@@ -779,7 +893,7 @@ fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &Pivot
             s.push_str(" multipleItemSelectionAllowed=\"1\"");
         }
         s.push_str(" showAll=\"0\"");
-        if let Some(af) = axis_field(pt, c, i) {
+        if let Some(af) = axis_field(i) {
             match af.sort {
                 PivotSort::Asc => s.push_str(" sortType=\"ascending\""),
                 PivotSort::Desc => s.push_str(" sortType=\"descending\""),
@@ -792,8 +906,8 @@ fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &Pivot
         if !pt.subtotals_top {
             s.push_str(" subtotalTop=\"0\"");
         }
-        if axis.is_some() {
-            let collapsed: &[String] = axis_field(pt, c, i).map(|f| f.collapsed_items.as_slice()).unwrap_or(&[]);
+        if axis.is_some() || ((f.itemized || f.group.is_some()) && (hidden.contains_key(&i) || c.slicer_fields.contains(&i))) {
+            let collapsed: &[String] = axis_field(i).map(|f| f.collapsed_items.as_slice()).unwrap_or(&[]);
             let count = labels.len() + usize::from(pt.subtotals);
             let _ = write!(s, "><items count=\"{count}\">");
             for (x, l) in labels.iter().enumerate() {
@@ -817,17 +931,17 @@ fn write_pivot_fields(s: &mut String, pt: &PivotTable, c: &Cache, layout: &Pivot
     s.push_str("</pivotFields>");
 }
 
-fn write_page_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>) {
-    if layout.page_fields.is_empty() {
+fn write_page_fields(s: &mut String, c: &Cache, pages: &[(usize, &PivotFilter)]) {
+    if pages.is_empty() {
         return;
     }
-    let _ = write!(s, "<pageFields count=\"{}\">", layout.page_fields.len());
-    for (i, filter) in &layout.page_fields {
+    let _ = write!(s, "<pageFields count=\"{}\">", pages.len());
+    for (i, f) in pages {
         let _ = write!(s, "<pageField fld=\"{i}\"");
-        if let Some(selected) = &filter.selected
-            && selected.len() == 1
-            && let Some(one) = selected.first()
-            && let Some(x) = c.fields.get(*i).and_then(|field| field.item_labels().iter().position(|label| same(label, one)))
+        if let Some(sel) = &f.selected
+            && sel.len() == 1
+            && let Some(one) = sel.first()
+            && let Some(x) = c.fields.get(*i).and_then(|cf| cf.item_labels().iter().position(|l| same(l, one)))
         {
             let _ = write!(s, " item=\"{x}\"");
         }
@@ -836,31 +950,38 @@ fn write_page_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>) {
     s.push_str("</pageFields>");
 }
 
-fn write_data_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>, fmt_id: &dyn Fn(&str) -> Option<u32>) {
-    if layout.values.is_empty() {
+fn write_data_fields(
+    s: &mut String,
+    c: &Cache,
+    vals: &[(usize, &PivotValue)],
+    row_idx: &[usize],
+    col_idx: &[usize],
+    fmt_id: &dyn Fn(&str) -> Option<u32>,
+) {
+    if vals.is_empty() {
         return;
     }
-    let _ = write!(s, "<dataFields count=\"{}\">", layout.values.len());
+    let _ = write!(s, "<dataFields count=\"{}\">", vals.len());
     let mut used: Vec<String> = Vec::new();
-    for (i, value) in &layout.values {
-        let base = if value.name.trim().is_empty() {
-            format!("{} of {}", func_caption(value.func), c.fields.get(*i).map(|f| f.name.as_str()).unwrap_or(""))
+    for (i, v) in vals {
+        let base = if v.name.trim().is_empty() {
+            format!("{} of {}", func_caption(v.func), c.fields.get(*i).map(|f| f.name.as_str()).unwrap_or(""))
         } else {
-            value.name.clone()
+            v.name.clone()
         };
-        let mut name = base.clone();
-        let mut suffix = 2;
-        while used.iter().any(|existing| same(existing, &name)) {
-            name = format!("{base}{suffix}");
-            suffix += 1;
-        }
-        used.push(name.clone());
-        let _ = write!(s, "<dataField name=\"{}\" fld=\"{i}\"", esc_attr(&name));
-        if value.func != PivotFunc::Sum {
-            let _ = write!(s, " subtotal=\"{}\"", func_name(value.func));
-        }
-        let base_field = layout.row_fields.first().or(layout.column_fields.first()).copied().unwrap_or(0);
-        match value.show_as {
+        let mut n = base.clone();
+        let mut j = 2;
+        while used.iter().any(|u| same(u, &n)) {
+            n = format!("{base}{j}");
+            j += 1;
+        }
+        used.push(n.clone());
+        let _ = write!(s, "<dataField name=\"{}\" fld=\"{i}\"", esc_attr(&n));
+        if v.func != PivotFunc::Sum {
+            let _ = write!(s, " subtotal=\"{}\"", func_name(v.func));
+        }
+        let base_field = row_idx.first().or(col_idx.first()).copied().unwrap_or(0);
+        match v.show_as {
             PivotShowAs::Normal => s.push_str(" baseField=\"0\" baseItem=\"0\""),
             PivotShowAs::PercentOfGrandTotal => s.push_str(" showDataAs=\"percentOfTotal\" baseField=\"0\" baseItem=\"0\""),
             PivotShowAs::PercentOfColumnTotal => s.push_str(" showDataAs=\"percentOfCol\" baseField=\"0\" baseItem=\"0\""),
@@ -872,10 +993,10 @@ fn write_data_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>, f
                 let _ = write!(s, " baseField=\"{base_field}\" baseItem=\"0\"");
             }
         }
-        if let Some(id) = value.number_format.as_deref().and_then(fmt_id) {
+        if let Some(id) = v.number_format.as_deref().and_then(fmt_id) {
             let _ = write!(s, " numFmtId=\"{id}\"");
         }
-        if value.show_as == PivotShowAs::Rank {
+        if v.show_as == PivotShowAs::Rank {
             let _ = write!(
                 s,
                 "><extLst><ext uri=\"{EXT_X14_DATA_FIELD}\" xmlns:x14=\"{NS_X14}\"><x14:dataField pivotShowAs=\"rankDescending\"/></ext></extLst></dataField>"
@@ -887,6 +1008,55 @@ fn write_data_fields(s: &mut String, c: &Cache, layout: &PivotTableLayout<'_>, f
     s.push_str("</dataFields>");
 }
 
+fn source_fields_and_rows(sh: &gridcraft_model::Sheet, r: RangeRef) -> (Vec<CField>, Vec<u32>) {
+    let mut fields: Vec<CField> = Vec::new();
+    // Lower-case names taken, and the next suffix for each header (linear for repeated headers).
+    let mut taken = std::collections::HashSet::new();
+    let mut next_suffix: HashMap<String, usize> = HashMap::new();
+    for (k, c) in (r.start.col..=r.end.col).enumerate() {
+        let mut h = header_text(&sh.value(CellRef::new(r.start.row, c)).scalar());
+        if h.is_empty() {
+            h = format!("Column{}", k + 1);
+        }
+        let mut n = h.clone();
+        let mut i = next_suffix.get(&h.to_lowercase()).copied().unwrap_or(2);
+        while taken.contains(&n.to_lowercase()) {
+            n = format!("{h}{i}");
+            i += 1;
+        }
+        next_suffix.insert(h.to_lowercase(), i);
+        taken.insert(n.to_lowercase());
+        fields.push(CField {
+            name: n,
+            col: Some(k as u32),
+            stats: Stats::default(),
+            items: vec![],
+            index: HashMap::new(),
+            itemized: false,
+            group: None,
+            formula: None,
+        });
+    }
+
+    // Records (rows that aren't entirely blank), read once.
+    let mut rows: Vec<u32> = Vec::new();
+    if r.end.row > r.start.row {
+        for row in r.start.row + 1..=r.end.row {
+            let blank = (r.start.col..=r.end.col).all(|c| sh.value(CellRef::new(row, c)).scalar().is_empty());
+            if !blank {
+                rows.push(row);
+            }
+        }
+    }
+    for &row in &rows {
+        for f in fields.iter_mut() {
+            let c = r.start.col + f.col.unwrap_or(0);
+            f.stats.add(&sh.value(CellRef::new(row, c)).scalar());
+        }
+    }
+    (fields, rows)
+}
+
 /// `<rowFields>`/`<colFields>`: the axis's cache field indices, with Σ Values (`-2`) at `values_at`.
 fn axis_fields_xml(s: &mut String, tag: &str, idx: &[usize], values_at: Option<usize>) {
     let n = idx.len() + usize::from(values_at.is_some());
diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs
index 8b118ecdb9..6e849db9f5 100644
--- a/crates/xlsx/src/read.rs
+++ b/crates/xlsx/src/read.rs
@@ -32,6 +32,8 @@ pub struct Ctx<'a> {
     pub cell_pictures: Vec<Option<Arc<CellPicture>>>,
     /// x14 conditional-format ids of the current sheet's data bars, with the index of the rule in `cond_formats`.
     pub cf_ext_ids: Vec<(String, usize)>,
+    /// PivotTable slicer pieces collected from sheets, joined once sheets are read.
+    pub slicers: crate::slicer::SlicersIn,
 }
 
 impl Ctx<'_> {
@@ -238,6 +240,7 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         num_fmts: Default::default(),
         cell_pictures: vec![],
         cf_ext_ids: vec![],
+        slicers: Default::default(),
     };
     let root_rels = cx.pkg.rels("")?;
     let wb_part = find_rel(&root_rels, "officeDocument").map(|r| r.target.clone()).unwrap_or_else(|| "xl/workbook.xml".into());
@@ -321,6 +324,7 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> {
         wb.sheets.push(Arc::new(Sheet::new("Sheet1")));
     }
     wb.set_active_sheet(file_to_model.get(active_tab).copied().flatten().unwrap_or(0));
+    crate::slicer::resolve(&mut cx, &wb_xml, &wb_rels, &sheet_els, &file_to_model, &pivot_caches, &mut wb);
 
     // Defined names. Chartex parts refer to their data through hidden `_xlchart.*` names.
     let mut chart_names: Vec<(String, String)> = vec![];
diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs
index 7a37e41d81..1030513726 100644
--- a/crates/xlsx/src/sheet_read.rs
+++ b/crates/xlsx/src/sheet_read.rs
@@ -259,7 +259,10 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<Sheet, IoE
                     }
                 }
             }
-            "extLst" => read_ext(cx, e, &mut sheet),
+            "extLst" => {
+                read_ext(cx, e, &mut sheet);
+                crate::slicer::read_sheet_ext(cx, e, &rels, name);
+            }
             "protectedRanges" => read_protected_ranges(e, &mut sheet),
             _ => {}
         }
diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs
index 10bb3d21d5..9be3df826c 100644
--- a/crates/xlsx/src/sheet_write.rs
+++ b/crates/xlsx/src/sheet_write.rs
@@ -212,7 +212,7 @@ pub fn write_sheet(wb: &Workbook, si: usize, selected: bool, out: &mut Out) -> (
         }
         let _ = write!(s, "<tableParts count=\"{}\">{parts}</tableParts>", tables.len());
     }
-    write_sheet_extensions(&mut s, sheet, &prio);
+    write_sheet_extensions(&mut s, sheet, &prio, &out.slicers.on_sheet(si), out, &mut rels);
     s.push_str("</worksheet>");
     (s, rels)
 }
@@ -226,7 +226,7 @@ struct CellWriteInput<'a> {
     dynamic_range: Option<&'a RangeRef>,
 }
 
-fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32]) {
+fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32], slicers: &[crate::slicer::SheetSlicer], out: &mut Out, rels: &mut Rels) {
     // Excel 2010 extensions: solid data bars, then sparklines.
     let solid_bars: Vec<(&CondFormat, u32)> = sheet
         .cond_formats
@@ -235,7 +235,8 @@ fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32]) {
         .filter(|(_, cf)| !cf.ranges.is_empty() && matches!(cf.rule, CfRule::DataBar { gradient: false, .. }))
         .map(|(i, cf)| (cf, prio.get(i).copied().unwrap_or(1)))
         .collect();
-    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
+    let slicer_ext = crate::slicer::SlicerWriter::sheet_part(sheet, slicers, out, rels);
+    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() || !slicer_ext.is_empty() {
         s.push_str("<extLst>");
     }
     if !solid_bars.is_empty() {
@@ -273,7 +274,8 @@ fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32]) {
         }
         s.push_str("</x14:sparklineGroups></ext>");
     }
-    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() {
+    s.push_str(&slicer_ext);
+    if !solid_bars.is_empty() || !sheet.sparklines.is_empty() || !slicer_ext.is_empty() {
         s.push_str("</extLst>");
     }
 }
@@ -305,8 +307,9 @@ fn write_sheet_notes(s: &mut String, sheet: &Sheet, si: usize, kept: &crate::pas
 }
 
 fn write_sheet_drawing(s: &mut String, wb: &Workbook, si: usize, sheet: &Sheet, rels: &mut Rels, out: &mut Out) {
-    // Drawing: pictures, charts, shapes.
-    if !sheet.images.is_empty() || !sheet.charts.is_empty() || !sheet.shapes.is_empty() {
+    // Drawing: pictures, charts, shapes, slicers.
+    let slicers = out.slicers.on_sheet(si);
+    if !sheet.images.is_empty() || !sheet.charts.is_empty() || !sheet.shapes.is_empty() || !slicers.is_empty() {
         out.drawings += 1;
         let dn = out.drawings;
         let mut drels = Rels::default();
@@ -345,6 +348,11 @@ fn write_sheet_drawing(s: &mut String, wb: &Workbook, si: usize, sheet: &Sheet,
         for sh in &sheet.shapes {
             objs.push(Obj::Shape(sh));
         }
+        for p in &slicers {
+            if let Some(sl) = sheet.slicers.get(p.slicer) {
+                objs.push(Obj::Slicer(sl, p.name.clone()));
+            }
+        }
         out.part(&format!("xl/drawings/drawing{dn}.xml"), Some(CT_DRAWING), crate::drawing::write_drawing(sheet, &wb.theme, &objs).into_bytes());
         if !drels.is_empty() {
             out.part(&format!("xl/drawings/_rels/drawing{dn}.xml.rels"), None, drels.xml().into_bytes());
diff --git a/crates/xlsx/src/slicer.rs b/crates/xlsx/src/slicer.rs
new file mode 100644
index 0000000000..c58ec6d3bd
--- /dev/null
+++ b/crates/xlsx/src/slicer.rs
@@ -0,0 +1,584 @@
+//! PivotTable slicers (the Excel 2010 `x14` extension, [MS-XLSX] §2.3): a drawing frame
+//! (`sle:slicer`, in a markup-compatibility block with a fallback shape) places the slicer, a
+//! slicer part (`xl/slicers/slicerN.xml`, listed by the sheet's `x14:slicerList`) holds its
+//! caption and layout, and a slicer cache (`xl/slicerCaches/slicerCacheN.xml`, listed by the
+//! workbook's `x14:slicerCaches`) names the PivotTables, the field and the selected items.
+//!
+//! Reading: frames and slicer parts are collected while sheets are read, then [`resolve`] joins
+//! them with the slicer caches once the PivotTables exist. The selection lives in the model as the
+//! PivotTables' filters on the field (read from their hidden items); a cache's `s` flags only fill
+//! in a PivotTable that has no filter on the field. Table and OLAP slicers, and slicers on a
+//! coarser date level that has its own cache field, are skipped with a warning.
+//!
+//! Writing: [`SlicerWriter`] plans the slicers before the sheets are written, so the PivotTable
+//! writer can give their fields shared items and their caches an id; the sheets write the frames
+//! and slicer parts and [`SlicerWriter::finish`] the caches.
+
+use std::fmt::Write as _;
+
+use gridcraft_model::{
+    Anchor, PivotDateGroup, PivotFilter, PivotSort, PivotTable, Sheet, Slicer, SlicerCrossFilter, SlicerPivot, SlicerSource, Workbook,
+};
+
+use crate::package::Rel;
+use crate::read::Ctx;
+use crate::tables::EMU_PER_PX;
+use crate::write::{Out, Rels, XML_DECL};
+use crate::xml::{El, esc_attr};
+
+pub const CT_SLICER: &str = "application/vnd.ms-excel.slicer+xml";
+pub const CT_SLICER_CACHE: &str = "application/vnd.ms-excel.slicerCache+xml";
+const REL_SLICER: &str = "http://schemas.microsoft.com/office/2007/relationships/slicer";
+const REL_SLICER_CACHE: &str = "http://schemas.microsoft.com/office/2007/relationships/slicerCache";
+const NS_X14: &str = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
+const NS_MC: &str = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+/// `a:graphicData` uri (and `sle` namespace) of a slicer frame.
+pub const FRAME_URI: &str = "http://schemas.microsoft.com/office/drawing/2010/slicer";
+const EXT_SHEET_SLICERS: &str = "{A8765BA9-456A-4dab-B4F3-ACF838C121DE}";
+const EXT_WB_SLICER_CACHES: &str = "{BBE1A952-AA13-448e-AADC-164F8A28A991}";
+/// Excel's default button height (EMU), written when the model has none.
+const DEFAULT_ROW_HEIGHT: u32 = 241_300;
+/// Most items read from one slicer cache.
+const MAX_ITEMS: usize = 1_048_576;
+/// Most slicers read from one workbook.
+const MAX_SLICERS: usize = 4096;
+
+// ---------------------------------------------------------------- reading
+
+/// Slicer pieces found while reading sheets.
+#[derive(Default)]
+pub struct SlicersIn {
+    /// (sheet name, slicer name, anchor) of the `sle:slicer` drawing frames.
+    frames: Vec<(String, String, Anchor)>,
+    /// (sheet name, slicer) of the slicers the sheets list.
+    parts: Vec<(String, PartIn)>,
+}
+
+/// One `<slicer>` of a slicer part.
+struct PartIn {
+    name: String,
+    cache: String,
+    caption: String,
+    columns: u32,
+    style: String,
+    row_height: Option<f32>,
+}
+
+/// A slicer cache definition.
+struct CacheDef {
+    name: String,
+    source: String,
+    /// (`tabId`, PivotTable name).
+    pivots: Vec<(u32, String)>,
+    /// `None`: not a PivotTable (tabular) cache.
+    tabular: Option<Tabular>,
+}
+
+struct Tabular {
+    cache_id: Option<u32>,
+    sort: PivotSort,
+    cross: SlicerCrossFilter,
+    show_missing: bool,
+    /// (shared item index, selected).
+    items: Vec<(u32, bool)>,
+}
+
+/// Records a drawing frame's slicer; returns false when `gd` is not a slicer frame.
+pub fn read_frame(cx: &mut Ctx<'_>, sheet: &str, gd: &El, anchor: Anchor) -> bool {
+    if gd.attr("uri") != Some(FRAME_URI) {
+        return false;
+    }
+    let Some(name) = gd.child("slicer").and_then(|s| s.attr("name")) else { return false };
+    if cx.slicers.frames.len() < MAX_SLICERS {
+        cx.slicers.frames.push((sheet.to_string(), name.to_string(), anchor));
+    }
+    true
+}
+
+/// Reads the slicer parts a worksheet's `extLst` lists (`x14:slicerList`).
+pub fn read_sheet_ext(cx: &mut Ctx<'_>, ext_lst: &El, rels: &[Rel], sheet: &str) {
+    for list in ext_lst.kids("ext").flat_map(|e| e.kids("slicerList")) {
+        for sl in list.kids("slicer") {
+            let Some(rel) = sl.attr("id").and_then(|id| rels.iter().find(|r| r.id == id && !r.external)) else { continue };
+            let target = rel.target.clone();
+            let Ok(Some(x)) = cx.optional_xml(&target) else { continue };
+            for s in x.kids("slicer") {
+                if cx.slicers.parts.len() >= MAX_SLICERS {
+                    return;
+                }
+                let part = PartIn {
+                    name: s.attr("name").unwrap_or("").to_string(),
+                    cache: s.attr("cache").unwrap_or("").to_string(),
+                    caption: s.attr("caption").unwrap_or("").to_string(),
+                    columns: s.attr_u32("columnCount").unwrap_or(1).clamp(1, 20_000),
+                    style: s.attr("style").unwrap_or("").to_string(),
+                    row_height: s.attr_u32("rowHeight").filter(|h| *h > 0).map(|h| (h as f64 / EMU_PER_PX) as f32),
+                };
+                cx.slicers.parts.push((sheet.to_string(), part));
+            }
+        }
+    }
+}
+
+fn read_cache_def(x: &El) -> Option<CacheDef> {
+    if x.name != "slicerCacheDefinition" {
+        return None;
+    }
+    let pivots = x
+        .child("pivotTables")
+        .map(|p| p.kids("pivotTable").filter_map(|t| Some((t.attr_u32("tabId")?, t.attr("name")?.to_string()))).collect())
+        .unwrap_or_default();
+    let tabular = x.path(&["data", "tabular"]).map(|t| Tabular {
+        cache_id: t.attr_u32("pivotCacheId"),
+        sort: if t.attr("sortOrder") == Some("descending") { PivotSort::Desc } else { PivotSort::Asc },
+        cross: match t.attr("crossFilter") {
+            Some("none") => SlicerCrossFilter::None,
+            Some("showItemsWithNoData") => SlicerCrossFilter::ShowItemsWithNoData,
+            _ => SlicerCrossFilter::ShowItemsWithDataAtTop,
+        },
+        show_missing: t.flag("showMissing", true),
+        items: t
+            .child("items")
+            .map(|i| i.kids("i").filter_map(|e| Some((e.attr_u32("x")?, e.flag("s", false)))).take(MAX_ITEMS).collect())
+            .unwrap_or_default(),
+    });
+    Some(CacheDef { name: x.attr("name").unwrap_or("").to_string(), source: x.attr("sourceName").unwrap_or("").to_string(), pivots, tabular })
+}
+
+/// Joins the collected frames and slicer parts with the workbook's slicer caches and adds the
+/// PivotTable slicers to their sheets. `sheet_els` are the workbook's `<sheet>` elements and
+/// `file_to_model` maps each to a model sheet.
+pub fn resolve(
+    cx: &mut Ctx<'_>,
+    wb_xml: &El,
+    wb_rels: &[Rel],
+    sheet_els: &[El],
+    file_to_model: &[Option<usize>],
+    caches: &crate::pivot::CachesIn,
+    wb: &mut Workbook,
+) {
+    let found = std::mem::take(&mut cx.slicers);
+    if found.frames.is_empty() && found.parts.is_empty() {
+        return;
+    }
+    let mut defs: Vec<CacheDef> = Vec::new();
+    let lists = wb_xml.child("extLst").map(|l| l.kids("ext").flat_map(|e| e.kids("slicerCaches")).collect::<Vec<_>>()).unwrap_or_default();
+    for c in lists.iter().flat_map(|l| l.kids("slicerCache")) {
+        let Some(rel) = c.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id && !r.external)) else { continue };
+        let target = rel.target.clone();
+        if let Ok(Some(x)) = cx.optional_xml(&target)
+            && let Some(d) = read_cache_def(&x)
+            && defs.len() < MAX_SLICERS
+        {
+            defs.push(d);
+        }
+    }
+    // `tabId` is the `sheetId` of the PivotTable's sheet.
+    let sheet_of_tab = |tab: u32| -> Option<usize> {
+        let i = sheet_els.iter().position(|s| s.attr_u32("sheetId") == Some(tab))?;
+        file_to_model.get(i).copied().flatten()
+    };
+    let mut used = vec![false; found.frames.len()];
+    for (sheet_name, part) in found.parts {
+        let Some(si) = wb.sheet_index(&sheet_name) else { continue };
+        // The part's frame is accounted for even when the slicer is skipped below with its own
+        // warning.
+        let fi = found.frames.iter().position(|(s, n, _)| s.eq_ignore_ascii_case(&sheet_name) && n.eq_ignore_ascii_case(&part.name));
+        if let Some(u) = fi.and_then(|i| used.get_mut(i)) {
+            *u = true;
+        }
+        let Some(def) = defs.iter().find(|d| d.name.eq_ignore_ascii_case(&part.cache)) else {
+            cx.warn(format!("slicer \"{}\" has no slicer cache and was skipped", part.name));
+            continue;
+        };
+        let Some(tab) = &def.tabular else {
+            cx.warn(format!("slicer \"{}\" filters a table or an external data source, which is not supported; skipped", part.name));
+            continue;
+        };
+        // The model's slicer filters a source column; a cache field that isn't one (a coarser date
+        // level Excel keeps in its own field, such as "Years" over "Date") can't be filtered or
+        // saved.
+        let Some(cache_id) = tab.cache_id.filter(|id| caches.has_slicer_cache(*id)) else {
+            cx.warn(format!("slicer \"{}\" has no resolvable PivotTable cache; skipped", part.name));
+            continue;
+        };
+        if let Some(other) = caches.slicer_non_source(cache_id, &def.source) {
+            cx.warn(match other {
+                crate::pivot::NonSourceField::DateLevel { base } => {
+                    format!(
+                        "slicer \"{}\" filters \"{}\", a coarser date level of \"{base}\", which is not supported; skipped",
+                        part.name, def.source
+                    )
+                }
+                crate::pivot::NonSourceField::Other => {
+                    format!("slicer \"{}\" filters \"{}\", which is not a column of its PivotTable's source; skipped", part.name, def.source)
+                }
+            });
+            continue;
+        }
+        // The connected PivotTables that were read: (sheet, index).
+        let targets: Vec<(usize, usize)> = def
+            .pivots
+            .iter()
+            .filter_map(|(t, name)| {
+                let psi = sheet_of_tab(*t)?;
+                let pi = wb.sheet(psi)?.pivots.iter().position(|p| p.name.eq_ignore_ascii_case(name))?;
+                Some((psi, pi))
+            })
+            .collect();
+        if targets.is_empty() || def.source.trim().is_empty() {
+            cx.warn(format!("slicer \"{}\": its PivotTable is missing or could not be read; skipped", part.name));
+            continue;
+        }
+        let Some(&(_, _, anchor)) = fi.and_then(|i| found.frames.get(i)) else {
+            cx.warn(format!("slicer \"{}\" has no drawing frame and was skipped", part.name));
+            continue;
+        };
+        // The cache field's items and date grouping. A PivotTable without a filter on the field
+        // takes the cache's selection; with everything selected it still keeps the field's
+        // grouping (the cache field's, ECMA-376 §18.10.1.33) when no Rows/Columns field has it.
+        let field = caches.slicer_labels(cache_id, &def.source);
+        let group = field.map(|(_, g)| g).unwrap_or_default();
+        let selected: Option<Vec<String>> = field.and_then(|(labels, _)| {
+            let sel: Vec<String> = tab.items.iter().filter(|(_, s)| *s).filter_map(|(x, _)| labels.get(*x as usize).cloned()).collect();
+            (tab.items.iter().any(|(_, s)| !s) && !sel.is_empty()).then_some(sel)
+        });
+        for &(psi, pi) in &targets {
+            let Some(pt) = wb.sheet_mut(psi).and_then(|sh| sh.pivots.get_mut(pi)) else { continue };
+            if pt.filters.iter().any(|f| f.source_col.eq_ignore_ascii_case(&def.source)) {
+                continue;
+            }
+            match &selected {
+                Some(sel) => pt.set_filter(&def.source, Some(sel.clone()), group),
+                None if group != PivotDateGroup::None && pt.field_group(&def.source) != group => {
+                    pt.filters.push(PivotFilter { source_col: def.source.clone(), selected: None, hidden: true, date_group: group });
+                    pt.normalize_filter_groups();
+                }
+                None => {}
+            }
+        }
+        let pivots = targets
+            .iter()
+            .filter_map(|&(psi, pi)| {
+                let sh = wb.sheet(psi)?;
+                Some(SlicerPivot { sheet: sh.name.clone(), name: sh.pivots.get(pi)?.name.clone() })
+            })
+            .collect();
+        let id = cx.next_object_id();
+        let slicer = Slicer {
+            id,
+            source: SlicerSource::Pivot {
+                pivots,
+                field: def.source.clone(),
+                sort: tab.sort,
+                cross_filter: tab.cross,
+                show_missing: tab.show_missing,
+            },
+            caption: part.caption,
+            anchor,
+            columns: part.columns,
+            name: part.name,
+            style: part.style,
+            row_height: part.row_height,
+        };
+        if let Some(sh) = wb.sheet_mut(si) {
+            sh.slicers.push(slicer);
+        }
+    }
+    for ((_, name, _), u) in found.frames.iter().zip(used) {
+        if !u {
+            cx.warn(format!("slicer \"{name}\" was skipped (only PivotTable slicers are supported)"));
+        }
+    }
+}
+
+// ---------------------------------------------------------------- writing
+
+/// A slicer to write.
+struct Planned {
+    sheet: usize,
+    /// Index in the sheet's slicers.
+    slicer: usize,
+    /// Unique slicer name.
+    name: String,
+    /// Unique slicer cache name (also a workbook defined name).
+    cache: String,
+    field: String,
+    /// The connected PivotTables written (sheet, index), which share one pivot cache.
+    pivots: Vec<(usize, usize)>,
+}
+
+/// A slicer on the sheet being written: its index in the sheet's slicers, name and cache name.
+pub struct SheetSlicer {
+    pub slicer: usize,
+    pub name: String,
+    pub cache: String,
+}
+
+/// The PivotTable slicers of a workbook being written.
+#[derive(Default)]
+pub struct SlicerWriter {
+    planned: Vec<Planned>,
+    /// PivotTables (sheet, index) written with one pivot cache: those the same slicers connect.
+    groups: Vec<Vec<(usize, usize)>>,
+    parts: u32,
+}
+
+impl SlicerWriter {
+    /// Plans the PivotTable slicers whose PivotTables can be written. A slicer's PivotTables must
+    /// share a pivot cache; where they can't (different sources or date grouping), the slicer
+    /// keeps only its first PivotTable.
+    pub fn new(wb: &Workbook) -> SlicerWriter {
+        let mut planned: Vec<Planned> = Vec::new();
+        let mut names: Vec<String> = Vec::new();
+        let mut caches: Vec<String> = Vec::new();
+        for (si, sheet) in wb.sheets.iter().enumerate() {
+            for (i, sl) in sheet.slicers.iter().enumerate() {
+                let SlicerSource::Pivot { pivots, field, .. } = &sl.source else { continue };
+                let mut targets: Vec<(usize, usize)> = Vec::new();
+                for p in pivots {
+                    let Some(psi) = wb.sheet_index(&p.sheet) else { continue };
+                    let Some(sh) = wb.sheet(psi) else { continue };
+                    let Some(pi) = sh.pivots.iter().position(|t| t.name.eq_ignore_ascii_case(&p.name)) else { continue };
+                    let ok = sh.pivots.get(pi).is_some_and(|pt| crate::pivot::slicer_field_ok(wb, pt, psi, field));
+                    if ok && !targets.contains(&(psi, pi)) {
+                        targets.push((psi, pi));
+                    }
+                }
+                if targets.is_empty() {
+                    continue;
+                }
+                let base = [sl.name.trim(), sl.caption.trim(), field.trim()].into_iter().find(|n| !n.is_empty()).unwrap_or("Slicer");
+                let name = unique(base, " ", &mut names);
+                let clean: String = field.chars().map(|c| if c.is_alphanumeric() || c == '_' { c } else { '_' }).collect();
+                let cache = unique(&format!("Slicer_{clean}"), "", &mut caches);
+                planned.push(Planned { sheet: si, slicer: i, name, cache, field: field.clone(), pivots: targets });
+            }
+        }
+        let mut groups = merge_groups(&planned);
+        let mut split = false;
+        for g in groups.iter().filter(|g| g.len() > 1) {
+            if !crate::pivot::can_share(wb, g, &group_fields(&planned, g)) {
+                for p in planned.iter_mut().filter(|p| p.pivots.iter().any(|x| g.contains(x))) {
+                    p.pivots.truncate(1);
+                }
+                split = true;
+            }
+        }
+        if split {
+            groups = merge_groups(&planned);
+        }
+        SlicerWriter { planned, groups, parts: 0 }
+    }
+
+    /// The PivotTables written with the same pivot cache as PivotTable `pi` on sheet `si`
+    /// (itself included), when slicers connect it.
+    pub fn cache_group(&self, si: usize, pi: usize) -> Option<Vec<(usize, usize)>> {
+        self.groups.iter().find(|g| g.contains(&(si, pi))).cloned()
+    }
+
+    /// Fields that slicers filter in the pivot cache of PivotTable `pi` on sheet `si`.
+    pub fn fields_for(&self, si: usize, pi: usize) -> Vec<String> {
+        self.groups.iter().find(|g| g.contains(&(si, pi))).map(|g| group_fields(&self.planned, g)).unwrap_or_default()
+    }
+
+    /// The slicers to write on sheet `si`.
+    pub fn on_sheet(&self, si: usize) -> Vec<SheetSlicer> {
+        self.planned
+            .iter()
+            .filter(|p| p.sheet == si)
+            .map(|p| SheetSlicer { slicer: p.slicer, name: p.name.clone(), cache: p.cache.clone() })
+            .collect()
+    }
+
+    /// Whether `name` is a slicer cache name (written as a defined name by the writer).
+    pub fn is_cache_name(&self, name: &str) -> bool {
+        self.planned.iter().any(|p| p.cache.eq_ignore_ascii_case(name))
+    }
+
+    /// `<definedName>` elements Excel keeps for slicer caches.
+    pub fn defined_names(&self) -> String {
+        self.planned.iter().map(|p| format!("<definedName name=\"{}\">#N/A</definedName>", esc_attr(&p.cache))).collect()
+    }
+
+    /// Writes a sheet's slicer part and relationship; returns the sheet's `x14:slicerList`
+    /// extension (empty when the sheet has none).
+    pub fn sheet_part(sheet: &Sheet, list: &[SheetSlicer], out: &mut Out, rels: &mut Rels) -> String {
+        if list.is_empty() {
+            return String::new();
+        }
+        let mut x = format!("{XML_DECL}<slicers xmlns=\"{NS_X14}\" xmlns:mc=\"{NS_MC}\" mc:Ignorable=\"x\" xmlns:x=\"{}\">", crate::write::NS_MAIN);
+        let mut any = false;
+        for p in list {
+            let Some(sl) = sheet.slicers.get(p.slicer) else { continue };
+            any = true;
+            let _ = write!(x, "<slicer name=\"{}\" cache=\"{}\"", esc_attr(&p.name), esc_attr(&p.cache));
+            if !sl.caption.is_empty() {
+                let _ = write!(x, " caption=\"{}\"", esc_attr(&sl.caption));
+            }
+            if sl.columns > 1 {
+                let _ = write!(x, " columnCount=\"{}\"", sl.columns.min(20_000));
+            }
+            if let Some(st) = builtin_style(&sl.style) {
+                let _ = write!(x, " style=\"{st}\"");
+            }
+            let h = sl.row_height.filter(|h| h.is_finite() && *h > 0.0).map(|h| (h as f64 * EMU_PER_PX).round().min(u32::MAX as f64) as u32);
+            let _ = write!(x, " rowHeight=\"{}\"/>", h.unwrap_or(DEFAULT_ROW_HEIGHT));
+        }
+        if !any {
+            return String::new();
+        }
+        x.push_str("</slicers>");
+        out.slicers.parts += 1;
+        let n = out.slicers.parts;
+        out.part(&format!("xl/slicers/slicer{n}.xml"), Some(CT_SLICER), x.into_bytes());
+        let rid = rels.add_uri(REL_SLICER, &format!("../slicers/slicer{n}.xml"));
+        format!("<ext uri=\"{EXT_SHEET_SLICERS}\" xmlns:x14=\"{NS_X14}\"><x14:slicerList><x14:slicer r:id=\"{rid}\"/></x14:slicerList></ext>")
+    }
+
+    /// Writes the slicer caches; returns the workbook `extLst`'s `ext` listing them (empty when
+    /// there are none). `sheet_ids` is the `sheetId` written for each model sheet, which a cache's
+    /// `tabId` names.
+    pub fn finish(self, wb: &Workbook, sheet_ids: &[usize], pivots: &crate::pivot::PivotWriter, out: &mut Out, wb_rels: &mut Rels) -> String {
+        let mut list = String::new();
+        for (k, p) in self.planned.iter().enumerate() {
+            // The connected PivotTables that were written, with their (shared) cache's data.
+            let written: Vec<((usize, usize), &PivotTable, &crate::pivot::PivotSlicerInfo)> =
+                p.pivots.iter().filter_map(|&(psi, pi)| Some(((psi, pi), wb.sheet(psi)?.pivots.get(pi)?, pivots.slicer_info(psi, pi)?))).collect();
+            let Some(&(_, pt, info)) = written.first() else { continue };
+            let Some(sl) = wb.sheet(p.sheet).and_then(|s| s.slicers.get(p.slicer)) else { continue };
+            let SlicerSource::Pivot { sort, cross_filter, show_missing, .. } = &sl.source else { continue };
+            let field = info.fields.iter().find(|f| f.name.eq_ignore_ascii_case(&p.field));
+            let labels: &[String] = field.map(|f| f.labels.as_slice()).unwrap_or(&[]);
+            // The selection at the base cache field's level (the items written below).
+            let level = pt.field_group(&p.field);
+            let sel = pt
+                .filters
+                .iter()
+                .find(|f| f.source_col.eq_ignore_ascii_case(&p.field) && pt.filter_group(f) == level)
+                .and_then(|f| f.selected.as_deref());
+            let mut on: Vec<bool> = labels.iter().map(|l| sel.is_none_or(|s| s.iter().any(|x| x.eq_ignore_ascii_case(l)))).collect();
+            if !on.contains(&true) {
+                on.iter_mut().for_each(|o| *o = true);
+            }
+            // Date groups are in date order already; other items sort by value.
+            let mut order: Vec<usize> = (0..labels.len()).collect();
+            match (sort, field.is_some_and(|f| f.grouped)) {
+                (PivotSort::Asc, false) => order.sort_by(|a, b| cmp_label(&labels[*a], &labels[*b])),
+                (PivotSort::Desc, false) => order.sort_by(|a, b| cmp_label(&labels[*b], &labels[*a])),
+                (PivotSort::Desc, true) => order.reverse(),
+                (PivotSort::Asc | PivotSort::None, true) | (PivotSort::None, false) => {}
+            }
+            let mut x = format!(
+                "{XML_DECL}<slicerCacheDefinition xmlns=\"{NS_X14}\" xmlns:mc=\"{NS_MC}\" mc:Ignorable=\"x\" xmlns:x=\"{}\" name=\"{}\" sourceName=\"{}\"><pivotTables>",
+                crate::write::NS_MAIN,
+                esc_attr(&p.cache),
+                esc_attr(&p.field),
+            );
+            for &((psi, pi), t, i) in &written {
+                if i.cache_id != info.cache_id {
+                    continue;
+                }
+                let Some(tab) = sheet_ids.get(psi) else { continue };
+                let pname = if t.name.trim().is_empty() { format!("PivotTable{}", pi + 1) } else { t.name.clone() };
+                let _ = write!(x, "<pivotTable tabId=\"{tab}\" name=\"{}\"/>", esc_attr(&pname));
+            }
+            let _ = write!(x, "</pivotTables><data><tabular pivotCacheId=\"{}\"", info.cache_id);
+            if *sort == PivotSort::Desc {
+                x.push_str(" sortOrder=\"descending\"");
+            }
+            if !show_missing {
+                x.push_str(" showMissing=\"0\"");
+            }
+            match cross_filter {
+                SlicerCrossFilter::None => x.push_str(" crossFilter=\"none\""),
+                SlicerCrossFilter::ShowItemsWithNoData => x.push_str(" crossFilter=\"showItemsWithNoData\""),
+                SlicerCrossFilter::ShowItemsWithDataAtTop => {}
+            }
+            let _ = write!(x, "><items count=\"{}\">", order.len());
+            for i in order {
+                let _ = write!(x, "<i x=\"{i}\"{}/>", if on[i] { " s=\"1\"" } else { "" });
+            }
+            x.push_str("</items></tabular></data></slicerCacheDefinition>");
+            let part = format!("slicerCaches/slicerCache{}.xml", k + 1);
+            out.part(&format!("xl/{part}"), Some(CT_SLICER_CACHE), x.into_bytes());
+            let rid = wb_rels.add_uri(REL_SLICER_CACHE, &part);
+            let _ = write!(list, "<x14:slicerCache r:id=\"{rid}\"/>");
+        }
+        if list.is_empty() {
+            return String::new();
+        }
+        format!("<ext uri=\"{EXT_WB_SLICER_CACHES}\" xmlns:x14=\"{NS_X14}\"><x14:slicerCaches>{list}</x14:slicerCaches></ext>")
+    }
+}
+
+/// The PivotTables (sheet, index) that must share a pivot cache: each slicer's, merged where
+/// slicers have a PivotTable in common.
+fn merge_groups(planned: &[Planned]) -> Vec<Vec<(usize, usize)>> {
+    let mut groups: Vec<Vec<(usize, usize)>> = Vec::new();
+    for p in planned {
+        let mut g = p.pivots.clone();
+        let (overlap, rest): (Vec<_>, Vec<_>) = std::mem::take(&mut groups).into_iter().partition(|o| o.iter().any(|x| g.contains(x)));
+        groups = rest;
+        for x in overlap.into_iter().flatten() {
+            if !g.contains(&x) {
+                g.push(x);
+            }
+        }
+        groups.push(g);
+    }
+    groups
+}
+
+/// The fields that the slicers on the PivotTables `group` filter.
+fn group_fields(planned: &[Planned], group: &[(usize, usize)]) -> Vec<String> {
+    let mut v: Vec<String> = Vec::new();
+    for p in planned.iter().filter(|p| p.pivots.iter().any(|x| group.contains(x))) {
+        if !v.iter().any(|f| f.eq_ignore_ascii_case(&p.field)) {
+            v.push(p.field.clone());
+        }
+    }
+    v
+}
+
+/// `base`, or `base{sep}2`, `base{sep}3`… if taken (case-insensitively); records the result.
+fn unique(base: &str, sep: &str, taken: &mut Vec<String>) -> String {
+    let mut n = base.to_string();
+    let mut i = 2;
+    while taken.iter().any(|t| t.eq_ignore_ascii_case(&n)) {
+        n = format!("{base}{sep}{i}");
+        i += 1;
+    }
+    taken.push(n.clone());
+    n
+}
+
+/// Ascending item order: numbers (dates are serials) by value, before text by case-insensitive
+/// text.
+fn cmp_label(a: &str, b: &str) -> std::cmp::Ordering {
+    match (a.parse::<f64>().ok().filter(|n| n.is_finite()), b.parse::<f64>().ok().filter(|n| n.is_finite())) {
+        (Some(x), Some(y)) => x.total_cmp(&y),
+        (Some(_), None) => std::cmp::Ordering::Less,
+        (None, Some(_)) => std::cmp::Ordering::Greater,
+        (None, None) => a.to_lowercase().cmp(&b.to_lowercase()),
+    }
+}
+
+/// A built-in slicer style name to write: the style itself, or the built-in a custom copy is named
+/// after (`SlicerStyleDark1 2`). Custom style definitions aren't written, so other names are
+/// dropped and Excel uses its default.
+fn builtin_style(style: &str) -> Option<&str> {
+    let base = style.split_whitespace().next()?;
+    let ok =
+        ["SlicerStyleLight", "SlicerStyleDark"].iter().any(|p| base.strip_prefix(p).is_some_and(|n| matches!(n, "1" | "2" | "3" | "4" | "5" | "6")))
+            || matches!(base, "SlicerStyleOther1" | "SlicerStyleOther2");
+    ok.then_some(base)
+}
+
+/// The drawing XML of a slicer frame, with a fallback shape for readers without slicers.
+pub fn frame_xml(id: usize, name: &str, xfrm: &str, a_xfrm: &str) -> String {
+    format!(
+        "<mc:AlternateContent xmlns:mc=\"{NS_MC}\"><mc:Choice xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" Requires=\"a14\"><xdr:graphicFrame macro=\"\"><xdr:nvGraphicFramePr><xdr:cNvPr id=\"{id}\" name=\"{n}\"/><xdr:cNvGraphicFramePr/></xdr:nvGraphicFramePr>{xfrm}<a:graphic><a:graphicData uri=\"{FRAME_URI}\"><sle:slicer xmlns:sle=\"{FRAME_URI}\" name=\"{n}\"/></a:graphicData></a:graphic></xdr:graphicFrame></mc:Choice><mc:Fallback><xdr:sp macro=\"\" textlink=\"\"><xdr:nvSpPr><xdr:cNvPr id=\"0\" name=\"\"/><xdr:cNvSpPr><a:spLocks noTextEdit=\"1\"/></xdr:cNvSpPr></xdr:nvSpPr><xdr:spPr>{a_xfrm}<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></xdr:spPr><xdr:txBody><a:bodyPr vertOverflow=\"clip\" horzOverflow=\"clip\"/><a:lstStyle/><a:p><a:r><a:rPr lang=\"en-US\" sz=\"1100\"/><a:t>This is a PivotTable slicer. Slicers need Excel 2010 or later.</a:t></a:r></a:p></xdr:txBody></xdr:sp></mc:Fallback></mc:AlternateContent>",
+        n = esc_attr(name)
+    )
+}
diff --git a/crates/xlsx/src/tests/passthrough_tests.rs b/crates/xlsx/src/tests/passthrough_tests.rs
index 28113be0d5..8731477521 100644
--- a/crates/xlsx/src/tests/passthrough_tests.rs
+++ b/crates/xlsx/src/tests/passthrough_tests.rs
@@ -760,6 +760,59 @@ fn chart_sheets_survive_a_round_trip_in_place() {
     assert_eq!(written_sheets(&again), written_sheets(&u));
 }
 
+/// A slicer cache names its PivotTable's sheet by that sheet's `sheetId`, which counts the chart
+/// sheets kept between the worksheets: "More" is the third sheet in the file.
+#[test]
+fn a_slicer_cache_names_its_pivot_sheet_by_the_written_sheet_id() {
+    use gridcraft_core::{CellRef, Value};
+    use gridcraft_model::{Anchor, PivotField, PivotFunc, PivotTable, PivotValue, Slicer, SlicerCrossFilter, SlicerPivot, SlicerSource};
+    let (mut wb, _) = read_xlsx(&chartsheet_package()).unwrap();
+    let data = wb.sheet_mut(0).unwrap();
+    for (r, (region, sales)) in [("Region", None), ("East", Some(10.0)), ("West", Some(20.0))].into_iter().enumerate() {
+        data.set_value(CellRef::new(r as u32, 0), Value::text(region));
+        data.set_value(CellRef::new(r as u32, 1), sales.map_or(Value::text("Sales"), Value::Number));
+    }
+    let more = wb.sheet_mut(1).unwrap();
+    more.pivots.push(PivotTable {
+        id: 1,
+        name: "P1".into(),
+        source: "Data!$A$1:$B$3".into(),
+        anchor: CellRef::new(3, 0),
+        rows: vec![PivotField { source_col: "Region".into(), ..PivotField::default() }],
+        values: vec![PivotValue { source_col: "Sales".into(), func: PivotFunc::Sum, name: "Sum of Sales".into(), ..PivotValue::default() }],
+        ..PivotTable::default()
+    });
+    more.slicers.push(Slicer {
+        id: 1,
+        source: SlicerSource::Pivot {
+            pivots: vec![SlicerPivot { sheet: "More".into(), name: "P1".into() }],
+            field: "Region".into(),
+            sort: Default::default(),
+            cross_filter: SlicerCrossFilter::default(),
+            show_missing: true,
+        },
+        caption: "Region".into(),
+        anchor: Anchor { cell: CellRef::new(2, 5), dx: 0.0, dy: 0.0, width: 180.0, height: 200.0, mode: Default::default() },
+        columns: 1,
+        name: "Region".into(),
+        style: String::new(),
+        row_height: None,
+    });
+    let out = write_xlsx(&wb).unwrap();
+    let u = Unpacked::new(&out);
+    u.assert_valid();
+    let wbx = xml::parse(u.parts.get("xl/workbook.xml").unwrap()).unwrap();
+    let sheet_id = wbx.child("sheets").unwrap().kids("sheet").find(|s| s.attr("name") == Some("More")).unwrap().attr("sheetId").unwrap().to_string();
+    let cache = u.text("xl/slicerCaches/slicerCache1.xml");
+    assert_eq!(attr_of(&cache, "pivotTable", "tabId"), sheet_id, "{cache}");
+
+    let (back, rep) = read_xlsx(&out).unwrap();
+    assert!(!rep.warnings.iter().any(|w| w.contains("slicer")), "{:?}", rep.warnings);
+    let slicers = &back.sheet(1).unwrap().slicers;
+    assert_eq!(slicers.len(), 1);
+    assert_eq!(slicers[0].source, wb.sheet(1).unwrap().slicers[0].source);
+}
+
 #[test]
 fn a_chart_sheet_whose_data_sheet_was_renamed_is_dropped_with_its_parts() {
     let (mut wb, _) = read_xlsx(&chartsheet_package()).unwrap();
diff --git a/crates/xlsx/src/tests/pivot_tests.rs b/crates/xlsx/src/tests/pivot_tests.rs
index 111eacd470..6db6ec061e 100644
--- a/crates/xlsx/src/tests/pivot_tests.rs
+++ b/crates/xlsx/src/tests/pivot_tests.rs
@@ -105,7 +105,7 @@ fn workbook() -> Workbook {
                 ..PivotValue::default()
             },
         ],
-        filters: vec![PivotFilter { source_col: "Channel".into(), selected: Some(vec!["Online".into()]) }],
+        filters: vec![PivotFilter { source_col: "Channel".into(), selected: Some(vec!["Online".into()]), ..PivotFilter::default() }],
         layout: PivotLayout::Tabular,
         enable_show_details: false,
         grand_totals_rows: false,
@@ -163,8 +163,8 @@ fn workbook() -> Workbook {
             },
         ],
         filters: vec![
-            PivotFilter { source_col: "Region".into(), selected: Some(vec!["East".into(), "North".into()]) },
-            PivotFilter { source_col: "Product".into(), selected: Some(vec!["A".into(), "B".into()]) },
+            PivotFilter { source_col: "Region".into(), selected: Some(vec!["East".into(), "North".into()]), ..PivotFilter::default() },
+            PivotFilter { source_col: "Product".into(), selected: Some(vec!["A".into(), "B".into()]), ..PivotFilter::default() },
         ],
         layout: PivotLayout::Outline,
         enable_show_details: true,
@@ -187,7 +187,7 @@ fn workbook() -> Workbook {
         anchor: at("AB1"),
         rows: vec![field("Product")],
         values: vec![PivotValue { source_col: "Units".into(), func: PivotFunc::Product, name: "Product of Units".into(), ..PivotValue::default() }],
-        filters: vec![PivotFilter { source_col: "Channel".into(), selected: None }],
+        filters: vec![PivotFilter { source_col: "Channel".into(), ..PivotFilter::default() }],
         last_range: Some(rr("AB1:AC6")),
         ..PivotTable::default()
     };
@@ -711,6 +711,329 @@ fn data_on_rows_with_one_value_field_reads_without_warning() {
     assert!(back.sheet(0).unwrap().pivots[0].values_on_rows);
 }
 
+/// `workbook()` plus a slicer on "Report" over the Product field of "Sales by Region", with
+/// "A" and "C" selected (Product is a column field, so the selection is its hidden items).
+fn slicer_workbook() -> Workbook {
+    let mut wb = workbook();
+    let report = wb.sheet_mut(1).unwrap();
+    let pi = report.pivots.iter().position(|p| p.name == "Sales by Region").unwrap();
+    report.pivots[pi].filters.push(PivotFilter {
+        source_col: "Product".into(),
+        selected: Some(vec!["A".into(), "C".into()]),
+        ..PivotFilter::default()
+    });
+    report.slicers.push(Slicer {
+        id: 1,
+        source: SlicerSource::Pivot {
+            pivots: vec![SlicerPivot { sheet: "Report".into(), name: "Sales by Region".into() }],
+            field: "Product".into(),
+            sort: PivotSort::Desc,
+            cross_filter: SlicerCrossFilter::ShowItemsWithNoData,
+            show_missing: false,
+        },
+        caption: "Pick a product".into(),
+        anchor: Anchor { cell: at("M3"), dx: 4.0, dy: 2.0, width: 180.0, height: 240.0, mode: AnchorMode::default() },
+        columns: 2,
+        name: "Product".into(),
+        style: "SlicerStyleDark1".into(),
+        row_height: Some(30.0),
+    });
+    wb
+}
+
+#[test]
+fn pivot_slicer_round_trips() {
+    let wb = slicer_workbook();
+    let bytes = write_xlsx(&wb).unwrap();
+    let parts = unzip(&bytes);
+    let text = |k: &str| String::from_utf8(parts.get(k).unwrap_or_else(|| panic!("missing {k}")).clone()).unwrap();
+    let cache = text("xl/slicerCaches/slicerCache1.xml");
+    assert!(cache.contains("sourceName=\"Product\""), "{cache}");
+    assert!(cache.contains("name=\"Sales by Region\""), "{cache}");
+    assert!(cache.contains("<tabular pivotCacheId="), "{cache}");
+    assert!(cache.contains(" s=\"1\"") && cache.contains("sortOrder=\"descending\""), "{cache}");
+    let slicer = text("xl/slicers/slicer1.xml");
+    assert!(slicer.contains("caption=\"Pick a product\"") && slicer.contains("columnCount=\"2\""), "{slicer}");
+    let ct = text("[Content_Types].xml");
+    assert!(ct.contains("/xl/slicers/slicer1.xml") && ct.contains("/xl/slicerCaches/slicerCache1.xml"), "{ct}");
+    assert!(text("xl/workbook.xml").contains("slicerCaches"));
+    let ws = text("xl/worksheets/sheet2.xml");
+    assert!(ws.contains("x14:slicerList"), "{ws}");
+    let drawing =
+        parts.keys().filter(|k| k.starts_with("xl/drawings/drawing")).map(|k| text(k)).find(|d| d.contains("sle:slicer")).expect("slicer frame");
+    assert!(drawing.contains("mc:AlternateContent") && drawing.contains("mc:Fallback"), "{drawing}");
+
+    let (back, report) = read_xlsx(&bytes).unwrap();
+    assert!(report.warnings.iter().all(|w| !w.contains("slicer") && !w.contains("embedded object")), "{:?}", report.warnings);
+    let a = &wb.sheet(1).unwrap();
+    let b = &back.sheet(1).unwrap();
+    assert_eq!(b.slicers.len(), 1);
+    let (x, y) = (&a.slicers[0], &b.slicers[0]);
+    assert_eq!((&y.source, &y.caption, y.columns, &y.name, &y.style), (&x.source, &x.caption, x.columns, &x.name, &x.style));
+    assert_eq!(y.anchor.cell, x.anchor.cell);
+    assert!((y.anchor.width - x.anchor.width).abs() < 1.0 && (y.anchor.height - x.anchor.height).abs() < 1.0);
+    assert!(y.row_height.is_some_and(|h| (h - 30.0).abs() < 1.0), "{:?}", y.row_height);
+    let pa = a.pivots.iter().find(|p| p.name == "Sales by Region").unwrap();
+    let pb = b.pivots.iter().find(|p| p.name == "Sales by Region").unwrap();
+    assert_eq!(pa.filters, pb.filters, "the slicer's selection is the pivot's hidden items");
+    // A second save is stable.
+    let (again, _) = read_xlsx(&write_xlsx(&back).unwrap()).unwrap();
+    assert_eq!(again.sheet(1).unwrap().slicers, b.slicers);
+}
+
+/// A slicer on Product connected to "Sales by Region" and a second PivotTable on the same source
+/// that doesn't show Product (so its selection there is a hidden filter).
+#[test]
+fn pivot_slicer_keeps_every_connected_pivot_table() {
+    let mut wb = slicer_workbook();
+    let report = wb.sheet_mut(1).unwrap();
+    report.pivots.push(PivotTable {
+        id: 4,
+        name: "Units by Region".into(),
+        source: "Data!$A$1:$F$9".into(),
+        anchor: at("AF1"),
+        rows: vec![field("Region")],
+        values: vec![PivotValue { source_col: "Units".into(), func: PivotFunc::Sum, name: "Sum of Units".into(), ..PivotValue::default() }],
+        filters: vec![PivotFilter {
+            source_col: "Product".into(),
+            selected: Some(vec!["A".into(), "C".into()]),
+            hidden: true,
+            ..PivotFilter::default()
+        }],
+        ..PivotTable::default()
+    });
+    if let SlicerSource::Pivot { pivots, .. } = &mut report.slicers[0].source {
+        pivots.push(SlicerPivot { sheet: "Report".into(), name: "Units by Region".into() });
+    }
+    let bytes = write_xlsx(&wb).unwrap();
+    let parts = unzip(&bytes);
+    let text = |k: &str| String::from_utf8(parts.get(k).unwrap_or_else(|| panic!("missing {k}")).clone()).unwrap();
+    let cache = text("xl/slicerCaches/slicerCache1.xml");
+    assert!(cache.contains("name=\"Sales by Region\"") && cache.contains("name=\"Units by Region\""), "{cache}");
+    // The connected PivotTables share one pivot cache, as Excel requires.
+    let cache_id = |name: &str| {
+        let t = parts
+            .keys()
+            .filter(|k| k.starts_with("xl/pivotTables/pivotTable"))
+            .map(|k| text(k))
+            .find(|t| t.contains(&format!("name=\"{name}\"")))
+            .unwrap();
+        t.split("cacheId=\"").nth(1).and_then(|s| s.split('"').next()).unwrap().to_string()
+    };
+    assert_eq!(cache_id("Sales by Region"), cache_id("Units by Region"));
+
+    let (back, report) = read_xlsx(&bytes).unwrap();
+    assert!(report.warnings.iter().all(|w| !w.contains("slicer")), "{:?}", report.warnings);
+    let (a, b) = (wb.sheet(1).unwrap(), back.sheet(1).unwrap());
+    assert_eq!(b.slicers.len(), 1);
+    assert_eq!(b.slicers[0].source, a.slicers[0].source);
+    for name in ["Sales by Region", "Units by Region", "Trend", "PivotTable3"] {
+        let pa = a.pivots.iter().find(|p| p.name == name).unwrap();
+        let pb = b.pivots.iter().find(|p| p.name == name).unwrap();
+        assert_eq!((&pa.rows, &pa.columns, &pa.filters), (&pb.rows, &pb.columns, &pb.filters), "{name}");
+    }
+}
+
+/// PivotTables a slicer connects share one cache only when they have the same calculated fields:
+/// a cache's calculated fields are read back into each of its tables, so sharing would add one
+/// table's calculated field to the other.
+#[test]
+fn pivot_slicer_shares_no_cache_across_calculated_fields() {
+    let mut wb = slicer_workbook();
+    let report = wb.sheet_mut(1).unwrap();
+    let pi = report.pivots.iter().position(|p| p.name == "Sales by Region").unwrap();
+    report.pivots[pi].calculated_fields.push(PivotCalcField { name: "Price".into(), formula: "=Sales/Units".into() });
+    report.pivots.push(PivotTable {
+        id: 4,
+        name: "Units by Region".into(),
+        source: "Data!$A$1:$F$9".into(),
+        anchor: at("AF1"),
+        rows: vec![field("Region")],
+        values: vec![PivotValue { source_col: "Units".into(), func: PivotFunc::Sum, name: "Sum of Units".into(), ..PivotValue::default() }],
+        filters: vec![PivotFilter {
+            source_col: "Product".into(),
+            selected: Some(vec!["A".into(), "C".into()]),
+            hidden: true,
+            ..PivotFilter::default()
+        }],
+        ..PivotTable::default()
+    });
+    if let SlicerSource::Pivot { pivots, .. } = &mut report.slicers[0].source {
+        pivots.push(SlicerPivot { sheet: "Report".into(), name: "Units by Region".into() });
+    }
+    let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
+    let calc = |name: &str| back.sheet(1).unwrap().pivots.iter().find(|p| p.name == name).unwrap().calculated_fields.clone();
+    assert_eq!(calc("Sales by Region"), vec![PivotCalcField { name: "Price".into(), formula: "=Sales/Units".into() }]);
+    assert_eq!(calc("Units by Region"), vec![]);
+
+    // With the same calculated fields they share one cache and stay connected.
+    let report = wb.sheet_mut(1).unwrap();
+    let units = report.pivots.iter().position(|p| p.name == "Units by Region").unwrap();
+    report.pivots[units].calculated_fields.push(PivotCalcField { name: "Price".into(), formula: "=Sales/Units".into() });
+    let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap();
+    assert_eq!(back.sheet(1).unwrap().slicers[0].source, wb.sheet(1).unwrap().slicers[0].source);
+}
+
+/// A slicer on a date field grouped by quarters lists the groups, in date order.
+#[test]
+fn pivot_slicer_on_grouped_dates_writes_the_groups() {
+    let mut wb = workbook();
+    let report = wb.sheet_mut(1).unwrap();
+    report.pivots.push(PivotTable {
+        id: 4,
+        name: "By Quarter".into(),
+        source: "Data!$A$1:$F$9".into(),
+        anchor: at("AF1"),
+        rows: vec![PivotField { source_col: "Date".into(), date_group: PivotDateGroup::Quarters, ..PivotField::default() }],
+        values: vec![PivotValue { source_col: "Sales".into(), func: PivotFunc::Sum, name: "Sum of Sales".into(), ..PivotValue::default() }],
+        filters: vec![PivotFilter { source_col: "Date".into(), selected: Some(vec!["Qtr2".into()]), ..PivotFilter::default() }],
+        ..PivotTable::default()
+    });
+    report.slicers.push(Slicer {
+        id: 1,
+        source: SlicerSource::Pivot {
+            pivots: vec![SlicerPivot { sheet: "Report".into(), name: "By Quarter".into() }],
+            field: "Date".into(),
+            sort: PivotSort::Asc,
+            cross_filter: SlicerCrossFilter::ShowItemsWithDataAtTop,
+            show_missing: true,
+        },
+        caption: "Date".into(),
+        anchor: Anchor { cell: at("AJ1"), dx: 0.0, dy: 0.0, width: 180.0, height: 240.0, mode: AnchorMode::default() },
+        columns: 1,
+        name: "Date".into(),
+        style: String::new(),
+        row_height: None,
+    });
+    let bytes = write_xlsx(&wb).unwrap();
+    let parts = unzip(&bytes);
+    let cache = String::from_utf8(parts["xl/slicerCaches/slicerCache1.xml"].clone()).unwrap();
+    // Items: <start, Qtr1..Qtr4, >end, listed in that order, with only Qtr2 selected.
+    let items = cache.split("<items").nth(1).unwrap();
+    let xs: Vec<&str> = items.split("<i x=\"").skip(1).map(|s| s.split('"').next().unwrap()).collect();
+    assert_eq!(xs, ["0", "1", "2", "3", "4", "5"], "{cache}");
+    assert!(items.contains("<i x=\"2\" s=\"1\"/>") && items.matches("s=\"1\"").count() == 1, "{cache}");
+
+    let (back, _) = read_xlsx(&bytes).unwrap();
+    let b = back.sheet(1).unwrap();
+    assert_eq!(b.slicers[0].source, wb.sheet(1).unwrap().slicers[0].source);
+    let pb = b.pivots.iter().find(|p| p.name == "By Quarter").unwrap();
+    assert_eq!(pb.filters, vec![PivotFilter { source_col: "Date".into(), selected: Some(vec!["Qtr2".into()]), ..PivotFilter::default() }]);
+}
+
+/// With a date grouped at several levels, Excel keeps each coarser level in its own cache field
+/// ("Years" over "Date"), and a slicer on that level names it as its source. Such a slicer is
+/// skipped with one warning that says so, and the PivotTable is kept.
+#[test]
+fn pivot_slicer_on_a_coarser_date_level_is_skipped_with_a_warning() {
+    let mut wb = workbook();
+    let report = wb.sheet_mut(1).unwrap();
+    report.pivots.push(PivotTable {
+        id: 4,
+        name: "By Year".into(),
+        source: "Data!$A$1:$F$9".into(),
+        anchor: at("AF1"),
+        rows: vec![
+            PivotField { source_col: "Date".into(), date_group: PivotDateGroup::Years, ..PivotField::default() },
+            PivotField { source_col: "Date".into(), date_group: PivotDateGroup::Months, ..PivotField::default() },
+        ],
+        values: vec![PivotValue { source_col: "Sales".into(), func: PivotFunc::Sum, name: "Sum of Sales".into(), ..PivotValue::default() }],
+        ..PivotTable::default()
+    });
+    report.slicers.push(Slicer {
+        id: 1,
+        source: SlicerSource::Pivot {
+            pivots: vec![SlicerPivot { sheet: "Report".into(), name: "By Year".into() }],
+            field: "Date".into(),
+            sort: PivotSort::Asc,
+            cross_filter: SlicerCrossFilter::ShowItemsWithDataAtTop,
+            show_missing: true,
+        },
+        caption: "Years".into(),
+        anchor: Anchor { cell: at("AJ1"), dx: 0.0, dy: 0.0, width: 180.0, height: 240.0, mode: AnchorMode::default() },
+        columns: 1,
+        name: "Years".into(),
+        style: String::new(),
+        row_height: None,
+    });
+    let mut parts = unzip(&write_xlsx(&wb).unwrap());
+    let defs: Vec<String> = parts
+        .iter()
+        .filter(|(k, _)| k.starts_with("xl/pivotCache/pivotCacheDefinition"))
+        .map(|(_, v)| String::from_utf8(v.clone()).unwrap())
+        .collect();
+    assert!(defs.iter().any(|d| d.contains("<cacheField name=\"Years\"") && d.contains("databaseField=\"0\"")), "{defs:?}");
+    let key = "xl/slicerCaches/slicerCache1.xml".to_string();
+    let cache = String::from_utf8(parts.remove(&key).unwrap()).unwrap();
+    let edited = cache.replace("sourceName=\"Date\"", "sourceName=\"Years\"");
+    assert_ne!(cache, edited);
+    parts.insert(key, edited.into_bytes());
+    let refs: Vec<(&str, &[u8])> = parts.iter().map(|(n, d)| (n.as_str(), d.as_slice())).collect();
+    let (back, report) = read_xlsx(&super::make_zip(&refs)).unwrap();
+    let b = back.sheet(1).unwrap();
+    assert!(b.slicers.is_empty(), "{:?}", b.slicers);
+    let about: Vec<&String> = report.warnings.iter().filter(|w| w.contains("slicer")).collect();
+    assert_eq!(about.len(), 1, "{:?}", report.warnings);
+    assert!(about[0].contains("coarser date level of \"Date\""), "{about:?}");
+    let pb = b.pivots.iter().find(|p| p.name == "By Year").unwrap();
+    assert_eq!(pb.rows.iter().map(|f| f.date_group).collect::<Vec<_>>(), [PivotDateGroup::Years, PivotDateGroup::Months]);
+    let _ = write_xlsx(&back).unwrap();
+}
+
+#[test]
+fn hostile_slicer_parts_warn_not_panic() {
+    let bytes = write_xlsx(&slicer_workbook()).unwrap();
+    let cache = "xl/slicerCaches/slicerCache1.xml";
+    type XmlEdit<'a> = (&'a str, &'a dyn Fn(&str) -> String);
+    let edits: [XmlEdit<'_>; 7] = [
+        // The cache names a PivotTable that doesn't exist.
+        (cache, &|s| s.replace("name=\"Sales by Region\"", "name=\"Nowhere\"")),
+        (cache, &|s| s.replace("tabId=\"", "tabId=\"99")),
+        (cache, &|s| s.replace("pivotCacheId=\"", "pivotCacheId=\"77")),
+        (cache, &|s| s.replace("<i x=\"", "<i x=\"4294967")),
+        (cache, &|_| "garbage <<<".into()),
+        ("xl/slicers/slicer1.xml", &|s| s.replace("cache=\"", "cache=\"Other")),
+        ("xl/slicers/slicer1.xml", &|_| "<slicers/>".into()),
+    ];
+    for (part, f) in edits {
+        let mut parts = unzip(&bytes);
+        let old = String::from_utf8(parts.remove(part).unwrap()).unwrap();
+        let new = f(&old);
+        assert_ne!(old, new, "edit to {part} did nothing");
+        let mut list: Vec<(String, Vec<u8>)> = parts.into_iter().collect();
+        list.push((part.to_string(), new.into_bytes()));
+        let refs: Vec<(&str, &[u8])> = list.iter().map(|(n, d)| (n.as_str(), d.as_slice())).collect();
+        let (wb, report) = read_xlsx(&super::make_zip(&refs)).unwrap();
+        let sh = wb.sheet(1).unwrap();
+        if sh.slicers.is_empty() {
+            // One warning names the dropped slicer, not a second one for its frame.
+            let about = report.warnings.iter().filter(|w| w.contains("\"Product\"")).count();
+            assert_eq!(about, 1, "after editing {part}: {:?}", report.warnings);
+        }
+        // Whatever was read saves again.
+        let _ = write_xlsx(&wb).unwrap();
+    }
+}
+
+#[test]
+fn unresolved_slicer_cache_is_skipped_and_dropped_on_save() {
+    let bytes = write_xlsx(&slicer_workbook()).unwrap();
+    let cache = "xl/slicerCaches/slicerCache1.xml";
+    for replacement in [("pivotCacheId=\"", "pivotCacheId=\"77"), (" pivotCacheId=\"1\"", "")] {
+        let mut parts = unzip(&bytes);
+        let original = String::from_utf8(parts.remove(cache).unwrap()).unwrap();
+        let edited = original.replace(replacement.0, replacement.1);
+        assert_ne!(original, edited);
+        parts.insert(cache.into(), edited.into_bytes());
+        let refs: Vec<(&str, &[u8])> = parts.iter().map(|(n, d)| (n.as_str(), d.as_slice())).collect();
+        let (wb, report) = read_xlsx(&super::make_zip(&refs)).unwrap();
+        assert!(wb.sheet(1).unwrap().slicers.is_empty());
+        assert!(report.warnings.iter().any(|w| w.contains("has no resolvable PivotTable cache; skipped")), "{:?}", report.warnings);
+        let saved = unzip(&write_xlsx(&wb).unwrap());
+        assert!(!saved.keys().any(|k| k.starts_with("xl/slicers/") || k.starts_with("xl/slicerCaches/")));
+        assert!(!saved.values().any(|v| String::from_utf8_lossy(v).contains("x14:slicerList")));
+    }
+}
 /// A one-sheet-of-data workbook with a pivot on "Report": `columns` are the source columns
 /// (header, values), `pt` the pivot built on `Data!A1:<last>`.
 fn small_pivot(columns: &[(&str, Vec<Value>)], pt: impl FnOnce(&mut PivotTable)) -> HashMap<String, String> {
diff --git a/crates/xlsx/src/write.rs b/crates/xlsx/src/write.rs
index f03dd9b049..9503206c51 100644
--- a/crates/xlsx/src/write.rs
+++ b/crates/xlsx/src/write.rs
@@ -126,6 +126,7 @@ pub struct Out {
     pub dynamic_arrays: bool,
     pub needs_calc: bool,
     pub cell_pictures: crate::richdata::PicturesOut,
+    pub slicers: crate::slicer::SlicerWriter,
     /// Kept (pass-through) parts written so far.
     pub kept: crate::passthrough::KeptOut,
 }
@@ -236,6 +237,7 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
         dynamic_arrays: false,
         needs_calc: false,
         cell_pictures: Default::default(),
+        slicers: crate::slicer::SlicerWriter::new(wb),
         kept: Default::default(),
     };
     out.kept.reserve_vml_blocks(wb);
@@ -250,9 +252,8 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
     };
 
     let mut wb_rels = Rels::default();
-    let (sheets_xml, kept, pivots) = write_sheets(wb, &mut out, active, &mut wb_rels);
-
-    let names = write_defined_names(wb, &kept, &out.chart_names);
+    let (sheets_xml, kept, pivots, sheet_ids) = write_sheets(wb, &mut out, active, &mut wb_rels);
+    let names = write_defined_names(wb, &kept, &out.chart_names, &out.slicers);
 
     let mut w = format!("{XML_DECL}<workbook xmlns=\"{NS_MAIN}\" xmlns:r=\"{NS_REL}\">");
     // A workbook read from a file keeps its <fileVersion> as it was: Excel trusts the saved values
@@ -304,9 +305,10 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>)
     }
     w.push_str("/>");
     w.push_str(&pivots.workbook_xml(&mut wb_rels));
+    let slicer_ext = std::mem::take(&mut out.slicers).finish(wb, &sheet_ids, &pivots, &mut out, &mut wb_rels);
     let exts = crate::passthrough::workbook_elements(wb, "ext");
-    if !exts.is_empty() {
-        let _ = write!(w, "<extLst>{exts}</extLst>");
+    if !slicer_ext.is_empty() || !exts.is_empty() {
+        let _ = write!(w, "<extLst>{slicer_ext}{exts}</extLst>");
     }
     w.push_str("</workbook>");
 
@@ -431,11 +433,12 @@ fn write_sheets(
     out: &mut Out,
     active: usize,
     wb_rels: &mut Rels,
-) -> (String, crate::passthrough::WorkbookKept, crate::pivot::PivotWriter) {
+) -> (String, crate::passthrough::WorkbookKept, crate::pivot::PivotWriter, Vec<usize>) {
     // Kept content first: the chart sheets among the worksheets need their relationship ids.
     let kept = crate::passthrough::write_workbook(wb, wb_rels, out);
     let mut pivots = crate::pivot::PivotWriter::default();
     let mut sheets_xml = String::new();
+    let mut sheet_ids = Vec::with_capacity(wb.sheets.len());
     let any_visible = wb.sheets.iter().any(|s| s.visibility == Visibility::Visible);
     let mut ids = crate::passthrough::SheetIds::new(wb, &kept);
     for (i, sheet) in wb.sheets.iter().enumerate() {
@@ -456,19 +459,26 @@ fn write_sheets(
         };
         let name: String = sheet.name.chars().take(31).collect();
         let sheet_id = ids.take(sheet.file_id);
+        sheet_ids.push(sheet_id as usize);
         let _ = write!(sheets_xml, "<sheet name=\"{}\" sheetId=\"{sheet_id}\"{state} r:id=\"{rid}\"/>", esc_attr(&name));
     }
     sheets_xml.push_str(&kept.sheet_entries(wb.sheets.len(), true, &mut ids));
 
-    (sheets_xml, kept, pivots)
+    (sheets_xml, kept, pivots, sheet_ids)
 }
 
-fn write_defined_names(wb: &Workbook, kept: &crate::passthrough::WorkbookKept, chart_names: &[String]) -> String {
+fn write_defined_names(
+    wb: &Workbook,
+    kept: &crate::passthrough::WorkbookKept,
+    chart_names: &[String],
+    slicers: &crate::slicer::SlicerWriter,
+) -> String {
     // Defined names, then print areas and titles.
     let mut names = String::new();
     let mut seen = std::collections::HashSet::new();
     for n in &wb.names {
-        if n.name.is_empty() || !seen.insert((n.name.to_ascii_lowercase(), n.scope)) {
+        // A slicer cache's name is written with its cache.
+        if n.name.is_empty() || (n.scope.is_none() && slicers.is_cache_name(&n.name)) || !seen.insert((n.name.to_ascii_lowercase(), n.scope)) {
             continue;
         }
         if let Some(sc) = n.scope
@@ -524,6 +534,7 @@ fn write_defined_names(wb: &Workbook, kept: &crate::passthrough::WorkbookKept, c
         }
     }
 
+    names.push_str(&slicers.defined_names());
     names
 }
 
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 1523e9d94d..fe2ab5f99c 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -1,6 +1,6 @@
 # File-format parity
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-26 · **Change:** minor (`file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-26 · **Change:** minor (XLSX: PivotTable slicers read and written; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4
 
 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests.
 Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h**
@@ -41,6 +41,9 @@ values) is still dropped.
 
 | Format | Excel | GridCraft read | GridCraft write | Fidelity / notes | Tests |
 |---|---|---|---|---|---|
+| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables) and compatible PivotTable slicers (tabular slicer caches, slicer parts and drawing frames; connections that cannot share a pivot cache are reduced to the first PivotTable on write, and coarser date-group levels are skipped on open), protection, calc settings. **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** table and OLAP slicers and their caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
+| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes, merges, CF, validation, tables, notes (with their shown/hidden state) and threaded comments with replies, resolved state and timestamps (`threadedComments` and `persons` parts, #300), hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables) and compatible PivotTable slicers (tabular slicer caches, slicer parts and drawing frames; connections that cannot share a pivot cache are reduced to the first PivotTable on write, and coarser date-group levels are skipped on open), protection, calc settings. **Not preserved:** unmodelled parts and extensions (form controls, table and OLAP slicers and their caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
+| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables) and compatible PivotTable slicers (tabular slicer caches, slicer parts and drawing frames; connections that cannot share a pivot cache are reduced to the first PivotTable on write, and coarser date-group levels are skipped on open), protection, Allow Edit Ranges (`protectedRanges` with their password hashes, #307), calc settings. **Not preserved:** unmodelled parts and extensions (form controls, table and OLAP slicers and their caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
 | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `<rPh>` offsets and readings and `<phoneticPr>` are written back next to the same string; the table holds each text once, so duplicate `<si>` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
 | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `<rPh>` offsets and readings and `<phoneticPr>` are written back next to the same string; the table holds each text once, so duplicate `<si>` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, notes (with their shown/hidden state) and threaded comments with replies, resolved state and timestamps (`threadedComments` and `persons` parts, #300), hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
 | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `<rPh>` offsets and readings and `<phoneticPr>` are written back next to the same string; the table holds each text once, so duplicate `<si>` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, Allow Edit Ranges (`protectedRanges` with their password hashes, #307), calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` |
@@ -98,7 +101,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here.
 | Work | Hours |
 |---|---|
 | Real-world XLSX corpus run, and confirm Excel opens our output with no repair prompt (owner runs Excel) | 15–25 |
-| Preserve the rest of the unmodelled XLSX content (slicers, timelines, data model, table query tables, `extLst` entries); pass-through landed for the rest (#330) | 6–10 |
+| Preserve the rest of the unmodelled XLSX content (table slicers, timelines, data model, table query tables, `extLst` entries); pass-through landed for the rest (#330) | 6–10 |
 | Streaming XLSX reader for very large files (#175), part-size limits that degrade instead of failing | 10–15 |
 | Legacy `.xls` (BIFF8): styles (fonts, fills, borders, alignment), comments, CF, validation, pictures and charts on import; corpus run; then write | 10–15 |
 | Encrypted workbooks: save with password (#11) | 4–6 |
@@ -136,6 +139,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here.
 | 2026-10-14 | trivial | Formula parser: text longer than Excel's 8,192 characters, and postfix chains (`1%%%…`, `f(1)(1)…`) past the 256-level nesting limit, are parse errors (the cell keeps its formula text and cached value) instead of trees deep enough to overflow the stack when a hostile file is opened, saved or dropped |
 | 2026-10-14 | minor | XLSX formulas read with dynamic-array metadata (`cm`) keep it on save, so Excel does not recalculate them with implicit intersection |
 | 2026-10-14 | minor | PDF export writes clickable annotations for safe cell URLs and destinations on printed pages; CLI `convert` accepts `.pdf` output (#954) |
+| 2026-10-13 | minor | XLSX: PivotTable slicers (x14 slicer caches with tabular items, slicer parts, `sle:slicer` drawing frames with a fallback shape, sheet and workbook ext lists) read and written; they no longer warn as skipped embedded objects |
 | 2026-10-13 | trivial | XLSX export keeps a picture shared by several sheets as one media part (#985) |
 | 2026-10-12 | trivial | XLSX chart sheets are kept on save (#727) |
 | 2026-10-12 | trivial | CSV and TSV export is capped at 512 MiB and refuses a larger used range with an error (#528) |
diff --git a/docs/gaps.md b/docs/gaps.md
index 97299acda0..0ef42f7ed7 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Gaps
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-24 · **Change:** minor (§8: PivotTable Enable show details; earlier: PivotTable Show Details) · **Target:** Microsoft Excel (Microsoft 365)
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-24 · **Change:** minor (§8: PivotTable Enable show details; §3, §8: PivotTable slicers landed; earlier: PivotTable Show Details) · **Target:** Microsoft Excel (Microsoft 365)
 
 Every known shortfall against Excel, one entry each, ranked by user impact (what blocks someone
 using GridCraft for real work first). This is the work list: pick from the top, check the open
@@ -34,12 +34,12 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha-
 - **Estimate:** 25–40 h. [target-app-parity.md](target-app-parity.md#performance), [hardware-parity.md](hardware-parity.md)
 
 ### 3. Some unmodelled XLSX content is dropped on save (FF)
-- **Missing:** slicers and their caches, timelines, the data model, query tables attached to
+- **Missing:** table and OLAP slicers and their caches (PivotTable slicers are read and written), timelines, the data model, query tables attached to
   tables, unmodelled `extLst` entries, chart details. Pass-through (#330) keeps custom XML,
   external links, connections, sheet query tables, printer settings, form and ActiveX controls,
   OLE objects and sheet backgrounds; never checked in Excel (repair prompts unknown).
 - **Evidence:** `crates/xlsx/src/passthrough.rs` (what is kept, and why the rest isn't).
-- **Impact:** open-edit-save still simplifies workbooks with slicers, timelines or Power Pivot.
+- **Impact:** open-edit-save still simplifies workbooks with table or OLAP slicers, timelines or Power Pivot.
 - **Estimate:** 6–10 h. [file-format-parity.md](file-format-parity.md)
 
 ### 4. Charts lose options on round trip; shallow chart model (F, FF)
@@ -81,13 +81,19 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha-
   routine in business.
 - **Estimate:** 14–21 h (`.xls` styles and objects 10–15, encryption 4–6). [file-format-parity.md](file-format-parity.md)
 
-### 8. PivotTables: no slicers, calculated items, PivotCharts; unverified in Excel (F)
+### 8. PivotTables: no calculated items, inserting slicers, timelines; unverified in Excel (F)
 - **Evidence:** `parity-checklist.md` missing `insert.slicer`, `insert.timeline`,
   `insert.pivotChart`, `table.insertSlicer`; calculated items and GETPIVOTDATA missing (calculated fields
   and values on rows done). Show Details (double-click a value, subtotal or grand total cell) lists
   its source records on a new sheet. The "Enable show details" option (`pivot.options`
   `enableShowDetails`, saved as `enableDrill`) turns it off; it has no PivotTable Options dialog
   yet (command only).
+  PivotTable slicers from files are shown, filter their PivotTables when clicked and are saved;
+  inserting one on a PivotTable, and slicer settings, are not done yet. A slicer connected to
+  PivotTables that can't share one pivot cache (different sources or calculated fields, or a
+  date field grouped differently) is saved connected to the first of them only. A slicer on a
+  coarser level of a date grouped at several levels (a Years slicer on a Date grouped by years
+  and months, which Excel keeps in its own cache field) is skipped with a warning on open.
 - **Impact:** pivots are the analyst's main tool.
 - **Estimate:** 20–30 h for beta (25–40 h full).
 
@@ -190,6 +196,7 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha-
 | 2026-10-17 | minor | §6: the five reports it tracked are closed and their PRs merged (#57, #133, #139, #140, #134; PRs #148, #155, #156, #157); the entry stays open for §15's oracle suite |
 | 2026-10-15 | minor | §6: Maximum Iterations and Maximum Change in File › Options › Formulas; dropped the stale "no Options dialog yet" |
 | 2026-10-15 | minor | §13: Solver prepares reports before committing the solution, model and report sheets together; report refusal preserves the workbook and Undo/Redo (#1050) |
+| 2026-10-13 | minor | §3, §8: PivotTable slicers read, shown, clickable and written |
 | 2026-10-13 | trivial | §4: multi-level category axes landed |
 | 2026-10-12 | minor | §9: next/previous sheet commands retain the current visible sheet and selection when there is no visible destination |
 | 2026-10-12 | minor | rows auto-fit oversized fonts on open and whole-row/column formatting (#833) |