From cce5fe739a0d476b6d54ae7cd9385a2313eb639e Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Mon, 3 Mar 2025 19:59:41 -0300
Subject: [PATCH 01/28] multiple footers

---
 crates/typst-library/src/layout/grid/resolve.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index baf6b7383..42df8953b 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -678,8 +678,8 @@ pub struct CellGrid<'a> {
     pub hlines: Vec<Vec<Line>>,
     /// The repeatable headers of this grid.
     pub headers: Vec<Repeatable<Header>>,
-    /// The repeatable footer of this grid.
-    pub footer: Option<Repeatable<Footer>>,
+    /// The repeatable footers of this grid.
+    pub footers: Vec<Repeatable<Footer>>,
     /// Whether this grid has gutters.
     pub has_gutter: bool,
 }
@@ -756,7 +756,7 @@ impl<'a> CellGrid<'a> {
             vlines,
             hlines,
             headers,
-            footer,
+            footers: footer.into_iter().collect(),
             has_gutter,
         }
     }
@@ -895,6 +895,11 @@ impl<'a> CellGrid<'a> {
     pub fn has_repeated_headers(&self) -> bool {
         self.headers.iter().any(|h| h.repeated)
     }
+
+    #[inline]
+    pub fn has_repeated_footers(&self) -> bool {
+        self.footers.iter().any(|f| f.repeated)
+    }
 }
 
 /// Resolves and positions all cells in the grid before creating it.

From 5292c5b198aaf39f6666fd9164d7fa2e1653b495 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 16 May 2025 20:01:17 -0300
Subject: [PATCH 02/28] update html code for multiple footers

todo: test
---
 crates/typst-library/src/model/table.rs | 33 ++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index dcc77b0dc..367d3e66f 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -292,12 +292,33 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
         elem(tag::tr, Content::sequence(row))
     };
 
-    // TODO(subfooters): similarly to headers, take consecutive footers from
-    // the end for 'tfoot'.
-    let footer = grid.footer.map(|ft| {
-        let rows = rows.drain(ft.start..);
-        elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row))))
-    });
+    // Store all consecutive headers at the start in 'tfoot'. All remaining
+    // headers are just normal rows across the table body. (There doesn't
+    // appear to be an equivalent of 'th' for footers in HTML.)
+    // TODO: test
+    let footer = {
+        let mut consecutive_footer_start = grid.footers.len();
+        let footers_at_end = grid
+            .footers
+            .iter()
+            .rev()
+            .take_while(|ft| {
+                let is_consecutive = ft.end == consecutive_footer_start;
+                consecutive_footer_start = ft.start;
+
+                is_consecutive
+            })
+            .count();
+
+        if footers_at_end > 0 {
+            let last_mid_table_footer = grid.footers.len() - footers_at_end;
+            let rows = rows.drain(last_mid_table_footer..);
+
+            Some(elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row)))))
+        } else {
+            None
+        }
+    };
 
     // Store all consecutive headers at the start in 'thead'. All remaining
     // headers are just 'th' rows across the table body.

From 0a27b5055180461fd27688d8c8653f8e10378fc1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sun, 30 Mar 2025 23:46:13 -0300
Subject: [PATCH 03/28] footer pre sorting

---
 .../typst-library/src/layout/grid/resolve.rs  | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 42df8953b..acb588e95 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -680,6 +680,10 @@ pub struct CellGrid<'a> {
     pub headers: Vec<Repeatable<Header>>,
     /// The repeatable footers of this grid.
     pub footers: Vec<Repeatable<Footer>>,
+    /// Footers sorted by order of when they start repeating, or should
+    /// otherwise be laid out for the first time (even if only once, for
+    /// non-repeating footers).
+    pub sorted_footers: Vec<Repeatable<Footer>>,
     /// Whether this grid has gutters.
     pub has_gutter: bool,
 }
@@ -749,6 +753,9 @@ impl<'a> CellGrid<'a> {
             rows.pop();
         }
 
+        let footers: Vec<Repeatable<Footer>> = footer.into_iter().collect();
+        let sorted_footers = simulate_footer_repetition(&footers);
+
         Self {
             cols,
             rows,
@@ -2394,3 +2401,50 @@ fn skip_auto_index_through_fully_merged_rows(
         }
     }
 }
+
+/// Generates a vector where all footers are sorted ahead of time by the points
+/// at which they start repeating. When a new footer is about to be laid out,
+/// conflicting footers which come before it in this vector must stop
+/// repeating.
+fn simulate_footer_repetition(
+    footers: &[Repeatable<Footer>],
+) -> Vec<&Repeatable<Footer>> {
+    if footers.len() <= 1 {
+        return footers.iter().collect();
+    }
+
+    let mut ordered_footers = Vec::with_capacity(footers.len());
+    let mut repeating_footers: Vec<&Repeatable<Footer>> = vec![];
+
+    // Read footers in reverse, using the same algorithm as headers to
+    // determine when a footer starts and stops repeating, but going from grid
+    // end to start. When it stops repeating, that's when it will start
+    // repeating in proper layout (from start to end), whereas it starts
+    // repeating here when it should stop repeating in practice. So,
+    // effectively, repeated footer layout is the same as for headers, but
+    // reversed, which we take advantage of by doing it reversed and then
+    // reversing it all back later.
+    for footer in footers.iter().rev() {
+        // Keep only lower level footers. Assume sorted by increasing levels.
+        let stopped_repeating = repeating_footers
+            .drain(repeating_footers.partition_point(|f| f.level < footer.level)..);
+
+        // If they stopped repeating here, that's when they will start
+        // repeating. We save them in reverse of the reverse order so they stay
+        // sorted by increasing levels when we reverse `ordered_footers` later.
+        ordered_footers.extend(stopped_repeating.rev());
+
+        if footer.repeated {
+            // Start repeating now. Vector stays sorted by increasing levels,
+            // as any higher-level footers stopped repeating now.
+            repeating_footers.push(footer);
+        } else {
+            // Immediately finishes repeating.
+            ordered_footers.push(footer);
+        }
+    }
+
+    ordered_footers.reverse();
+
+    ordered_footers
+}

From 3bf0f2b48c1561efe7b180674df348600dc64648 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 16 May 2025 20:55:25 -0300
Subject: [PATCH 04/28] clone footers after sorting

might want to rethink this
---
 crates/typst-library/src/layout/grid/resolve.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index acb588e95..78f5cd42f 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -445,7 +445,7 @@ pub struct Header {
 }
 
 /// A repeatable grid footer. Stops at the last row.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Footer {
     /// The first row included in this footer.
     pub start: usize,
@@ -470,6 +470,7 @@ impl Footer {
 /// It still exists even when not repeatable, but must not have additional
 /// considerations by grid layout, other than for consistency (such as making
 /// a certain group of rows unbreakable).
+#[derive(Debug, Clone)]
 pub struct Repeatable<T> {
     inner: T,
 
@@ -763,7 +764,8 @@ impl<'a> CellGrid<'a> {
             vlines,
             hlines,
             headers,
-            footers: footer.into_iter().collect(),
+            footers,
+            sorted_footers,
             has_gutter,
         }
     }
@@ -2406,11 +2408,9 @@ fn skip_auto_index_through_fully_merged_rows(
 /// at which they start repeating. When a new footer is about to be laid out,
 /// conflicting footers which come before it in this vector must stop
 /// repeating.
-fn simulate_footer_repetition(
-    footers: &[Repeatable<Footer>],
-) -> Vec<&Repeatable<Footer>> {
+fn simulate_footer_repetition(footers: &[Repeatable<Footer>]) -> Vec<Repeatable<Footer>> {
     if footers.len() <= 1 {
-        return footers.iter().collect();
+        return footers.iter().cloned().collect();
     }
 
     let mut ordered_footers = Vec::with_capacity(footers.len());
@@ -2432,7 +2432,7 @@ fn simulate_footer_repetition(
         // If they stopped repeating here, that's when they will start
         // repeating. We save them in reverse of the reverse order so they stay
         // sorted by increasing levels when we reverse `ordered_footers` later.
-        ordered_footers.extend(stopped_repeating.rev());
+        ordered_footers.extend(stopped_repeating.rev().cloned());
 
         if footer.repeated {
             // Start repeating now. Vector stays sorted by increasing levels,
@@ -2440,7 +2440,7 @@ fn simulate_footer_repetition(
             repeating_footers.push(footer);
         } else {
             // Immediately finishes repeating.
-            ordered_footers.push(footer);
+            ordered_footers.push(footer.clone());
         }
     }
 

From 5f663a8da43bc8529737e62c5a6828b588a44daf Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 20 May 2025 21:45:43 -0300
Subject: [PATCH 05/28] initial footer properties and bumping

---
 crates/typst-layout/src/grid/layouter.rs | 15 +++++++++++++
 crates/typst-layout/src/grid/repeated.rs | 28 ++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 42fe38dbe..9f714ac86 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -6,6 +6,7 @@ use typst_library::foundations::{Resolve, StyleChain};
 use typst_library::layout::grid::resolve::{
     Cell, CellGrid, Header, LinePosition, Repeatable,
 };
+use typst_library::layout::resolve::Footer;
 use typst_library::layout::{
     Abs, Axes, Dir, Fr, Fragment, Frame, FrameItem, Length, Point, Region, Regions, Rel,
     Size, Sizing,
@@ -60,6 +61,16 @@ pub struct GridLayouter<'a> {
     pub(super) pending_headers: &'a [Repeatable<Header>],
     /// Next headers to be processed.
     pub(super) upcoming_headers: &'a [Repeatable<Header>],
+    /// Currently repeating footers, one per level. Sorted by increasing
+    /// levels.
+    ///
+    /// Note that some levels may be absent, in particular level 0, which does
+    /// not exist (so all levels are >= 1).
+    pub(super) repeating_footers: Vec<&'a Footer>,
+    /// Next footers to be processed.
+    pub(super) upcoming_footers: &'a [Repeatable<Footer>],
+    /// Next footers sorted by when they start repeating.
+    pub(super) upcoming_sorted_footers: &'a [Repeatable<Footer>],
     /// State of the row being currently laid out.
     ///
     /// This is kept as a field to avoid passing down too many parameters from
@@ -253,6 +264,10 @@ impl<'a> GridLayouter<'a> {
             repeating_headers: vec![],
             upcoming_headers: &grid.headers,
             pending_headers: Default::default(),
+            // This is calculated on layout
+            repeating_footers: vec![],
+            upcoming_footers: &grid.footers,
+            upcoming_sorted_footers: &grid.sorted_footers,
             row_state: RowState::default(),
             current: Current {
                 initial: regions.size,
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 8db33df5e..7ca937e7e 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -463,6 +463,34 @@ impl<'a> GridLayouter<'a> {
         )
     }
 
+    pub fn bump_repeating_footers(&mut self) -> &'a [Repeatable<Footer>] {
+        let [next_footer, other_footers @ ..] = self.upcoming_sorted_footers else {
+            return &[];
+        };
+
+        if !next_footer.repeated {
+            // TODO(subfooters): grouping and laying them out together?
+            self.upcoming_sorted_footers = other_footers;
+            return &[];
+        }
+
+        if other_footers.is_empty() {
+            return std::mem::replace(&mut self.upcoming_sorted_footers, &[]);
+        }
+
+        let first_conflicting_index = other_footers
+            .iter()
+            .take_while(|f| f.level > next_footer.level)
+            .count()
+            + 1;
+
+        let (next_repeating_footers, new_upcoming_footers) =
+            self.upcoming_sorted_footers.split_at(first_conflicting_index);
+
+        self.upcoming_sorted_footers = new_upcoming_footers;
+        return next_repeating_footers;
+    }
+
     /// Updates `self.footer_height` by simulating the footer, and skips to fitting region.
     pub fn prepare_footer(
         &mut self,

From db2ac385a9122f8b1839a6e6cd350ee94431044a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 00:42:40 -0300
Subject: [PATCH 06/28] move height resets to finish region internal

---
 crates/typst-layout/src/grid/layouter.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 9f714ac86..d4682a9da 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1747,11 +1747,6 @@ impl<'a> GridLayouter<'a> {
         );
 
         if !last {
-            self.current.repeated_header_rows = 0;
-            self.current.last_repeated_header_end = 0;
-            self.current.repeating_header_height = Abs::zero();
-            self.current.repeating_header_heights.clear();
-
             let disambiguator = self.finished.len();
             if let Some(footer) =
                 self.grid.footer.as_ref().and_then(Repeatable::as_repeated)
@@ -1795,6 +1790,11 @@ impl<'a> GridLayouter<'a> {
 
         self.current.could_progress_at_top = self.regions.may_progress();
 
+        self.current.repeated_header_rows = 0;
+        self.current.last_repeated_header_end = 0;
+        self.current.repeating_header_height = Abs::zero();
+        self.current.repeating_header_heights.clear();
+
         if !self.grid.headers.is_empty() {
             self.finished_header_rows.push(header_row_info);
         }

From b63f6c99df0f5d0b243e85f4b2982ac6b07b4de7 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 00:42:40 -0300
Subject: [PATCH 07/28] initial footer simulation and placement

---
 crates/typst-layout/src/grid/layouter.rs | 111 +++++++-----
 crates/typst-layout/src/grid/repeated.rs | 222 +++++++++++++++++------
 2 files changed, 234 insertions(+), 99 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index d4682a9da..2c7f957f2 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -166,6 +166,12 @@ pub(super) struct Current {
     /// when finding a new header and causing existing repeating headers to
     /// stop.
     pub(super) repeating_header_heights: Vec<Abs>,
+    /// The height for each repeating footer that will be placed in this region.
+    ///
+    /// This is used to know how much to update `repeating_footer_height` by
+    /// when finding a footer and causing existing repeating footers to
+    /// stop (and new ones to start).
+    pub(super) repeating_footer_heights: Vec<Abs>,
     /// The simulated footer height for this region.
     ///
     /// The simulation occurs before any rows are laid out for a region.
@@ -264,7 +270,7 @@ impl<'a> GridLayouter<'a> {
             repeating_headers: vec![],
             upcoming_headers: &grid.headers,
             pending_headers: Default::default(),
-            // This is calculated on layout
+            // This is updated on layout
             repeating_footers: vec![],
             upcoming_footers: &grid.footers,
             upcoming_sorted_footers: &grid.sorted_footers,
@@ -279,6 +285,7 @@ impl<'a> GridLayouter<'a> {
                 lrows_orphan_snapshot: None,
                 repeating_header_height: Abs::zero(),
                 repeating_header_heights: vec![],
+                repeating_footer_heights: vec![],
                 footer_height: Abs::zero(),
             },
             span,
@@ -289,15 +296,12 @@ impl<'a> GridLayouter<'a> {
     pub fn layout(mut self, engine: &mut Engine) -> SourceResult<Fragment> {
         self.measure_columns(engine)?;
 
-        if let Some(footer) = &self.grid.footer {
-            if footer.repeated {
-                // Ensure rows in the first region will be aware of the
-                // possible presence of the footer.
-                self.prepare_footer(footer, engine, 0)?;
-                self.regions.size.y -= self.current.footer_height;
-                self.current.initial_after_repeats = self.regions.size.y;
-            }
-        }
+        self.prepare_next_repeating_footers(true, engine)?;
+
+        // Ensure rows in the first region will be aware of the possible
+        // presence of the footer.
+        self.regions.size.y -= self.current.footer_height;
+        self.current.initial_after_repeats = self.regions.size.y;
 
         let mut y = 0;
         let mut consecutive_header_count = 0;
@@ -313,13 +317,14 @@ impl<'a> GridLayouter<'a> {
                 }
             }
 
-            if let Some(footer) = &self.grid.footer {
-                if footer.repeated && y >= footer.start {
-                    if y == footer.start {
-                        self.layout_footer(footer, engine, self.finished.len())?;
-                        self.flush_orphans();
-                    }
-                    y = footer.end;
+            if let Some(next_footer) = self.upcoming_footers.first() {
+                // TODO(subfooters): effective range (consider gutter before
+                // if it was removed)
+                if next_footer.range().contains(&y) {
+                    self.place_new_footer(engine, next_footer)?;
+                    self.flush_orphans();
+                    y = next_footer.end;
+
                     continue;
                 }
             }
@@ -1581,26 +1586,25 @@ impl<'a> GridLayouter<'a> {
         // TODO(subfooters): explicitly check for short-lived footers.
         // TODO(subfooters): widow prevention for non-repeated footers with a
         // similar mechanism / when implementing multiple footers.
-        let footer_would_be_widow = matches!(&self.grid.footer, Some(footer) if footer.repeated)
+        let may_place_footers = !self.repeating_footers.is_empty()
             && self.current.lrows.is_empty()
             && self.current.could_progress_at_top;
 
-        let mut laid_out_footer_start = None;
-        if !footer_would_be_widow {
-            if let Some(footer) = &self.grid.footer {
-                // Don't layout the footer if it would be alone with the header
-                // in the page (hence the widow check), and don't layout it
-                // twice (check below).
-                //
-                // TODO(subfooters): this check can be replaced by a vector of
-                // repeating footers in the future, and/or some "pending
-                // footers" vector for footers we're about to place.
-                if footer.repeated
-                    && self.current.lrows.iter().all(|row| row.index() < footer.start)
-                {
-                    laid_out_footer_start = Some(footer.start);
-                    self.layout_footer(footer, engine, self.finished.len())?;
-                }
+        if may_place_footers {
+            // Don't layout the footer if it would be alone with the header
+            // in the page (hence the widow check), and don't layout it
+            // twice (it is removed from repeating_footers once it is
+            // reached).
+            //
+            // Use index for iteration to avoid borrow conflict.
+            //
+            // TODO(subfooters): "pending footers" vector for footers we're
+            // about to place. Needed for widow prevention of non-repeated
+            // footers.
+            let mut i = 0;
+            while let Some(footer) = self.repeating_footers.get(i) {
+                self.layout_footer(footer, false, engine, self.finished.len())?;
+                i += 1;
             }
         }
 
@@ -1699,12 +1703,24 @@ impl<'a> GridLayouter<'a> {
                 // laid out at the first frame of the row).
                 // Any rowspans ending before this row are laid out even
                 // on this row's first frame.
-                if laid_out_footer_start.is_none_or(|footer_start| {
-                    // If this is a footer row, then only lay out this rowspan
-                    // if the rowspan is contained within the footer.
-                    y < footer_start || rowspan.y >= footer_start
-                }) && (rowspan.y + rowspan.rowspan < y + 1
-                    || rowspan.y + rowspan.rowspan == y + 1 && is_last)
+                if !may_place_footers
+                    || self.repeating_footers.iter().all(|footer| {
+                        // If this is a footer row, then only lay out this rowspan
+                        // if the rowspan is contained within the footer.
+                        // Since the footer is a row from "the future", it
+                        // always has a larger Y than all active rowspans,
+                        // so we must not interpret a rowspan before it to have
+                        // already ended because we saw a repeated footer.
+                        //
+                        // Of course, not a concern for non-repeated or
+                        // short-lived footers as they only appear once.
+                        //
+                        // TODO(subfooters): use effective range
+                        // (what about the gutter?).
+                        !footer.range().contains(&y)
+                            || footer.range().contains(&rowspan.y)
+                    }) && (rowspan.y + rowspan.rowspan < y + 1
+                        || rowspan.y + rowspan.rowspan == y + 1 && is_last)
                 {
                     // Rowspan ends at this or an earlier row, so we take
                     // it from the rowspans vector and lay it out.
@@ -1748,10 +1764,15 @@ impl<'a> GridLayouter<'a> {
 
         if !last {
             let disambiguator = self.finished.len();
-            if let Some(footer) =
-                self.grid.footer.as_ref().and_then(Repeatable::as_repeated)
-            {
-                self.prepare_footer(footer, engine, disambiguator)?;
+            if !self.repeating_footers.is_empty() {
+                // TODO(subfooters): let's not...
+                let footers = self.repeating_footers.clone();
+                self.prepare_repeating_footers(
+                    footers.iter().map(|f| *f),
+                    true,
+                    engine,
+                    disambiguator,
+                )?;
             }
 
             // Ensure rows don't try to overrun the footer.
@@ -1794,6 +1815,8 @@ impl<'a> GridLayouter<'a> {
         self.current.last_repeated_header_end = 0;
         self.current.repeating_header_height = Abs::zero();
         self.current.repeating_header_heights.clear();
+        self.current.footer_height = Abs::zero();
+        self.current.repeating_footer_heights.clear();
 
         if !self.grid.headers.is_empty() {
             self.finished_header_rows.push(header_row_info);
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 7ca937e7e..89e785efc 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -240,16 +240,17 @@ impl<'a> GridLayouter<'a> {
             self.current.initial_after_repeats = self.regions.size.y;
         }
 
-        if let Some(footer) = &self.grid.footer {
-            if footer.repeated && skipped_region {
-                // Simulate the footer again; the region's 'full' might have
-                // changed.
-                self.regions.size.y += self.current.footer_height;
-                self.current.footer_height = self
-                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                    .height;
-                self.regions.size.y -= self.current.footer_height;
-            }
+        if !self.repeating_footers.is_empty() && skipped_region {
+            // Simulate the footer again; the region's 'full' might have
+            // changed.
+            let (footer_height, footer_heights) = self.simulate_footer_heights(
+                self.repeating_footers.iter().map(|x| *x),
+                engine,
+                disambiguator,
+            )?;
+
+            self.current.footer_height = footer_height;
+            self.current.repeating_footer_heights.extend(footer_heights);
         }
 
         let repeating_header_rows =
@@ -463,19 +464,89 @@ impl<'a> GridLayouter<'a> {
         )
     }
 
-    pub fn bump_repeating_footers(&mut self) -> &'a [Repeatable<Footer>] {
-        let [next_footer, other_footers @ ..] = self.upcoming_sorted_footers else {
-            return &[];
-        };
+    /// Place a footer we have reached through normal row layout.
+    pub fn place_new_footer(
+        &mut self,
+        engine: &mut Engine,
+        footer: &Repeatable<Footer>,
+    ) -> SourceResult<()> {
+        // TODO(subfooters): short-lived check
+        if !footer.repeated {
+            // TODO(subfooters): widow prevention for this.
+            // Will need some lookahead. For now, act as short-lived.
+            let footer_height =
+                self.simulate_footer(footer, &self.regions, engine, 0)?.height;
 
-        if !next_footer.repeated {
-            // TODO(subfooters): grouping and laying them out together?
-            self.upcoming_sorted_footers = other_footers;
-            return &[];
+            // Skip to fitting region where only this footer fits.
+            while self.unbreakable_rows_left == 0
+                && !self.regions.size.y.fits(footer_height)
+                && self.may_progress_with_repeats()
+            {
+                // Advance regions until we can place the footer.
+                // Treat as a normal row group.
+                self.finish_region(engine, false)?;
+            }
+
+            self.layout_footer(footer, true, engine, 0)?;
+        } else {
+            // Placing a non-short-lived repeating footer, so it must be
+            // the latest one in the repeating footers vector.
+            let latest_repeating_footer = self.repeating_footers.pop().unwrap();
+            assert_eq!(latest_repeating_footer.start, footer.start);
+
+            let expected_footer_height =
+                self.current.repeating_footer_heights.pop().unwrap();
+
+            // Ensure upcoming rows won't see that this footer will occupy
+            // any space in future regions anymore.
+            self.current.footer_height -= expected_footer_height;
+
+            // Ensure footer rows have their own expected height
+            // available. While not that relevant for them, as they will be
+            // laid out as an unbreakable row group, it's relevant for any
+            // further rows in the same region.
+            self.regions.size.y += expected_footer_height;
+
+            self.layout_footer(footer, false, engine, self.finished.len())?;
         }
 
-        if other_footers.is_empty() {
-            return std::mem::replace(&mut self.upcoming_sorted_footers, &[]);
+        // If the next group of footers would conflict with other repeating
+        // footers, wait for them to finish repeating before adding more to
+        // repeat.
+        if self.repeating_footers.is_empty()
+            || self
+                .upcoming_sorted_footers
+                .first()
+                .is_none_or(|f| f.level >= footer.level)
+        {
+            self.prepare_next_repeating_footers(false, engine);
+            return Ok(());
+        }
+
+        Ok(())
+    }
+
+    /// Takes all non-conflicting consecutive footers which are about to start
+    /// repeating, skips to the first region where they all fit, and pushes
+    /// them to `repeating_footers`, sorted by ascending levels.
+    pub fn prepare_next_repeating_footers(
+        &mut self,
+        first_footers: bool,
+        engine: &mut Engine,
+    ) -> SourceResult<()> {
+        let [next_footer, other_footers @ ..] = self.upcoming_sorted_footers else {
+            // No footers to take.
+            return Ok(());
+        };
+
+        // TODO(subfooters): also ignore short-lived footers.
+        if !next_footer.repeated {
+            // Skip this footer and don't do anything until we get to it.
+            //
+            // TODO(subfooters): grouping and laying out non-repeated with
+            // repeated, with widow prevention.
+            self.upcoming_sorted_footers = other_footers;
+            return Ok(());
         }
 
         let first_conflicting_index = other_footers
@@ -488,77 +559,110 @@ impl<'a> GridLayouter<'a> {
             self.upcoming_sorted_footers.split_at(first_conflicting_index);
 
         self.upcoming_sorted_footers = new_upcoming_footers;
-        return next_repeating_footers;
+        self.prepare_repeating_footers(
+            next_repeating_footers.iter().map(Repeatable::deref),
+            first_footers,
+            engine,
+            0,
+        );
+
+        Ok(())
     }
 
-    /// Updates `self.footer_height` by simulating the footer, and skips to fitting region.
-    pub fn prepare_footer(
+    /// Updates `self.current.repeating_footer_height` by simulating repeating
+    /// footers, and skips to fitting region.
+    pub fn prepare_repeating_footers(
         &mut self,
-        footer: &Footer,
+        footers: impl Iterator<Item = &'a Footer> + ExactSizeIterator + Clone,
+        at_region_top: bool,
         engine: &mut Engine,
         disambiguator: usize,
     ) -> SourceResult<()> {
-        let footer_height = self
-            .simulate_footer(footer, &self.regions, engine, disambiguator)?
-            .height;
+        let (mut expected_footer_height, mut expected_footer_heights) =
+            self.simulate_footer_heights(footers.clone(), engine, disambiguator)?;
+
+        // Skip to fitting region where all of them fit at once.
+        //
+        // Can't be widows: they are assumed to not be short-lived, so
+        // there is at least one non-footer before them, and this
+        // function is called right after placing a new footer, but
+        // before the next non-footer, or at the top of the region,
+        // at which point we haven't reached the row before the highest
+        // level footer yet since the footer itself won't cause a
+        // region break.
         let mut skipped_region = false;
         while self.unbreakable_rows_left == 0
-            && !self.regions.size.y.fits(footer_height)
+            && !self.regions.size.y.fits(expected_footer_height)
             && self.regions.may_progress()
         {
             // Advance regions without any output until we can place the
             // footer.
-            self.finish_region_internal(
-                Frame::soft(Axes::splat(Abs::zero())),
-                vec![],
-                Default::default(),
-            );
+            if at_region_top {
+                self.finish_region_internal(
+                    Frame::soft(Axes::splat(Abs::zero())),
+                    vec![],
+                    Default::default(),
+                );
+            } else {
+                self.finish_region(engine, false)?;
+            }
             skipped_region = true;
         }
 
-        // TODO(subfooters): Consider resetting header height etc. if we skip
-        // region. (Maybe move that step to `finish_region_internal`.)
-        //
-        // That is unnecessary at the moment as 'prepare_footers' is only
-        // called at the start of the region, so header height is always zero
-        // and no headers were placed so far, but what about when we can have
-        // footers in the middle of the region? Let's think about this then.
-        self.current.footer_height = if skipped_region {
+        if skipped_region {
             // Simulate the footer again; the region's 'full' might have
-            // changed.
-            self.simulate_footer(footer, &self.regions, engine, disambiguator)?
-                .height
-        } else {
-            footer_height
-        };
+            // changed, and the vector of heights was cleared.
+            (expected_footer_height, expected_footer_heights) =
+                self.simulate_footer_heights(footers, engine, disambiguator)?;
+        }
+
+        self.current.footer_height += expected_footer_height;
+        self.current.repeating_footer_heights.extend(expected_footer_heights);
 
         Ok(())
     }
 
+    fn simulate_footer_heights(
+        &self,
+        footers: impl Iterator<Item = &'a Footer> + ExactSizeIterator,
+        engine: &mut Engine,
+        disambiguator: usize,
+    ) -> SourceResult<(Abs, Vec<Abs>)> {
+        let mut total_footer_height = Abs::zero();
+        let mut footer_heights = Vec::with_capacity(footers.len());
+        for footer in footers {
+            let footer_height = self
+                .simulate_footer(footer, &self.regions, engine, disambiguator)?
+                .height;
+
+            total_footer_height += footer_height;
+            footer_heights.push(footer_height);
+        }
+
+        Ok((total_footer_height, footer_heights))
+    }
+
     /// Lays out all rows in the footer.
     /// They are unbreakable.
     pub fn layout_footer(
         &mut self,
         footer: &Footer,
+        as_short_lived: bool,
         engine: &mut Engine,
         disambiguator: usize,
     ) -> SourceResult<()> {
-        // Ensure footer rows have their own height available.
-        // Won't change much as we're creating an unbreakable row group
-        // anyway, so this is mostly for correctness.
-        self.regions.size.y += self.current.footer_height;
-
-        let repeats = self.grid.footer.as_ref().is_some_and(|f| f.repeated);
-        let footer_len = self.grid.rows.len() - footer.start;
+        let footer_len = footer.end - footer.start;
         self.unbreakable_rows_left += footer_len;
 
+        // TODO(subfooters): also consider omitted gutter before the footer
+        // when there is a header right before it taking it.
         for y in footer.start..self.grid.rows.len() {
             self.layout_row_with_state(
                 y,
                 engine,
                 disambiguator,
                 RowState {
-                    in_active_repeatable: repeats,
+                    in_active_repeatable: !as_short_lived,
                     ..Default::default()
                 },
             )?;
@@ -597,3 +701,11 @@ pub fn total_header_row_count<'h>(
 ) -> usize {
     headers.into_iter().map(|h| h.range.end - h.range.start).sum()
 }
+
+/// The total amount of rows in the given list of headers.
+#[inline]
+pub fn total_footer_row_count<'f>(
+    footers: impl IntoIterator<Item = &'f Footer>,
+) -> usize {
+    footers.into_iter().map(|f| f.end - f.start).sum()
+}

From 3de1237f54d1d61f1d7a70f22c69aafae1d178b1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 00:52:44 -0300
Subject: [PATCH 08/28] temporary workaround for footer lines

---
 crates/typst-layout/src/grid/lines.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index d5da7e263..973f0d21c 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -512,15 +512,18 @@ pub fn hline_stroke_at_column(
     );
 
     // Prioritize the footer's top stroke as well where applicable.
+    // TODO(subfooters): do this properly (store footer rows)
     let bottom_stroke_comes_from_footer = grid
-        .footer
-        .as_ref()
+        .footers
+        .last()
         .and_then(Repeatable::as_repeated)
         .is_some_and(|footer| {
             // Ensure the row below us is a repeated footer.
             // FIXME: Make this check more robust when footers at arbitrary
             // positions are added.
-            local_top_y.unwrap_or(0) + 1 < footer.start && y >= footer.start
+            footer.end == grid.rows.len()
+                && local_top_y.unwrap_or(0) + 1 < footer.start
+                && y >= footer.start
         });
 
     let (prioritized_cell_stroke, deprioritized_cell_stroke) =

From e89e3066a4946e7223d521caba02a9d6dc0e5e11 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 01:06:08 -0300
Subject: [PATCH 09/28] repeated method fixes

---
 crates/typst-layout/src/grid/layouter.rs |  2 +-
 crates/typst-layout/src/grid/repeated.rs | 34 +++++++++++-------------
 2 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 2c7f957f2..5d37584ec 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1768,7 +1768,7 @@ impl<'a> GridLayouter<'a> {
                 // TODO(subfooters): let's not...
                 let footers = self.repeating_footers.clone();
                 self.prepare_repeating_footers(
-                    footers.iter().map(|f| *f),
+                    footers.iter().copied(),
                     true,
                     engine,
                     disambiguator,
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 89e785efc..512593a5b 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -245,6 +245,7 @@ impl<'a> GridLayouter<'a> {
             // changed.
             let (footer_height, footer_heights) = self.simulate_footer_heights(
                 self.repeating_footers.iter().map(|x| *x),
+                &self.regions,
                 engine,
                 disambiguator,
             )?;
@@ -519,7 +520,7 @@ impl<'a> GridLayouter<'a> {
                 .first()
                 .is_none_or(|f| f.level >= footer.level)
         {
-            self.prepare_next_repeating_footers(false, engine);
+            self.prepare_next_repeating_footers(false, engine)?;
             return Ok(());
         }
 
@@ -564,7 +565,7 @@ impl<'a> GridLayouter<'a> {
             first_footers,
             engine,
             0,
-        );
+        )?;
 
         Ok(())
     }
@@ -578,8 +579,13 @@ impl<'a> GridLayouter<'a> {
         engine: &mut Engine,
         disambiguator: usize,
     ) -> SourceResult<()> {
-        let (mut expected_footer_height, mut expected_footer_heights) =
-            self.simulate_footer_heights(footers.clone(), engine, disambiguator)?;
+        let (mut expected_footer_height, mut expected_footer_heights) = self
+            .simulate_footer_heights(
+                footers.clone(),
+                &self.regions,
+                engine,
+                disambiguator,
+            )?;
 
         // Skip to fitting region where all of them fit at once.
         //
@@ -612,8 +618,8 @@ impl<'a> GridLayouter<'a> {
         if skipped_region {
             // Simulate the footer again; the region's 'full' might have
             // changed, and the vector of heights was cleared.
-            (expected_footer_height, expected_footer_heights) =
-                self.simulate_footer_heights(footers, engine, disambiguator)?;
+            (expected_footer_height, expected_footer_heights) = self
+                .simulate_footer_heights(footers, &self.regions, engine, disambiguator)?;
         }
 
         self.current.footer_height += expected_footer_height;
@@ -622,18 +628,18 @@ impl<'a> GridLayouter<'a> {
         Ok(())
     }
 
-    fn simulate_footer_heights(
+    pub fn simulate_footer_heights(
         &self,
         footers: impl Iterator<Item = &'a Footer> + ExactSizeIterator,
+        regions: &Regions<'_>,
         engine: &mut Engine,
         disambiguator: usize,
     ) -> SourceResult<(Abs, Vec<Abs>)> {
         let mut total_footer_height = Abs::zero();
         let mut footer_heights = Vec::with_capacity(footers.len());
         for footer in footers {
-            let footer_height = self
-                .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                .height;
+            let footer_height =
+                self.simulate_footer(footer, regions, engine, disambiguator)?.height;
 
             total_footer_height += footer_height;
             footer_heights.push(footer_height);
@@ -701,11 +707,3 @@ pub fn total_header_row_count<'h>(
 ) -> usize {
     headers.into_iter().map(|h| h.range.end - h.range.start).sum()
 }
-
-/// The total amount of rows in the given list of headers.
-#[inline]
-pub fn total_footer_row_count<'f>(
-    footers: impl IntoIterator<Item = &'f Footer>,
-) -> usize {
-    footers.into_iter().map(|f| f.end - f.start).sum()
-}

From 58db042ff325bda52309c42b28bfae4d9be2114a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 01:06:36 -0300
Subject: [PATCH 10/28] support repeated footers in rowspan simulation

---
 crates/typst-layout/src/grid/rowspans.rs | 57 ++++++++++++------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/crates/typst-layout/src/grid/rowspans.rs b/crates/typst-layout/src/grid/rowspans.rs
index 02ea14813..8feb23c32 100644
--- a/crates/typst-layout/src/grid/rowspans.rs
+++ b/crates/typst-layout/src/grid/rowspans.rs
@@ -234,24 +234,12 @@ impl GridLayouter<'_> {
         engine: &mut Engine,
     ) -> SourceResult<()> {
         if self.unbreakable_rows_left == 0 {
-            // By default, the amount of unbreakable rows starting at the
-            // current row is dynamic and depends on the amount of upcoming
-            // unbreakable cells (with or without a rowspan setting).
-            let mut amount_unbreakable_rows = None;
-            if let Some(footer) = &self.grid.footer {
-                if !footer.repeated && current_row >= footer.start {
-                    // Non-repeated footer, so keep it unbreakable.
-                    //
-                    // TODO(subfooters): This will become unnecessary
-                    // once non-repeated footers are treated differently and
-                    // have widow prevention.
-                    amount_unbreakable_rows = Some(self.grid.rows.len() - footer.start);
-                }
-            }
-
             let row_group = self.simulate_unbreakable_row_group(
                 current_row,
-                amount_unbreakable_rows,
+                // By default, the amount of unbreakable rows starting at the
+                // current row is dynamic and depends on the amount of upcoming
+                // unbreakable cells (with or without a rowspan setting).
+                None,
                 &self.regions,
                 engine,
                 0,
@@ -400,7 +388,8 @@ impl GridLayouter<'_> {
             if breakable
                 && (!self.repeating_headers.is_empty()
                     || !self.pending_headers.is_empty()
-                    || matches!(&self.grid.footer, Some(footer) if footer.repeated))
+                    // TODO(subfooters): pending footers
+                    || !self.repeating_footers.is_empty())
             {
                 // Subtract header and footer height from all upcoming regions
                 // when measuring the cell, including the last repeated region.
@@ -1176,14 +1165,23 @@ impl<'a> RowspanSimulator<'a> {
             (None, Abs::zero())
         };
 
-        let footer_height = if let Some(footer) =
-            layouter.grid.footer.as_ref().and_then(Repeatable::as_repeated)
+        let (repeating_footers, footer_height) = if layouter.repeating_footers.is_empty()
         {
-            layouter
-                .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                .height
+            (None, Abs::zero())
         } else {
-            Abs::zero()
+            // Only repeating footers have survived after the first region
+            // break.
+            // TODO(subfooters): consider pending footers
+            let repeating_footers = layouter.repeating_footers.iter().copied();
+
+            let (footer_height, _) = layouter.simulate_footer_heights(
+                repeating_footers.clone(),
+                &self.regions,
+                engine,
+                disambiguator,
+            )?;
+
+            (Some(repeating_footers), footer_height)
         };
 
         let mut skipped_region = false;
@@ -1212,15 +1210,18 @@ impl<'a> RowspanSimulator<'a> {
             };
         }
 
-        if let Some(footer) =
-            layouter.grid.footer.as_ref().and_then(Repeatable::as_repeated)
-        {
+        if let Some(repeating_footers) = repeating_footers {
             self.footer_height = if skipped_region {
                 // Simulate footers again, at the new region, as
                 // the full region height may change.
                 layouter
-                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                    .height
+                    .simulate_footer_heights(
+                        repeating_footers,
+                        &self.regions,
+                        engine,
+                        disambiguator,
+                    )?
+                    .0
             } else {
                 footer_height
             };

From 9422ecc74ade554a755659c41eecf1e6beaf87e1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 01:11:30 -0300
Subject: [PATCH 11/28] fix footer progression

---
 crates/typst-layout/src/grid/layouter.rs | 3 ++-
 crates/typst-layout/src/grid/repeated.rs | 3 +++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 5d37584ec..d068c134e 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -317,10 +317,11 @@ impl<'a> GridLayouter<'a> {
                 }
             }
 
-            if let Some(next_footer) = self.upcoming_footers.first() {
+            if let [next_footer, other_footers @ ..] = self.upcoming_footers {
                 // TODO(subfooters): effective range (consider gutter before
                 // if it was removed)
                 if next_footer.range().contains(&y) {
+                    self.upcoming_footers = other_footers;
                     self.place_new_footer(engine, next_footer)?;
                     self.flush_orphans();
                     y = next_footer.end;
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 512593a5b..4fdbd8e62 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -567,6 +567,9 @@ impl<'a> GridLayouter<'a> {
             0,
         )?;
 
+        self.repeating_footers
+            .extend(next_repeating_footers.iter().filter_map(Repeatable::as_repeated));
+
         Ok(())
     }
 

From b26e004be98ea437b3fa60cd0b397a2787862004 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Wed, 21 May 2025 01:11:30 -0300
Subject: [PATCH 12/28] fix footer widow check and rowspans

---
 crates/typst-layout/src/grid/layouter.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index d068c134e..d5aca0586 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1587,9 +1587,10 @@ impl<'a> GridLayouter<'a> {
         // TODO(subfooters): explicitly check for short-lived footers.
         // TODO(subfooters): widow prevention for non-repeated footers with a
         // similar mechanism / when implementing multiple footers.
+        // TODO(subfooters): could progress check must be replaced to consider
+        // the presence of non-repeating footer (then always true).
         let may_place_footers = !self.repeating_footers.is_empty()
-            && self.current.lrows.is_empty()
-            && self.current.could_progress_at_top;
+            && (!self.current.lrows.is_empty() || !self.current.could_progress_at_top);
 
         if may_place_footers {
             // Don't layout the footer if it would be alone with the header
@@ -1704,7 +1705,7 @@ impl<'a> GridLayouter<'a> {
                 // laid out at the first frame of the row).
                 // Any rowspans ending before this row are laid out even
                 // on this row's first frame.
-                if !may_place_footers
+                if (!may_place_footers
                     || self.repeating_footers.iter().all(|footer| {
                         // If this is a footer row, then only lay out this rowspan
                         // if the rowspan is contained within the footer.
@@ -1720,7 +1721,8 @@ impl<'a> GridLayouter<'a> {
                         // (what about the gutter?).
                         !footer.range().contains(&y)
                             || footer.range().contains(&rowspan.y)
-                    }) && (rowspan.y + rowspan.rowspan < y + 1
+                    }))
+                    && (rowspan.y + rowspan.rowspan < y + 1
                         || rowspan.y + rowspan.rowspan == y + 1 && is_last)
                 {
                     // Rowspan ends at this or an earlier row, so we take

From f9b1bfd1b034b12e57d892034b8caf9c34661803 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Thu, 12 Jun 2025 02:17:11 -0300
Subject: [PATCH 13/28] fix tfoot in table html

---
 crates/typst-library/src/model/table.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index 367d3e66f..917953981 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -297,7 +297,7 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
     // appear to be an equivalent of 'th' for footers in HTML.)
     // TODO: test
     let footer = {
-        let mut consecutive_footer_start = grid.footers.len();
+        let mut consecutive_footer_start = grid.rows.len();
         let footers_at_end = grid
             .footers
             .iter()
@@ -312,7 +312,9 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
 
         if footers_at_end > 0 {
             let last_mid_table_footer = grid.footers.len() - footers_at_end;
-            let rows = rows.drain(last_mid_table_footer..);
+            let removed_footer_rows =
+                grid.footers.get(last_mid_table_footer).unwrap().start;
+            let rows = rows.drain(removed_footer_rows..);
 
             Some(elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row)))))
         } else {

From 0951fe13fd96e91620434dd19fb33f2993d6624f Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 24 May 2025 04:12:06 -0300
Subject: [PATCH 14/28] resolve multiple footers

---
 crates/typst-layout/src/grid/lines.rs         |   4 +-
 .../typst-library/src/layout/grid/resolve.rs  | 237 +++++++++---------
 tests/suite/layout/grid/footers.typ           |   3 -
 3 files changed, 122 insertions(+), 122 deletions(-)

diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index 973f0d21c..0ea113ac1 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -641,7 +641,7 @@ mod test {
             vec![],
             vec![],
             vec![],
-            None,
+            vec![],
             entries,
         )
     }
@@ -1179,7 +1179,7 @@ mod test {
             vec![],
             vec![],
             vec![],
-            None,
+            vec![],
             entries,
         )
     }
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 78f5cd42f..1e607ccca 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -697,7 +697,7 @@ impl<'a> CellGrid<'a> {
         cells: impl IntoIterator<Item = Cell<'a>>,
     ) -> Self {
         let entries = cells.into_iter().map(Entry::Cell).collect();
-        Self::new_internal(tracks, gutter, vec![], vec![], vec![], None, entries)
+        Self::new_internal(tracks, gutter, vec![], vec![], vec![], vec![], entries)
     }
 
     /// Generates the cell grid, given the tracks and resolved entries.
@@ -707,7 +707,7 @@ impl<'a> CellGrid<'a> {
         vlines: Vec<Vec<Line>>,
         hlines: Vec<Vec<Line>>,
         headers: Vec<Repeatable<Header>>,
-        footer: Option<Repeatable<Footer>>,
+        footers: Vec<Repeatable<Footer>>,
         entries: Vec<Entry<'a>>,
     ) -> Self {
         let mut cols = vec![];
@@ -754,7 +754,6 @@ impl<'a> CellGrid<'a> {
             rows.pop();
         }
 
-        let footers: Vec<Repeatable<Footer>> = footer.into_iter().collect();
         let sorted_footers = simulate_footer_repetition(&footers);
 
         Self {
@@ -991,6 +990,7 @@ struct RowGroupData {
     ///
     /// This stays as `None` for fully empty headers and footers.
     range: Option<Range<usize>>,
+    #[allow(dead_code)] // TODO: should we remove this?
     span: Span,
     kind: RowGroupKind,
 
@@ -1048,11 +1048,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         let has_gutter = self.gutter.any(|tracks| !tracks.is_empty());
 
         let mut headers: Vec<Repeatable<Header>> = vec![];
-
-        // Stores where the footer is supposed to end, its span, and the
-        // actual footer structure.
-        let mut footer: Option<(usize, Span, Footer)> = None;
-        let mut repeat_footer = false;
+        let mut footers: Vec<Repeatable<Footer>> = vec![];
 
         // If true, there has been at least one cell besides headers and
         // footers. When false, footers at the end are forced to not repeat.
@@ -1074,10 +1070,11 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         // automatically-positioned cell.
         let mut auto_index: usize = 0;
 
-        // The next header after the latest auto-positioned cell. This is used
-        // to avoid checking for collision with headers that were already
-        // skipped.
+        // The next header and footer after the latest auto-positioned cell.
+        // These are used to avoid checking for collision with headers that
+        // were already skipped.
         let mut next_header = 0;
+        let mut next_footer = 0;
 
         // We have to rebuild the grid to account for fixed cell positions.
         //
@@ -1100,10 +1097,10 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 &mut pending_hlines,
                 &mut pending_vlines,
                 &mut headers,
-                &mut footer,
-                &mut repeat_footer,
+                &mut footers,
                 &mut auto_index,
                 &mut next_header,
+                &mut next_footer,
                 &mut resolved_cells,
                 &mut at_least_one_cell,
                 child,
@@ -1121,11 +1118,10 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
             row_amount,
         )?;
 
-        let footer = self.finalize_headers_and_footers(
+        self.finalize_headers_and_footers(
             has_gutter,
             &mut headers,
-            footer,
-            repeat_footer,
+            &mut footers,
             row_amount,
             at_least_one_cell,
         )?;
@@ -1136,7 +1132,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
             vlines,
             hlines,
             headers,
-            footer,
+            footers,
             resolved_cells,
         ))
     }
@@ -1156,10 +1152,10 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         pending_hlines: &mut Vec<(Span, Line, bool)>,
         pending_vlines: &mut Vec<(Span, Line)>,
         headers: &mut Vec<Repeatable<Header>>,
-        footer: &mut Option<(usize, Span, Footer)>,
-        repeat_footer: &mut bool,
+        footers: &mut Vec<Repeatable<Footer>>,
         auto_index: &mut usize,
         next_header: &mut usize,
+        next_footer: &mut usize,
         resolved_cells: &mut Vec<Option<Entry<'x>>>,
         at_least_one_cell: &mut bool,
         child: ResolvableGridChild<T, I>,
@@ -1212,6 +1208,12 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
             &mut (*next_header).clone()
         };
 
+        let local_next_footer = if matches!(child, ResolvableGridChild::Item(_)) {
+            next_footer
+        } else {
+            &mut (*next_footer).clone()
+        };
+
         // The first row in which this table group can fit.
         //
         // Within headers and footers, this will correspond to the first
@@ -1249,10 +1251,6 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 (Some(items), None)
             }
             ResolvableGridChild::Footer { repeat, span, items, .. } => {
-                if footer.is_some() {
-                    bail!(span, "cannot have more than one footer");
-                }
-
                 row_group_data = Some(RowGroupData {
                     range: None,
                     span,
@@ -1396,10 +1394,11 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                     colspan,
                     rowspan,
                     headers,
-                    footer.as_ref(),
+                    footers,
                     resolved_cells,
                     local_auto_index,
                     local_next_header,
+                    local_next_footer,
                     first_available_row,
                     columns,
                     row_group_data.is_some(),
@@ -1621,23 +1620,23 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 RowGroupKind::Footer => {
                     // Only check if the footer is at the end later, once we know
                     // the final amount of rows.
-                    *footer = Some((
-                        group_range.end,
-                        row_group.span,
-                        Footer {
-                            // Later on, we have to correct this number in case there
-                            // is gutter, but only once all cells have been analyzed
-                            // and the header's and footer's exact boundaries are
-                            // known. That is because the gutter row immediately
-                            // before the footer might not be included as part of
-                            // the footer if it is contained within the header.
-                            start: group_range.start,
-                            end: group_range.end,
-                            level: 1,
-                        },
-                    ));
+                    let data = Footer {
+                        // Later on, we have to correct this number in case there
+                        // is gutter, but only once all cells have been analyzed
+                        // and the header's and footer's exact boundaries are
+                        // known. That is because the gutter row immediately
+                        // before the footer might not be included as part of
+                        // the footer if it is contained within the header.
+                        start: group_range.start,
+                        end: group_range.end,
+                        level: row_group.repeatable_level.get(),
+                    };
 
-                    *repeat_footer = row_group.repeat;
+                    footers.push(if row_group.repeat {
+                        Repeatable::Repeated(data)
+                    } else {
+                        Repeatable::NotRepeated(data)
+                    });
                 }
             }
         }
@@ -1807,24 +1806,30 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         &self,
         has_gutter: bool,
         headers: &mut [Repeatable<Header>],
-        footer: Option<(usize, Span, Footer)>,
-        repeat_footer: bool,
+        footers: &mut [Repeatable<Footer>],
         row_amount: usize,
         at_least_one_cell: bool,
-    ) -> SourceResult<Option<Repeatable<Footer>>> {
+    ) -> SourceResult<()> {
         // Mark consecutive headers right before the end of the table, or the
         // final footer, as short lived, given that there are no normal rows
         // after them, so repeating them is pointless.
         //
-        // It is important to do this BEFORE we update header and footer ranges
-        // due to gutter below as 'row_amount' doesn't consider gutter.
-        //
         // TODO(subfooters): take the last footer if it is at the end and
         // backtrack through consecutive footers until the first one in the
         // sequence is found. If there is no footer at the end, there are no
         // haeders to turn short-lived.
-        let mut consecutive_header_start =
-            footer.as_ref().map(|(_, _, f)| f.start).unwrap_or(row_amount);
+        //
+        // TODO: interleaved headers and footers?
+        let mut first_end_footer = row_amount;
+        for end_footer in footers.iter().rev() {
+            if end_footer.end != first_end_footer {
+                break;
+            }
+
+            first_end_footer = end_footer.start;
+        }
+
+        let mut consecutive_header_start = first_end_footer;
         for header_at_the_end in headers.iter_mut().rev().take_while(move |h| {
             let at_the_end = h.range.end == consecutive_header_start;
 
@@ -1863,13 +1868,9 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 let row_amount = (2 * row_amount).saturating_sub(1);
                 header.range.end = header.range.end.min(row_amount);
             }
-        }
 
-        let footer = footer
-            .map(|(footer_end, footer_span, mut footer)| {
-                if footer_end != row_amount {
-                    bail!(footer_span, "footer must end at the last row");
-                }
+            for repeatable_footer in &mut *footers {
+                let footer = repeatable_footer.unwrap_mut();
 
                 // TODO(subfooters): will need a global slice of headers and
                 // footers for when we have multiple footers
@@ -1883,45 +1884,37 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 // out the footer for real, the mechanism can be disabled.
                 let last_header_end = headers.last().map(|header| header.range.end);
 
-                if has_gutter {
-                    // Convert the footer's start index to post-gutter coordinates.
-                    footer.start *= 2;
+                // Convert the footer's start index to post-gutter coordinates.
+                footer.start *= 2;
 
-                    // Include the gutter right before the footer, unless there is
-                    // none, or the gutter is already included in the header (no
-                    // rows between the header and the footer).
-                    if last_header_end != Some(footer.start) {
-                        footer.start = footer.start.saturating_sub(1);
-                    }
-
-                    // Adapt footer end but DO NOT include the gutter below it,
-                    // if it exists. Calculation:
-                    // - Starts as 'last y + 1'.
-                    // - The result will be
-                    // 2 * (last_y + 1) - 1 = 2 * last_y + 1,
-                    // which is the new index of the last footer row plus one,
-                    // meaning we do exclude any gutter below this way.
-                    //
-                    // It also keeps us within the total amount of rows, so we
-                    // don't need to '.min()' later.
-                    footer.end = (2 * footer.end).saturating_sub(1);
+                // TODO: this probably has to change
+                // Include the gutter right before the footer, unless there is
+                // none, or the gutter is already included in the header (no
+                // rows between the header and the footer).
+                if last_header_end != Some(footer.start) {
+                    footer.start = footer.start.saturating_sub(1);
                 }
 
-                Ok(footer)
-            })
-            .transpose()?
-            .map(|footer| {
-                // Don't repeat footers when the table only has headers and
-                // footers.
-                // TODO(subfooters): Switch this to marking the last N
-                // consecutive footers as short lived.
-                Repeatable {
-                    inner: footer,
-                    repeated: repeat_footer && at_least_one_cell,
-                }
-            });
+                // Adapt footer end but DO NOT include the gutter below it,
+                // if it exists. Calculation:
+                // - Starts as 'last y + 1'.
+                // - The result will be
+                // 2 * (last_y + 1) - 1 = 2 * last_y + 1,
+                // which is the new index of the last footer row plus one,
+                // meaning we do exclude any gutter below this way.
+                //
+                // It also keeps us within the total amount of rows, so we
+                // don't need to '.min()' later.
+                footer.end = (2 * footer.end).saturating_sub(1);
 
-        Ok(footer)
+                if !at_least_one_cell {
+                    // TODO: short-lived (and remove this?)
+                    repeatable_footer.repeated = false;
+                }
+            }
+        }
+
+        Ok(())
     }
 
     /// Resolves the cell's fields based on grid-wide properties.
@@ -2093,7 +2086,7 @@ fn expand_row_group(
 /// Check if a cell's fixed row would conflict with a header or footer.
 fn check_for_conflicting_cell_row(
     headers: &[Repeatable<Header>],
-    footer: Option<&(usize, Span, Footer)>,
+    footers: &[Repeatable<Footer>],
     cell_y: usize,
     rowspan: usize,
 ) -> HintedStrResult<()> {
@@ -2112,13 +2105,14 @@ fn check_for_conflicting_cell_row(
         );
     }
 
-    if let Some((_, _, footer)) = footer {
-        if cell_y < footer.end && cell_y + rowspan > footer.start {
-            bail!(
-                "cell would conflict with footer spanning the same position";
-                hint: "try reducing the cell's rowspan or moving the footer"
-            );
-        }
+    if footers
+        .iter()
+        .any(|footer| cell_y < footer.end && cell_y + rowspan > footer.start)
+    {
+        bail!(
+            "cell would conflict with footer spanning the same position";
+            hint: "try reducing the cell's rowspan or moving the footer"
+        );
     }
 
     Ok(())
@@ -2140,10 +2134,11 @@ fn resolve_cell_position(
     colspan: usize,
     rowspan: usize,
     headers: &[Repeatable<Header>],
-    footer: Option<&(usize, Span, Footer)>,
+    footers: &[Repeatable<Footer>],
     resolved_cells: &[Option<Entry>],
     auto_index: &mut usize,
     next_header: &mut usize,
+    next_footer: &mut usize,
     first_available_row: usize,
     columns: usize,
     in_row_group: bool,
@@ -2166,11 +2161,12 @@ fn resolve_cell_position(
             // simply skipping existing cells, headers and footers.
             let resolved_index = find_next_available_position(
                 headers,
-                footer,
+                footers,
                 resolved_cells,
                 columns,
                 *auto_index,
                 next_header,
+                next_footer,
                 false,
             )?;
 
@@ -2207,7 +2203,7 @@ fn resolve_cell_position(
                 // footer (but only if it isn't already in one, otherwise there
                 // will already be a separate check).
                 if !in_row_group {
-                    check_for_conflicting_cell_row(headers, footer, cell_y, rowspan)?;
+                    check_for_conflicting_cell_row(headers, footers, cell_y, rowspan)?;
                 }
 
                 cell_index(cell_x, cell_y)
@@ -2226,25 +2222,26 @@ fn resolve_cell_position(
                 // cell in.
                 find_next_available_position(
                     headers,
-                    footer,
+                    footers,
                     resolved_cells,
                     columns,
                     initial_index,
-                    // Make our own copy of the 'next_header' counter, since it
-                    // should only be updated by auto cells. However, we cannot
-                    // start with the same value as we are searching from the
-                    // start, and not from 'auto_index', so auto cells might
-                    // have skipped some headers already which this cell will
-                    // also need to skip.
+                    // Make new copies of the 'next_header/footer' counters,
+                    // since they should only be updated by auto cells.
+                    // However, we cannot start with the same values as we are
+                    // searching from the start, and not from 'auto_index', so
+                    // auto cells might have skipped some headers and footers
+                    // already which this cell will also need to skip.
                     //
-                    // We could, in theory, keep a separate 'next_header'
-                    // counter for cells with fixed columns. But then we would
+                    // We could, in theory, keep separate 'next_header/footer'
+                    // counters for cells with fixed columns. But then we would
                     // need one for every column, and much like how there isn't
                     // an index counter for each column either, the potential
                     // speed gain seems less relevant for a less used feature.
                     // Still, it is something to consider for the future if
                     // this turns out to be a bottleneck in important cases.
                     &mut 0,
+                    &mut 0,
                     true,
                 )
             }
@@ -2255,7 +2252,7 @@ fn resolve_cell_position(
             // footer (but only if it isn't already in one, otherwise there
             // will already be a separate check).
             if !in_row_group {
-                check_for_conflicting_cell_row(headers, footer, cell_y, rowspan)?;
+                check_for_conflicting_cell_row(headers, footers, cell_y, rowspan)?;
             }
 
             // Let's find the first column which has that row available.
@@ -2293,11 +2290,12 @@ fn resolve_cell_position(
 #[inline]
 fn find_next_available_position(
     headers: &[Repeatable<Header>],
-    footer: Option<&(usize, Span, Footer)>,
+    footers: &[Repeatable<Footer>],
     resolved_cells: &[Option<Entry<'_>>],
     columns: usize,
     initial_index: usize,
     next_header: &mut usize,
+    next_footer: &mut usize,
     skip_rows: bool,
 ) -> HintedStrResult<usize> {
     let mut resolved_index = initial_index;
@@ -2341,15 +2339,20 @@ fn find_next_available_position(
 
             // From now on, only check the headers afterwards.
             *next_header += 1;
-        } else if let Some((footer_end, _, _)) = footer.filter(|(end, _, footer)| {
-            resolved_index >= footer.start * columns && resolved_index < *end * columns
-        }) {
+        } else if let Some(footer) = footers
+            .get(*next_footer)
+            .filter(|footer| resolved_index >= footer.start * columns)
+        {
             // Skip footer, for the same reason.
-            resolved_index = *footer_end * columns;
+            if resolved_index < footer.end * columns {
+                resolved_index = footer.end * columns;
 
-            if skip_rows {
-                resolved_index += initial_index % columns;
+                if skip_rows {
+                    resolved_index += initial_index % columns;
+                }
             }
+
+            *next_footer += 1;
         } else {
             return Ok(resolved_index);
         }
diff --git a/tests/suite/layout/grid/footers.typ b/tests/suite/layout/grid/footers.typ
index c0b03f50a..f37f63ae6 100644
--- a/tests/suite/layout/grid/footers.typ
+++ b/tests/suite/layout/grid/footers.typ
@@ -89,7 +89,6 @@
   stroke: black,
   inset: 5pt,
   grid.cell(x: 1)[a],
-  // Error: 3-56 footer must end at the last row
   grid.footer(grid.cell(x: 0)[b1], grid.cell(x: 0)[b2]),
   // This should skip the footer
   grid.cell(x: 1)[c]
@@ -141,14 +140,12 @@
 )
 
 --- grid-footer-not-at-last-row ---
-// Error: 2:3-2:19 footer must end at the last row
 #grid(
   grid.footer([a]),
   [b],
 )
 
 --- grid-footer-not-at-last-row-two-columns ---
-// Error: 3:3-3:19 footer must end at the last row
 #grid(
   columns: 2,
   grid.footer([a]),

From b3fd4676c47c79fdbcc727f218927a92354d91d8 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Thu, 12 Jun 2025 21:10:11 -0300
Subject: [PATCH 15/28] not using repeatable

---
 crates/typst-library/src/layout/grid/resolve.rs | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 1e607ccca..7b4130b44 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -1632,11 +1632,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                         level: row_group.repeatable_level.get(),
                     };
 
-                    footers.push(if row_group.repeat {
-                        Repeatable::Repeated(data)
-                    } else {
-                        Repeatable::NotRepeated(data)
-                    });
+                    footers.push(Repeatable { inner: data, repeated: row_group.repeat });
                 }
             }
         }
@@ -1869,9 +1865,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 header.range.end = header.range.end.min(row_amount);
             }
 
-            for repeatable_footer in &mut *footers {
-                let footer = repeatable_footer.unwrap_mut();
-
+            for footer in &mut *footers {
                 // TODO(subfooters): will need a global slice of headers and
                 // footers for when we have multiple footers
                 // Alternatively, never include the gutter in the footer's
@@ -1909,7 +1903,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
 
                 if !at_least_one_cell {
                     // TODO: short-lived (and remove this?)
-                    repeatable_footer.repeated = false;
+                    footer.repeated = false;
                 }
             }
         }

From bd7e403a6d9fc1de03c26b37a867a402584ce2ac Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Thu, 12 Jun 2025 21:30:25 -0300
Subject: [PATCH 16/28] fix last repeating footers not being pushed

---
 crates/typst-library/src/layout/grid/resolve.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 7b4130b44..9738ed73d 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -2441,6 +2441,8 @@ fn simulate_footer_repetition(footers: &[Repeatable<Footer>]) -> Vec<Repeatable<
         }
     }
 
+    // Push remaining footers that repeat starting from the top of the grid
+    ordered_footers.extend(repeating_footers.into_iter().rev().cloned());
     ordered_footers.reverse();
 
     ordered_footers

From 183f47ecc034a534612a52f635cc696159e30329 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 01:27:33 -0300
Subject: [PATCH 17/28] use footer.range like header.range

---
 crates/typst-layout/src/grid/layouter.rs      |  7 ++--
 crates/typst-layout/src/grid/lines.rs         |  6 +--
 crates/typst-layout/src/grid/repeated.rs      | 10 ++---
 .../typst-library/src/layout/grid/resolve.rs  | 39 +++++++------------
 crates/typst-library/src/model/table.rs       |  6 +--
 5 files changed, 28 insertions(+), 40 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index d5aca0586..31e17894d 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -320,11 +320,11 @@ impl<'a> GridLayouter<'a> {
             if let [next_footer, other_footers @ ..] = self.upcoming_footers {
                 // TODO(subfooters): effective range (consider gutter before
                 // if it was removed)
-                if next_footer.range().contains(&y) {
+                if next_footer.range.contains(&y) {
                     self.upcoming_footers = other_footers;
                     self.place_new_footer(engine, next_footer)?;
                     self.flush_orphans();
-                    y = next_footer.end;
+                    y = next_footer.range.end;
 
                     continue;
                 }
@@ -1719,8 +1719,7 @@ impl<'a> GridLayouter<'a> {
                         //
                         // TODO(subfooters): use effective range
                         // (what about the gutter?).
-                        !footer.range().contains(&y)
-                            || footer.range().contains(&rowspan.y)
+                        !footer.range.contains(&y) || footer.range.contains(&rowspan.y)
                     }))
                     && (rowspan.y + rowspan.rowspan < y + 1
                         || rowspan.y + rowspan.rowspan == y + 1 && is_last)
diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index 0ea113ac1..b75c7177f 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -521,9 +521,9 @@ pub fn hline_stroke_at_column(
             // Ensure the row below us is a repeated footer.
             // FIXME: Make this check more robust when footers at arbitrary
             // positions are added.
-            footer.end == grid.rows.len()
-                && local_top_y.unwrap_or(0) + 1 < footer.start
-                && y >= footer.start
+            footer.range.end == grid.rows.len()
+                && local_top_y.unwrap_or(0) + 1 < footer.range.start
+                && y >= footer.range.start
         });
 
     let (prioritized_cell_stroke, deprioritized_cell_stroke) =
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 4fdbd8e62..c1fbe7e00 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -493,7 +493,7 @@ impl<'a> GridLayouter<'a> {
             // Placing a non-short-lived repeating footer, so it must be
             // the latest one in the repeating footers vector.
             let latest_repeating_footer = self.repeating_footers.pop().unwrap();
-            assert_eq!(latest_repeating_footer.start, footer.start);
+            assert_eq!(latest_repeating_footer.range.start, footer.range.start);
 
             let expected_footer_height =
                 self.current.repeating_footer_heights.pop().unwrap();
@@ -660,12 +660,12 @@ impl<'a> GridLayouter<'a> {
         engine: &mut Engine,
         disambiguator: usize,
     ) -> SourceResult<()> {
-        let footer_len = footer.end - footer.start;
+        let footer_len = footer.range.end - footer.range.start;
         self.unbreakable_rows_left += footer_len;
 
         // TODO(subfooters): also consider omitted gutter before the footer
         // when there is a header right before it taking it.
-        for y in footer.start..self.grid.rows.len() {
+        for y in footer.range.start..self.grid.rows.len() {
             self.layout_row_with_state(
                 y,
                 engine,
@@ -694,8 +694,8 @@ impl<'a> GridLayouter<'a> {
         // assume that the amount of unbreakable rows following the first row
         // in the footer will be precisely the rows in the footer.
         self.simulate_unbreakable_row_group(
-            footer.start,
-            Some(footer.end - footer.start),
+            footer.range.start,
+            Some(footer.range.end - footer.range.start),
             regions,
             engine,
             disambiguator,
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 9738ed73d..fc1d13564 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -447,24 +447,14 @@ pub struct Header {
 /// A repeatable grid footer. Stops at the last row.
 #[derive(Debug, Clone)]
 pub struct Footer {
-    /// The first row included in this footer.
-    pub start: usize,
-    /// The index after the last row included in this footer.
-    pub end: usize,
+    /// The range of rows included in this footer.
+    pub range: Range<usize>,
     /// The footer's level.
     ///
     /// Used similarly to header level.
     pub level: u32,
 }
 
-impl Footer {
-    /// The footer's range of included rows.
-    #[inline]
-    pub fn range(&self) -> Range<usize> {
-        self.start..self.end
-    }
-}
-
 /// A possibly repeatable grid child (header or footer).
 ///
 /// It still exists even when not repeatable, but must not have additional
@@ -1621,14 +1611,13 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                     // Only check if the footer is at the end later, once we know
                     // the final amount of rows.
                     let data = Footer {
-                        // Later on, we have to correct this number in case there
+                        // Later on, we have to correct this range in case there
                         // is gutter, but only once all cells have been analyzed
                         // and the header's and footer's exact boundaries are
                         // known. That is because the gutter row immediately
                         // before the footer might not be included as part of
                         // the footer if it is contained within the header.
-                        start: group_range.start,
-                        end: group_range.end,
+                        range: group_range,
                         level: row_group.repeatable_level.get(),
                     };
 
@@ -1818,11 +1807,11 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         // TODO: interleaved headers and footers?
         let mut first_end_footer = row_amount;
         for end_footer in footers.iter().rev() {
-            if end_footer.end != first_end_footer {
+            if end_footer.range.end != first_end_footer {
                 break;
             }
 
-            first_end_footer = end_footer.start;
+            first_end_footer = end_footer.range.start;
         }
 
         let mut consecutive_header_start = first_end_footer;
@@ -1879,14 +1868,14 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 let last_header_end = headers.last().map(|header| header.range.end);
 
                 // Convert the footer's start index to post-gutter coordinates.
-                footer.start *= 2;
+                footer.range.start *= 2;
 
                 // TODO: this probably has to change
                 // Include the gutter right before the footer, unless there is
                 // none, or the gutter is already included in the header (no
                 // rows between the header and the footer).
-                if last_header_end != Some(footer.start) {
-                    footer.start = footer.start.saturating_sub(1);
+                if last_header_end != Some(footer.range.start) {
+                    footer.range.start = footer.range.start.saturating_sub(1);
                 }
 
                 // Adapt footer end but DO NOT include the gutter below it,
@@ -1899,7 +1888,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 //
                 // It also keeps us within the total amount of rows, so we
                 // don't need to '.min()' later.
-                footer.end = (2 * footer.end).saturating_sub(1);
+                footer.range.end = (2 * footer.range.end).saturating_sub(1);
 
                 if !at_least_one_cell {
                     // TODO: short-lived (and remove this?)
@@ -2101,7 +2090,7 @@ fn check_for_conflicting_cell_row(
 
     if footers
         .iter()
-        .any(|footer| cell_y < footer.end && cell_y + rowspan > footer.start)
+        .any(|footer| cell_y < footer.range.end && cell_y + rowspan > footer.range.start)
     {
         bail!(
             "cell would conflict with footer spanning the same position";
@@ -2335,11 +2324,11 @@ fn find_next_available_position(
             *next_header += 1;
         } else if let Some(footer) = footers
             .get(*next_footer)
-            .filter(|footer| resolved_index >= footer.start * columns)
+            .filter(|footer| resolved_index >= footer.range.start * columns)
         {
             // Skip footer, for the same reason.
-            if resolved_index < footer.end * columns {
-                resolved_index = footer.end * columns;
+            if resolved_index < footer.range.end * columns {
+                resolved_index = footer.range.end * columns;
 
                 if skip_rows {
                     resolved_index += initial_index % columns;
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index 917953981..0b905bd5f 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -303,8 +303,8 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
             .iter()
             .rev()
             .take_while(|ft| {
-                let is_consecutive = ft.end == consecutive_footer_start;
-                consecutive_footer_start = ft.start;
+                let is_consecutive = ft.range.end == consecutive_footer_start;
+                consecutive_footer_start = ft.range.start;
 
                 is_consecutive
             })
@@ -313,7 +313,7 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
         if footers_at_end > 0 {
             let last_mid_table_footer = grid.footers.len() - footers_at_end;
             let removed_footer_rows =
-                grid.footers.get(last_mid_table_footer).unwrap().start;
+                grid.footers.get(last_mid_table_footer).unwrap().range.start;
             let rows = rows.drain(removed_footer_rows..);
 
             Some(elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row)))))

From 7ee5dfaa8943ce3073928868e1d83b102175f578 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 01:31:35 -0300
Subject: [PATCH 18/28] fix footer layout range

---
 crates/typst-layout/src/grid/repeated.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index c1fbe7e00..2f9a5a947 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -665,7 +665,7 @@ impl<'a> GridLayouter<'a> {
 
         // TODO(subfooters): also consider omitted gutter before the footer
         // when there is a header right before it taking it.
-        for y in footer.range.start..self.grid.rows.len() {
+        for y in footer.range.clone() {
             self.layout_row_with_state(
                 y,
                 engine,

From eae79440b080c914dd730c3f0b7b27c31238a5b6 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 01:32:29 -0300
Subject: [PATCH 19/28] update multiple footer tests

---
 tests/ref/grid-footer-cell-with-x.png             | Bin 0 -> 489 bytes
 tests/ref/grid-footer-multiple.png                | Bin 0 -> 209 bytes
 .../grid-footer-not-at-last-row-two-columns.png   | Bin 0 -> 176 bytes
 tests/ref/grid-footer-not-at-last-row.png         | Bin 0 -> 176 bytes
 tests/suite/layout/grid/footers.typ               |   1 -
 5 files changed, 1 deletion(-)
 create mode 100644 tests/ref/grid-footer-cell-with-x.png
 create mode 100644 tests/ref/grid-footer-multiple.png
 create mode 100644 tests/ref/grid-footer-not-at-last-row-two-columns.png
 create mode 100644 tests/ref/grid-footer-not-at-last-row.png

diff --git a/tests/ref/grid-footer-cell-with-x.png b/tests/ref/grid-footer-cell-with-x.png
new file mode 100644
index 0000000000000000000000000000000000000000..58b636848051a380a92557794599e5f755b73a00
GIT binary patch
literal 489
zcmV<F0T%v=P)<h;3K|Lk000e1NJLTq004LZ0034900000A*l^W00057Nkl<Zc-rmS
zPbh<790zbIDIuDZ<lw-8aw4&WBBc;A8JZ-_v{ts#T3Zh0u-Xo^!*+1kYRy5k(rl$R
z$;teyQ4X3Cjnoc9cz@dMsplr|`_tR+dwA-5`t-iPp69tdd4QBWf(a&AMzBj`<I-(r
z+k#0HSkqzUQe<S?P`fCw%?ey9(rojo2_{%BaBO!)K!N?BO`yOL@5DX|+zN(06xi+Y
z+rMZ#5&V0&yQqRozJhHfwW7dgW15TNnr&_s%~%ew!+`|H^tm-UCpmngfB1yAqh{&h
z&Yhk|042f~gWHJ&yMh?-aaU~i9m0wmso~7?g#eIDrs(97A*>w<a4Ge$P1h?5Jlde*
zQaH%AmL{699N^475^T}s)|W^Y;gSHjbl&z!4i9ez;qD3QC5I<rCJwOeMflaeb%<>N
z0&F@>twK<c7)~s1_#iN%o}!bB;J<?hs+C*{TG&?CC<<(tj&mssvCYy?GbUIzupr>T
z2acsM3ak{euNbgU`HeK=G5h%y3j7g@(ms|2ygYx#rTma>YlEV|<5i7ZiW}Hg(?+i%
f2qu`|{{a60Q`nEA*oMl800000NkvXXu0mjfY8B+i

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-footer-multiple.png b/tests/ref/grid-footer-multiple.png
new file mode 100644
index 0000000000000000000000000000000000000000..34f374b29d6b5be69afe3fd219f1d2d366230384
GIT binary patch
literal 209
zcmeAS@N?(olHy`uVBq!ia0vp^6+o=P0VEg%8WVp4sTrOwjv*Ddl7HAcG$dYm6xi*q
zE4Q`cN|KSzzg=4%K5B@l`F8B;6vmA|&bGAPV@@i(`)>C;=A@5Pm(6uGcMmK3Rg{^a
zV|U%U_E<y2pQlgfEMVMNk^lKM<0-#T?l157T8^4dtY7zEmZRJMiF3xUXc?Q*s|O-v
ze%t^2z`*)-QXk`{9dGV9MAX<-pPF>h?D~qMi^ck*Y_bgV7#P+|Osl`Ji*+N&t)8xa
JF6*2UngI19TcrR1

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-footer-not-at-last-row-two-columns.png b/tests/ref/grid-footer-not-at-last-row-two-columns.png
new file mode 100644
index 0000000000000000000000000000000000000000..21ee5f93a421c23e8dda742c4eb3886bb3cac055
GIT binary patch
literal 176
zcmeAS@N?(olHy`uVBq!ia0vp^6+o=W0VEjA`wR?$RJo^%V@SoV<RA794T)DC1$MjZ
z%5AN<l4PXwZ`YQGj~XIsz8$+dg>mDLvn{Rnn3D?czT5o{NOk@`w`ewV;>U%57`?8l
zf13YSPNG}(`tH3F67v7&-?MiR^N%nU5R)&qn(`}ILFeC>XP5S0yp;(xpGl0F;ZS<S
Uu3ziVEC4yh)78&qol`;+0OMgvLI3~&

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-footer-not-at-last-row.png b/tests/ref/grid-footer-not-at-last-row.png
new file mode 100644
index 0000000000000000000000000000000000000000..21ee5f93a421c23e8dda742c4eb3886bb3cac055
GIT binary patch
literal 176
zcmeAS@N?(olHy`uVBq!ia0vp^6+o=W0VEjA`wR?$RJo^%V@SoV<RA794T)DC1$MjZ
z%5AN<l4PXwZ`YQGj~XIsz8$+dg>mDLvn{Rnn3D?czT5o{NOk@`w`ewV;>U%57`?8l
zf13YSPNG}(`tH3F67v7&-?MiR^N%nU5R)&qn(`}ILFeC>XP5S0yp;(xpGl0F;ZS<S
Uu3ziVEC4yh)78&qol`;+0OMgvLI3~&

literal 0
HcmV?d00001

diff --git a/tests/suite/layout/grid/footers.typ b/tests/suite/layout/grid/footers.typ
index f37f63ae6..286928b85 100644
--- a/tests/suite/layout/grid/footers.typ
+++ b/tests/suite/layout/grid/footers.typ
@@ -163,7 +163,6 @@
 )
 
 --- grid-footer-multiple ---
-// Error: 4:3-4:19 cannot have more than one footer
 #grid(
   [a],
   grid.footer([a]),

From 8c416b88f27633009c4453ec2cd37b03a76228c9 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 01:44:12 -0300
Subject: [PATCH 20/28] add footer level fields

---
 crates/typst-library/src/layout/grid/mod.rs     | 10 ++++++++++
 crates/typst-library/src/layout/grid/resolve.rs | 10 ++++++----
 crates/typst-library/src/model/table.rs         | 10 ++++++++++
 3 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/crates/typst-library/src/layout/grid/mod.rs b/crates/typst-library/src/layout/grid/mod.rs
index 52621c647..589799e52 100644
--- a/crates/typst-library/src/layout/grid/mod.rs
+++ b/crates/typst-library/src/layout/grid/mod.rs
@@ -496,6 +496,16 @@ pub struct GridFooter {
     #[default(true)]
     pub repeat: bool,
 
+    /// The level of the footer. Must not be zero.
+    ///
+    /// This allows repeating multiple footers at once. Footers with different
+    /// levels can repeat together, as long as they have descending levels.
+    ///
+    /// Notably, when a footer with a lower level stops repeating, all higher
+    /// or equal level headers start repeating, replacing the previous footer.
+    #[default(NonZeroU32::ONE)]
+    pub level: NonZeroU32,
+
     /// The cells and lines within the footer.
     #[variadic]
     pub children: Vec<GridItem>,
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index fc1d13564..c51db2d1e 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -54,6 +54,7 @@ pub fn grid_to_cellgrid<'a>(
         },
         GridChild::Footer(footer) => ResolvableGridChild::Footer {
             repeat: footer.repeat(styles),
+            level: footer.level(styles),
             span: footer.span(),
             items: footer.children.iter().map(resolve_item),
         },
@@ -108,6 +109,7 @@ pub fn table_to_cellgrid<'a>(
         },
         TableChild::Footer(footer) => ResolvableGridChild::Footer {
             repeat: footer.repeat(styles),
+            level: footer.level(styles),
             span: footer.span(),
             items: footer.children.iter().map(resolve_item),
         },
@@ -647,7 +649,7 @@ impl<'a> Entry<'a> {
 /// Any grid child, which can be either a header or an item.
 pub enum ResolvableGridChild<T: ResolvableCell, I> {
     Header { repeat: bool, level: NonZeroU32, span: Span, items: I },
-    Footer { repeat: bool, span: Span, items: I },
+    Footer { repeat: bool, level: NonZeroU32, span: Span, items: I },
     Item(ResolvableGridItem<T>),
 }
 
@@ -1213,7 +1215,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         let mut first_available_row = 0;
 
         let (header_footer_items, simple_item) = match child {
-            ResolvableGridChild::Header { repeat, level, span, items, .. } => {
+            ResolvableGridChild::Header { repeat, level, span, items } => {
                 row_group_data = Some(RowGroupData {
                     range: None,
                     span,
@@ -1240,13 +1242,13 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
 
                 (Some(items), None)
             }
-            ResolvableGridChild::Footer { repeat, span, items, .. } => {
+            ResolvableGridChild::Footer { repeat, level, span, items } => {
                 row_group_data = Some(RowGroupData {
                     range: None,
                     span,
                     repeat,
                     kind: RowGroupKind::Footer,
-                    repeatable_level: NonZeroU32::ONE,
+                    repeatable_level: level,
                     top_hlines_start: pending_hlines.len(),
                     top_hlines_end: None,
                 });
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index 0b905bd5f..685f78aeb 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -590,6 +590,16 @@ pub struct TableFooter {
     #[default(true)]
     pub repeat: bool,
 
+    /// The level of the footer. Must not be zero.
+    ///
+    /// This allows repeating multiple footers at once. Footers with different
+    /// levels can repeat together, as long as they have descending levels.
+    ///
+    /// Notably, when a footer with a lower level stops repeating, all higher
+    /// or equal level headers start repeating, replacing the previous footer.
+    #[default(NonZeroU32::ONE)]
+    pub level: NonZeroU32,
+
     /// The cells and lines within the footer.
     #[variadic]
     pub children: Vec<TableItem>,

From 858e620ef783e24bcbe7c78c3ef501f88d51fa78 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 01:41:29 -0300
Subject: [PATCH 21/28] fix footer layout order and consecutive footer pushing

---
 crates/typst-layout/src/grid/layouter.rs | 12 ++++++++++--
 crates/typst-layout/src/grid/repeated.rs | 10 +++++++++-
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 31e17894d..d46040910 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1600,12 +1600,20 @@ impl<'a> GridLayouter<'a> {
             //
             // Use index for iteration to avoid borrow conflict.
             //
+            // Note that repeating footers are in reverse order.
+            //
             // TODO(subfooters): "pending footers" vector for footers we're
             // about to place. Needed for widow prevention of non-repeated
             // footers.
             let mut i = 0;
-            while let Some(footer) = self.repeating_footers.get(i) {
-                self.layout_footer(footer, false, engine, self.finished.len())?;
+            while let Some(footer_index) = self.repeating_footers.len().checked_sub(1 + i)
+            {
+                self.layout_footer(
+                    self.repeating_footers[footer_index],
+                    false,
+                    engine,
+                    self.finished.len(),
+                )?;
                 i += 1;
             }
         }
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 2f9a5a947..2ebd2d9a7 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -550,9 +550,17 @@ impl<'a> GridLayouter<'a> {
             return Ok(());
         }
 
+        // Collect upcoming consecutive footers, they will start repeating with
+        // this one if compatible
+        let mut min_level = next_footer.level;
         let first_conflicting_index = other_footers
             .iter()
-            .take_while(|f| f.level > next_footer.level)
+            .take_while(|f| {
+                // TODO(subfooters): check for short-lived
+                let compatible = f.repeated && f.level > min_level;
+                min_level = f.level;
+                compatible
+            })
             .count()
             + 1;
 

From 40ae2324d1c61b32e68e12a02fa86a5e6ee8415f Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 02:28:54 -0300
Subject: [PATCH 22/28] test subfooters demo

---
 tests/ref/grid-subfooters-demo.png     | Bin 0 -> 7234 bytes
 tests/suite/layout/grid/subfooters.typ |  41 +++++++++++++++++++++++++
 2 files changed, 41 insertions(+)
 create mode 100644 tests/ref/grid-subfooters-demo.png
 create mode 100644 tests/suite/layout/grid/subfooters.typ

diff --git a/tests/ref/grid-subfooters-demo.png b/tests/ref/grid-subfooters-demo.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc64e29af496dc0032c7aa32733fa2beec95b6c5
GIT binary patch
literal 7234
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
Fe*t&HT6_Qi

literal 0
HcmV?d00001

diff --git a/tests/suite/layout/grid/subfooters.typ b/tests/suite/layout/grid/subfooters.typ
new file mode 100644
index 000000000..1e4c1a017
--- /dev/null
+++ b/tests/suite/layout/grid/subfooters.typ
@@ -0,0 +1,41 @@
+--- grid-subfooters-demo ---
+#set page(height: 15.2em)
+#table(
+  columns: 2,
+  align: center,
+  table.header(
+    table.cell(colspan: 2)[*Regional User Data*],
+  ),
+  table.header(
+    level: 2,
+    table.cell(colspan: 2)[*Germany*],
+    [*Username*], [*Joined*]
+  ),
+  [john123], [2024],
+  [rob8], [2025],
+  [joe1], [2025],
+  [joe2], [2025],
+  [martha], [2025],
+  [pear], [2025],
+  table.footer(
+    level: 2,
+    [*Mode*], [2025],
+    table.cell(colspan: 2)[*Totals*],
+  ),
+  table.header(
+    level: 2,
+    table.cell(colspan: 2)[*United States*],
+    [*Username*], [*Joined*]
+  ),
+  [cool4], [2023],
+  [roger], [2023],
+  [bigfan55], [2022],
+  table.footer(
+    level: 2,
+    [*Mode*], [2023],
+    table.cell(colspan: 2)[*Totals*],
+  ),
+  table.footer(
+    table.cell(colspan: 2)[*Data Inc.*],
+  ),
+)

From 8f434146d82c0996da40bfc835733ed3b09933a8 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 02:58:13 -0300
Subject: [PATCH 23/28] clippy lints

---
 crates/typst-layout/src/grid/repeated.rs        | 6 +++---
 crates/typst-library/src/layout/grid/resolve.rs | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 2ebd2d9a7..a93acd98d 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -244,7 +244,7 @@ impl<'a> GridLayouter<'a> {
             // Simulate the footer again; the region's 'full' might have
             // changed.
             let (footer_height, footer_heights) = self.simulate_footer_heights(
-                self.repeating_footers.iter().map(|x| *x),
+                self.repeating_footers.iter().copied(),
                 &self.regions,
                 engine,
                 disambiguator,
@@ -585,7 +585,7 @@ impl<'a> GridLayouter<'a> {
     /// footers, and skips to fitting region.
     pub fn prepare_repeating_footers(
         &mut self,
-        footers: impl Iterator<Item = &'a Footer> + ExactSizeIterator + Clone,
+        footers: impl ExactSizeIterator<Item = &'a Footer> + Clone,
         at_region_top: bool,
         engine: &mut Engine,
         disambiguator: usize,
@@ -641,7 +641,7 @@ impl<'a> GridLayouter<'a> {
 
     pub fn simulate_footer_heights(
         &self,
-        footers: impl Iterator<Item = &'a Footer> + ExactSizeIterator,
+        footers: impl ExactSizeIterator<Item = &'a Footer>,
         regions: &Regions<'_>,
         engine: &mut Engine,
         disambiguator: usize,
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index c51db2d1e..d51b55516 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -2272,6 +2272,7 @@ fn resolve_cell_position(
 ///
 /// When `skip_rows` is true, one row is skipped on each iteration, preserving
 /// the column. That is used to find a position for a fixed column cell.
+#[allow(clippy::too_many_arguments)]
 #[inline]
 fn find_next_available_position(
     headers: &[Repeatable<Header>],
@@ -2398,7 +2399,7 @@ fn skip_auto_index_through_fully_merged_rows(
 /// repeating.
 fn simulate_footer_repetition(footers: &[Repeatable<Footer>]) -> Vec<Repeatable<Footer>> {
     if footers.len() <= 1 {
-        return footers.iter().cloned().collect();
+        return footers.to_vec();
     }
 
     let mut ordered_footers = Vec::with_capacity(footers.len());

From c346fb85892c7de53fee87cc1028128aaee10380 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 03:01:48 -0300
Subject: [PATCH 24/28] initial proper subfooter unit tests

---
 ...ters-basic-non-consecutive-with-header.png | Bin 0 -> 279 bytes
 .../grid-subfooters-basic-non-consecutive.png | Bin 0 -> 258 bytes
 tests/ref/grid-subfooters-basic-replace.png   | Bin 0 -> 319 bytes
 .../ref/grid-subfooters-basic-with-header.png | Bin 0 -> 256 bytes
 tests/ref/grid-subfooters-basic.png           | Bin 0 -> 210 bytes
 tests/ref/grid-subfooters-repeat-gutter.png   | Bin 0 -> 626 bytes
 ...grid-subfooters-repeat-non-consecutive.png | Bin 0 -> 622 bytes
 ...subfooters-repeat-replace-double-widow.png | Bin 0 -> 1033 bytes
 .../grid-subfooters-repeat-replace-gutter.png | Bin 0 -> 772 bytes
 .../grid-subfooters-repeat-replace-widow.png  | Bin 0 -> 979 bytes
 tests/ref/grid-subfooters-repeat-replace.png  | Bin 0 -> 975 bytes
 .../grid-subfooters-repeat-with-header.png    | Bin 0 -> 596 bytes
 tests/ref/grid-subfooters-repeat.png          | Bin 0 -> 549 bytes
 tests/suite/layout/grid/subfooters.typ        | 141 ++++++++++++++++++
 14 files changed, 141 insertions(+)
 create mode 100644 tests/ref/grid-subfooters-basic-non-consecutive-with-header.png
 create mode 100644 tests/ref/grid-subfooters-basic-non-consecutive.png
 create mode 100644 tests/ref/grid-subfooters-basic-replace.png
 create mode 100644 tests/ref/grid-subfooters-basic-with-header.png
 create mode 100644 tests/ref/grid-subfooters-basic.png
 create mode 100644 tests/ref/grid-subfooters-repeat-gutter.png
 create mode 100644 tests/ref/grid-subfooters-repeat-non-consecutive.png
 create mode 100644 tests/ref/grid-subfooters-repeat-replace-double-widow.png
 create mode 100644 tests/ref/grid-subfooters-repeat-replace-gutter.png
 create mode 100644 tests/ref/grid-subfooters-repeat-replace-widow.png
 create mode 100644 tests/ref/grid-subfooters-repeat-replace.png
 create mode 100644 tests/ref/grid-subfooters-repeat-with-header.png
 create mode 100644 tests/ref/grid-subfooters-repeat.png

diff --git a/tests/ref/grid-subfooters-basic-non-consecutive-with-header.png b/tests/ref/grid-subfooters-basic-non-consecutive-with-header.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f2a57beb3810ea4a91f861eee59c1ddd837d9b0
GIT binary patch
literal 279
zcmeAS@N?(olHy`uVBq!ia0vp^6+mpt0VEjKpDfq|r0#jTIEGZ*O8#N*(2#iLQDC>b
zuH4p&D@jH=|8{M8_^2VG=G(EWQy4e?INQ>Ck2$IE?z`RZn3FzET{hR%+&yGfUDfyV
zd#^Jmew11}|0A>T74F0HczjNlo_hJFA!3jD=hkam8#h>(zdOFw9jK<WhQqhMyLtIK
zDT(gn|LXE`3l_v(GIS7|K3AHf`+T~8q|vQsi@J}VWwSRs_FtNz`@dv;<hN9Zrd{=~
z{xo(z?sw{EJNC$R-$&-;jZZH&dR{G73FGZKdSB*$zd`r@8~hWFa+mh?mYsq40O*yE
Z3=B%Xv#$O;$)*AFv8St_%Q~loCIASkfMNgu

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-basic-non-consecutive.png b/tests/ref/grid-subfooters-basic-non-consecutive.png
new file mode 100644
index 0000000000000000000000000000000000000000..81d0c42debabbab5533acafbfd7a2a71f6aa72d8
GIT binary patch
literal 258
zcmV+d0sa1oP)<h;3K|Lk000e1NJLTq004LZ001rs00000#@K@70002VNkl<Zc-mw5
zKR|$C)Z$T#M=c(;c+_GtES?<qJ^#o+So|+$?WTbV>PIr)2E^ijy?fIK#Nrk6-skTa
zS=s5!rGc^dT<`Q517h))mve#!#Nxfpue}Gv;?}MOdUprH;y;)ET>m?wveWF^9|v0g
z4S>bZ%>ExbKOjM!cx2ANlw9Y{cMpigvzE9IOyb&`y>wtKUaR(XU@Si2G$Z2EfLNUW
zzh~9}Sv+&zKv;Y{<VE89fw1_+;WckYyD*~`k6Jux@er^W02vWntW=lVZU6uP07*qo
IM6N<$f*Uq?<p2Nx

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-basic-replace.png b/tests/ref/grid-subfooters-basic-replace.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd73d3e9a3d0273a8cc780dc111ab22534728fd7
GIT binary patch
literal 319
zcmV-F0l@x=P)<h;3K|Lk000e1NJLTq004LZ0027(00000mBSIt00037Nkl<Zc-rmP
zKMMhI9LI4F#B4OOTMWt|10|BdV7N!16c*fM@c+oa45wsLx)O>~l$25ygNRbP!*K5B
zIT(D>eZNoORqy%?UjqZ3fnb6OCYaza;H>}2O%br>>-I6J55@-s)_5rlfjh#D8|Z6J
z@)`p#`CJ|X%jdES0!#6W0|F;gHS-<;t7~=p*43O!(bp)U0pO#BjaQJ=!D*R6;FWa<
zfs0K$gTPXxg@L;!1q07*dCwgJb1YK?!36;U&)lcr4FR7f;#FUt#HP~jLEy%buVYeg
zy_nRh<Gg{uwNN!ckNHnvEiJ?_b1Jbh1m;9gYSF1IATaC2cQhx02`2at;13t@V@-&^
R>~a7A002ovPDHLkV1iXvhdTfO

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-basic-with-header.png b/tests/ref/grid-subfooters-basic-with-header.png
new file mode 100644
index 0000000000000000000000000000000000000000..5216561464d16b3123ef947a8c3bb6017e1176c7
GIT binary patch
literal 256
zcmeAS@N?(olHy`uVBq!ia0vp^6+o=V0VEiX-Dr9Oq>g*KIEGZ*O8#N*(2#iLQDC>b
zuH4p&D@jH=|8{M8_^2VG=G(EWQy4e?INQ>Ck2$IE?z`RZfK=!2bBks(Cw^S`htcb*
z`ltDS<s`agukYR~AtC>N{ylpKG5-it0WtYvt0}*d6?Fc6d3I^PV3>98tnIZ9I(8TS
z?XPyw(Yt5l;CMIw)BmRp5r2%=E4;eJu=LfL!_3Ja*G~f47kxBnF5|`>^>_b20#X$}
z|2J~Jl8t*l_Y}KI;oLiAPyc0zr$OEOM~s=_W=GUd;ai98Kwk57^>bP0l+XkK)WLR}

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-basic.png b/tests/ref/grid-subfooters-basic.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a64680757e4120bc89ebd153bf23a5593c53c8c
GIT binary patch
literal 210
zcmeAS@N?(olHy`uVBq!ia0vp^6+o=P0VEg%8WVp4shOTGjv*Ddl7HAcG$dYm6xi*q
zE4Q`cN|KSzzg=4%K5B@l`F8B;6vmA|&bGAPV@@i(`)>C;Al3Q%+@jgci60mKVf4DH
z{%QVSIf-uB>$~?#NXY-6f6v}Q%s;|ZKuo^aYRa!<1)YCio?Y567-pS2YkRGOj@^ZS
z`>P#v^zIosINpu_^#5r?#2@4JN#`?WXTuyIVa~u{{%wZoLVd6IAjf*T`njxgN@xNA
Dt|(dA

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-gutter.png b/tests/ref/grid-subfooters-repeat-gutter.png
new file mode 100644
index 0000000000000000000000000000000000000000..35842b5827baf02ab8906128f3f17131877d0188
GIT binary patch
literal 626
zcmeAS@N?(olHy`uVBq!ia0vp^6+rxn14u9|R*Bodz`$hb>EaktaqI1^vtH7H677ZW
z7YFQmw`k!Gt&-pvFK^8$WtW>S#AZ61>xyJCC$*YndV3oDkabITxwwE$P-L<6;-(Wn
zSi88STzlmgbS`jlf2L$pUo!7ITU`NPx`pxQDVB>gnc3L(ITxrsIJc#;;>~jF;CZ(m
z&%LP4Ij2|ku+WdB#UGclyyKS*^?GpO`?Pj#rV6Vd>6P6#o<02HUVhBBw2ylm+dSUu
z$5jdv*T0;~BDeNr_PN5`4R0^bVu<r#5q@}NRppM~z1D~4SskBlEmfiU<MgBh?d;dG
zIp?gscV*6F2j}#k+Zf{f+u8o{=FMz>Ec$NAp0Dpp)-{^{t9d>3z|NZc(VRKq=d;g!
z>|gg!{W#Z;9ognnp9iyi;61Rr_?^s*_Sf(2Km4rmJQ%dxzWbZS>+pl37x~kLeoPJ)
z7uPK<_F>wu9rl*{!Q`3C_6P55s<fy%KR0aNRkjDK@9Q#h=9pRu3*ES{9QA6R_)$sD
zH%qd@cKl*s27}oRp@-#wEa6Flcp)P~!N)afD#}0z3{MbHQ%UY`Y;5E_$$<p(>OG!K
zd2{KLYPkFZ=?3vh?=-ZI9)G&X%kc5^zdQ6g9;APK-oEJn@&C$77Pr<lsB2GO?Z^6|
zDnDDp)@f-5n_lLFN8zvcvh<Z%SaSY3D)hGS*-BfL#<@q22!_iipaA~^*ZV`<+`Vs4
QTM9}{p00i_>zopr0F4F_RR910

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-non-consecutive.png b/tests/ref/grid-subfooters-repeat-non-consecutive.png
new file mode 100644
index 0000000000000000000000000000000000000000..02f572f31d7260f1b049cd1f9e51e53ebda0d008
GIT binary patch
literal 622
zcmV-!0+IcRP)<h;3K|Lk000e1NJLTq004LZ005x~00000DLy3W0006tNkl<Zc-rmS
z&r8#B9LI70hfdKgBIpvSpa<!Y1O*=Iu)u>My9gE~R+m~7QJ~qvjFcMA96AfKQj#qj
zgUHz&QU*CX*!)RiZ6=xN*A2h#{(>$YdJ?`q|G)!2Z@zr_@O~B<bczHE7A#osU%;(i
zCw9&S;MHO`I*VNO`4>S$;ORXn2DX#Nz}e>vobcqc83OJqDa3sQY!%t=0s@D8J%+%W
zJC_;QZW;ow-%T^Hzs7le!v)~QGJ7+D%-EagGz6X~k1?<vF$Q+R44kQ6XW;7xoWWWb
zfZfuyzBOdVt?dsDfq(3nXJGRg14l<0xTD5N23-K2tg!J2a@EJv&`%<MY=D8SG|#|W
z0Yl)qx*P*H9d%yTy8!GI7Y4o}GrsZ|dYCWn`pCd`${2V$!oY(k@}Cm~JXGe6wh^#Z
zE(Bc!?yrAj1U&U&_fG`AeddlK@T>9}296zUZ*vKFtj-#T5xBv6ZXxhlYxqRK=}Y$_
z+iV$9m}B6{mX>Y=Ude?#2>kZymnsCl))6k5Ctzn}BjsqfC|Iyy!GDISqZtbpELgBY
zGKFLc$rO?)BvVMHkW3-j{}GY}dZCakemcy+Pxt;};IYd4)vM4J#vg#-2VDf5^elN-
z2zY6vKexSJ5<|g_P?CT%hrTs$5wMN#-!ue%(%6f@eHWJZMfEWM7x4GaiwOiy&%Ucg
z;Dx4VRS0}}`2Ar7p7E!er}Q}q7A#n>V8Ma~3l=O`uwW4W4I)TLjy@5(rvLx|07*qo
IM6N<$f+Z^#E&u=k

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-replace-double-widow.png b/tests/ref/grid-subfooters-repeat-replace-double-widow.png
new file mode 100644
index 0000000000000000000000000000000000000000..86d92a83201b0679d6283dad34f8d479611d567f
GIT binary patch
literal 1033
zcmeAS@N?(olHy`uVBq!ia0vp^6$}iF&Ky7n!<C~`uP`t$U+{Es45_&F_ExmFNTST~
zkN2Fz14{%2pSXqv#fo?chP-KwTcR-|Y2wqyD|b|;yg78{>y%lU3)Z!VnR^~pe%F<`
zEICYQTIGQv+Z?r7FRM<;@>~Cpb2NAS*YWqP^bdpc#)pm18{dy*+Epf~<}<_K;r@ot
zO>-}DF<ooQk~VbCy}zBWaqF6I(gHhH9TCheUA_F*?%e7cImYW1IW0X(37X&Mi*fw<
zcZZ$hk6GQdWC_N8{}qSJwpY#ddT$*p%CcwC?+_i1h<)$M6CWH}&ab%P=7Sw656!Rp
z9k6VlW5>lbP2_Kb!-K%{njAK>bH2wp9*~{uy*2;NtCe|XR;Q~4H@tnr-^|VEeSacv
z<AJLiMFnoGiMKf8n&kdqj`z9MGhCH6J(%k7U?sD+K*i+?@A(_E<1K=s@4hbG6dfzD
zWBUp<W~TgJ(VtEacICA5F{!sqlaX^h5PAJ*qh(iz*uew4{>1PywR`4hXRPp*6!<aC
zrC;H}!j_V|?iZ8<uktpUR`alw9Vw}BN^oBMLh-}gB7rp(+vn`>Y)D;HU(_2daj1n;
z_@8mlE{o$phT544J&KafMr|oPCnY8ssw8_Ho6vJV28q+nf+mYl4i0!{qjQFdKr{c_
z7nH5IRTj;BK>N7KX_b@}k7xBTH6G{Rclbb&tHFmFS++2}{BySj3Qm4p`^|+#XZiEf
z+Y|~a7kMgtI5v-!M<<i1@wz;J;)62^TR%6lHKhA_h1;j}Ig17yyjH)8m-#g7!2?;U
zY};7ZBtLkvILo<%t-*A?sqr%bQ|tX93Lie@S+h-ZIe1{298ZkEl5bL`3^o-}zoHbJ
z-&(Uosobi4Ww@atHz^@}Au!lC%$KnEx+shHI>UyloYi%FM#nuv7xex-bML%Fgc1vL
z|Mr9jZ2Qj|vND>_zfx5sxM9xkv?~e)zCVf^58P%CGu-fmgC)*q)`0^r8MA)J@)jPC
zyY!9K=y>4T1+Ga~oDUv&q%KjhQ;PX^(=vk(NlUJZGuf}27Rs?kU##&!t@;|#*BlYg
zX8DykB~09r$MI*^6=^2zOd+PmuVMjmnI2O+rgKzS8mK;!`#(cC&EuFQC}}66L=GhQ
z|7)p4A3d=Dk?%nPi~T{%6bsgPvM`m;lic8tAZet(>$+dkg^YFW2bRrTlP(b9#>C2$
z|N0r5V!_R=O~x~PXYXLzWnl1Pev9_zE5c0EL%euc`qnb@mZqLKbyS@r;?$=#Ve^W?
hkqe4gVXzw%{zwP46<n;;c&iM`<DRa5F6*2UngCx`#GC*C

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-replace-gutter.png b/tests/ref/grid-subfooters-repeat-replace-gutter.png
new file mode 100644
index 0000000000000000000000000000000000000000..2ca221533c8ea53a9bac241667ac3484f7f884fd
GIT binary patch
literal 772
zcmV+f1N;1mP)<h;3K|Lk000e1NJLTq004LZ008m`00000qa<Fi0008ZNkl<Zc-rmU
zUrSSQ9LI5=Lsvm`)s<J3kc4+aM67=o77MDe%7TPO1w{<YSY-c9F{RwxA6>0RGpA7t
zY!tTCl91LkDmHa3Tg*H(Y@X$IzCDEq&OSIkzbEj5@8NsS@8Zp=5YVY0OqeiX!v6u^
zI=EzsAYg5O-ymkx$u&6$thI!XLEr~2#qx~nL|6~_TfC6SAmBh{-t-9pOV8evK;XBv
z?;!BlnRMk80!~b;Q%UYIVLf2?g{9^Q0?r!VcVkBVWo;1y+izcnz`iTWwh-5eus(1e
z15e*P`v?N3GW|vf96kTR0D&9*gPRoutoYNx4ELC@9&n#S9d&8|I94O$Pa&h;JqfyV
zg?9xpuvGoQz(u=2;Mt?|82HIU!NC3#Ab8Azg12;@%tPP?x#$Ot+S3k!>kCIx2sq*B
zit!>qSRZ&HtU%zI<Fk7pux$V|YHJ$^j#szcg}@?d?lIxAfKi9fm@r|&gjW>YYF39%
zX#hC8K?}`5Mt%CRQy_3+-5U%n2LuCW`Y~|)P=POy(!gKi#Y`LlyEZO|tq53ZGM;4!
z+++0$1kSJiiGk&+K;T^aBnJNeoL8R`!H!1t<s}UO&ux<73CO6;k#2#&6V*c)ShflV
zR_|fpxG{%;MdO>RM6hkWI$+WOuvWF`TZD|dwbLyS_}8i=1{SMe;LvLfoahh?e69fm
zkHB(_`ukA~ynSIu6qIB1HiO`%7YKNyuHzcN$ArrZ)~>snAh6dV!w}dK0F64Z^Y=Ie
zmZ0r3*NHG;!h{JEW=O_oOqeiX!VJk6k})J>NXC$iAsIt5hGY!M7?Lq0V@OsuA(`DP
z7&wgkEr$kzYwsAdpeo{q9Rzo|5b$VS+N>bp^sB%;F9L*hfn!cz5CVJWT6!U{eB37x
zxM27ZgTS7{ZWGsuFheqiWDLo;PJ{^)CQO*{Kb*fZXo{3lcyE{h0000<MNUMnLSTX_
Cd0sI9

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-replace-widow.png b/tests/ref/grid-subfooters-repeat-replace-widow.png
new file mode 100644
index 0000000000000000000000000000000000000000..35633b0a4f828e6759be8b5f4e7d28c3710adeb7
GIT binary patch
literal 979
zcmeAS@N?(olHy`uVBq!ia0vp^6$}iF&Ky7n!<C~`uP`t$&+>F}45_&F_ExmFNTI~>
z!u!tQfg&C*m4Pc$#N%3=mPBMsc+{F&l{jl+h+5N<j%jJ^rv3`+W-obWY1-e(UgQ((
z@+oB6>XoYVt_$zp{Q8~E-ln`=AKKsK-#gGgGrcYS!T(aB3r}5U7$hEQ`OkcAXJ%iZ
zzy`6P+Z~lxKD+x0L{#6blx7MSkxsrP^J?wC<PB%nC_Ru8_kJP5G;Pv?`%I1Od)pO1
zINX_ZT7_xe%uw~`vagCSsn5JD!m{V>_pKfR8~)g&9Y4^@>aSQ(x$ENgssCesGp5fq
z`K`?nG4Dtp7t1^=Yxc(JLC^H_lpm~{clOqKzOP~CFVCp{<+$-+>!dvQ14bpslmvGC
zs?$vKJhE>7vq?ARt3J%;JFe6D;!j@Vf#P$s1#Zl;6Jlx1Ufq-V7O1&j>)O6dmOF3L
z`Xb#9T&l=)Rw%f>HIL&?N&eFvO%3H`Z;r*b|C)1U)s^=G6$LpqLQMHjU;kAo_;j3A
zp2OzP4#lKX2mkF9GyLFI63xI;7piM5V6lzE<nhAKxupUT)2h$dM637!1M8=G&n}DP
zLoJ-bX&%QW^e9R?8?~kIoRpYksFLh)tX>a^qk0fS9wq?Pu6AZZkFgri$cN3$>1``z
z`Ar!1yj`{RUz5$NcKH&f#&o}$g9nP74L-c8=2;W7eVvp*!N%Kh=}b&w=dYSq3+zyN
zxYi-z^utmfo%1YAv*Y{|9*8Su`LAMY5Vw7DnIq*`BG-xp>75rE8=r1UNZ885EZyWQ
zVexd%ErC^x31@4!%M@RlHgmZ+$DYy*IcD#sga_B`c;?72`u5s{!RDQ&v+e|USp&u>
zp}GIQN<`dQD{&)EL!d%0iI;i#&lS0WQVe0S-(MM?^i68@Q~2;`q9Kn?IScdoEeQ|W
z9A0l}YM5=aWnT`9&OL4`UZ(3Vdxbf2itimfFo~5bKq%d?z-_}V$@PlwZp2#EIi%HW
zm))YWEJlQ5&RlT~fgS3rq?oVIi#mLOIc{lPwt$6OQISJIo+Q(|@3Or2T@OgN#dSB&
z)h&BjtyoaMNyYJj`&p)2$2pT)4lIlQsB2@W4iD77t<sl^CMy)ow@u+;@^;<j@L;L-
zH!hAlbJo_sOPD|T?QC8qeRsZ?)&r8INsR{zSr<t5?+OodO1LSzvCvu&6feMh0gNRK
chF!#m_(_(F6dPuqcLU{CPgg&ebxsLQ0K5vUiU0rr

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-replace.png b/tests/ref/grid-subfooters-repeat-replace.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d7803b8516af57beb0f5f078c2c69c8bdf4d917
GIT binary patch
literal 975
zcmV;=12FuFP)<h;3K|Lk000e1NJLTq004LZ008m`00000qa<Fi000A)Nkl<Zc-rmU
zSxZ!57zc2_LswB0NJM#2sbqu~p%E!wXprKCWlC6PB$kyRDyHR9xnvrd<0PrMjXGv7
zi3@pLQe<dcXv!ING*L$#b!6tucAh>#5JCQf^Soc+$9Wf?m-GI4JP0&A7-pDZh8g|~
zxa6uWQ9!^_l&TFg)y9KX2rNDCy#ayiD$R*qvf9-@^)7=60XKQsqjd<Fsv?#M0*?hw
zK;Y2_D_%1Q*f1x~7-e;wlo_@h0RiuXe67Ij>K}*P7`Xh^69`<JYYy(@JJ(*oMMrI+
z0s^MT$y$QIx|0hKcqPktZU+JP4Q#1~Wwoo@6}GAo1gsBO%XK4Q8b4tt2;7)djVThz
z8^^gw>`jpfw#8zKL_%3VLEr_?EePz$)kHvGRf9RFTUNVTD>#N`5pchcEpZhAQ`?12
zg1~*3Fz2}a&e~xC0b49?^RBFplh}~`4FZo%PThpS+hxiS2%Pz8F$e-rq^aX{GP`pv
zW8lq%t}qB(&`1^toLm7~<MGp7%@CMY2W<Sd$S}hUGfcmSQG?f*VTKuIn1f^-B;z0%
z2gx`{#z8U;l5voXgJl2foy(4a=L#M+L*OM-OC$u=rcZ`I;I#U-vt|Tru3u?2$?7<%
z-iRX#2>?&|(|8ADs>7y1)u}hM6$6v60|UFu2?8&~tz+PvAh9c60>GlTvlSD$Nv~57
z1YSNciGk@BVPHcC23ChVW(5S??k5cuBVY<#R7eoGDgHe{V3(%_15*(wfRa9kf%7B9
z-V_P(#lF<@9kRx^yFo=l=OsYk;?i(}zytA(7+7^|9RrUBREMlX;6y4Z0l_b85b#K_
zHg*>QZ|Vo_GJ9L>Qw~Dlkxa^f!1q5As2-=183J3crF8I%Il~+z<27cOVTKvrTevVr
z?71re;2m$Na~?9)_dX~H0vnEe!N7EdFtDiw0}GcOCOrbK^l|p4B4F}2y>&w1s?>J`
zf$jS@Ffip21h&4I#=y^_#DQ!H05AK|XANYHV+2q}Ky#)C1Jgyqz+w#s)<;?~aMmeN
z9W4Q1$#=IF)3TwkR7ntcd!G>lQz~KL&LIq37R5m_4w7+@jDutxB>O`+I}H>h6Jk0r
zu*zGr1<D8vpPvUk)mJ<P!TD+gJQPr$<U+ur%OtbEx7~TKb0Bb^^ZGahrnYo~z#G9%
xH3V+SS3V-{NX8w>xFZ>NBx9Iih8h0%;}>EMPW8W(JCy(c002ovPDHLkV1hJ%pk@F7

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-with-header.png b/tests/ref/grid-subfooters-repeat-with-header.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2a80ff333d72ad86551a2287ee0a052769fa20d
GIT binary patch
literal 596
zcmV-a0;~OrP)<h;3K|Lk000e1NJLTq004LZ005x~00000DLy3W0006TNkl<Zc-rmS
zOG~0*7{>9w$?S$%%rJ}D1;gM>Q^YhaDoTQgNNEvdC#p?hv?we}$|yV7$%xm4j*AXR
zV5LEHlA;5I1<{$xq9_#azCnu?&qa7WU*Lzgw>-SQ|2P4iIKqSp6DIr)_;J|01%cQ0
zb_@{s+B)zL0@utRCPCoxq}kGa1nf0|wtB^M8pgo7vBY!CCzg&D5NvfJ;Q4s3@fiVE
z8Uj%Pjao2pdb<k)=Scn{Xw=RI5L~g2fU6U1PC>w)BG@Gn1;M{N_4lCVYU%>Pb_W9X
zr=92BBH*Gl_q8BkAMBDajs!4p%FX`(XsZY7L9lrN0XP4&Sp)%VxJv>B|7|aMfxv}Q
ztAR${-wJ_^5yJ@rE=#d*3j$ukJ(zFYVPKu_&k<;=dm2HoWdZ>&>$H*x0)CEM#oFJ-
z1CAjGJZ+Ue2wXe~8nxXhK?oc*B^N+o$(DTx9QqX!2<-Vbhk>7T5@WFc^92Up_8;=y
zB4NUW3BLuS4!>i<gb5R7NXC$iAsIt5hGY!M7?Lq0V@Sr3j3F6AGKORf$v${U=F6~I
z_+YLCjy5{X5O}Ctyb##r294UC`nU>#WxVbnwzm2#aOsuJpn7=b`&e$V=SNsM97+&p
zo9K_#!-?W-6@5@StbH2I%DnvAs~mnP->te0-`y*RB^mT{n)>2m`Jx8Ci3h=2zK<_M
i2ookum@r|&D$XlXMI)TETbEq`0000<MNUMnLSTYC4F-|`

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat.png b/tests/ref/grid-subfooters-repeat.png
new file mode 100644
index 0000000000000000000000000000000000000000..e8b431fd31d822595baed06e9f7e1fdacf06bf6f
GIT binary patch
literal 549
zcmV+=0^0qFP)<h;3K|Lk000e1NJLTq004LZ005x~00000DLy3W0005(Nkl<Zc-rmS
zT`PlO7zc1)$B8osPNl?ygac<%I3QczSx8<Y=B>P&<t1fVBf^$M$ZN=0vse>Lo6VlG
ziDldE6F70;AJ6~(0>7^N?&|L9`o{^-i6cyyFk!+!fZyg@E+O#Qjjad*`v+zu2;98s
zOohPLt(HoMvf3$R#lYviqhk;_<kjUs;H@^F1c5ucrxTnAIAV?1ql#*$=&IHYfe%hD
zR1o-MMxOzJJ2#%wAn<mLAy;9aga~6`S6`h80=s=n`4HIJd?i8PCc{dSjDTf>XW6H$
zb~?}nA@J_To(5C#=2RvG9$5&aL*Rwd*+d5i^WT62x`urSY`Z@zfWVKPCJ6#JTFz4-
zuuFT~b*rp)dN4;J@ZqGf2LgZIO=d&jrG8n0z?wpRyaNIE77H0t@sU~x3@i-~#vpKs
zsIY*pdaefotAyH)fNh$gb)_vso-lBr%$yB@`xZqI0$1xmZ+x0)HbG$F-FfG3kuYJx
zgvIwT>hO&T6DCZUK{5u(7$jqmj6pI6$rvPKknC>+$*Lq!kZenZ+QO(~AUJs}{}ofQ
z&`yBhaXkV)%<~k=2-ve{^eb$HvCi5c@MUeJ90E72fv&o}LxdslOIE#+gE?Wsgb5QS
nOqeiX!h{JECQO*{zkt60YD`rFfv73o00000NkvXXu0mjf%ewPI

literal 0
HcmV?d00001

diff --git a/tests/suite/layout/grid/subfooters.typ b/tests/suite/layout/grid/subfooters.typ
index 1e4c1a017..dbd9ced4a 100644
--- a/tests/suite/layout/grid/subfooters.typ
+++ b/tests/suite/layout/grid/subfooters.typ
@@ -22,6 +22,7 @@
     [*Mode*], [2025],
     table.cell(colspan: 2)[*Totals*],
   ),
+  // TODO: Why does it overflow here?
   table.header(
     level: 2,
     table.cell(colspan: 2)[*United States*],
@@ -39,3 +40,143 @@
     table.cell(colspan: 2)[*Data Inc.*],
   ),
 )
+
+--- grid-subfooters-basic ---
+#grid(
+  [a],
+  grid.footer(level: 2, [b]),
+  grid.footer([c]),
+)
+
+--- grid-subfooters-basic-non-consecutive ---
+#grid(
+  [x],
+  grid.footer(level: 2, [a]),
+  [y],
+  grid.footer([b]),
+)
+
+--- grid-subfooters-basic-replace ---
+#grid(
+  [x],
+  grid.footer(level: 2, [a]),
+  [y],
+  grid.footer(level: 2, [b]),
+  [z],
+  grid.footer([c]),
+)
+
+--- grid-subfooters-basic-with-header ---
+#grid(
+  grid.header([a]),
+  [b],
+  grid.footer(level: 2, [c]),
+  grid.footer([d]),
+)
+
+--- grid-subfooters-basic-non-consecutive-with-header ---
+#grid(
+  grid.header([a]),
+  [x],
+  grid.footer(level: 2, [b]),
+  [y],
+  grid.footer([f])
+)
+
+--- grid-subfooters-repeat ---
+#set page(height: 8em)
+#grid(
+  ..([a],) * 10,
+  grid.footer(level: 2, [b]),
+  grid.footer([c]),
+)
+
+--- grid-subfooters-repeat-non-consecutive ---
+#set page(height: 8em)
+#grid(
+  ..([y],) * 10,
+  grid.footer(level: 2, [b]),
+  [x],
+  grid.footer([a]),
+)
+
+--- grid-subfooters-repeat-with-header ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  ..([b],) * 10,
+  grid.footer(level: 2, [c]),
+  [m],
+  grid.footer([f])
+)
+
+--- grid-subfooters-repeat-gutter ---
+// Gutter above the footer is also repeated
+#set page(height: 8em)
+#grid(
+  inset: (top: 0.5pt),
+  stroke: (top: 1pt),
+  gutter: (1pt,) * 9 + (6pt, 1pt),
+  ..([a],) * 10,
+  grid.footer(level: 2, [b]),
+  grid.footer([c]),
+)
+
+--- grid-subfooters-repeat-replace ---
+#set page(height: 8em)
+#grid(
+  ..([x],) * 10,
+  grid.footer(level: 2, [a]),
+  ..([y],) * 10,
+  grid.footer(level: 2, [b]),
+  [z],
+  grid.footer([c]),
+)
+
+--- grid-subfooters-repeat-replace-multiple-levels ---
+// TODO: This is overflowing
+#set page(height: 8em)
+#grid(
+  ..([x],) * 6,
+  grid.footer(level: 2, [a]),
+  ..([y],) * 10,
+  grid.footer(level: 3, [b]),
+  grid.footer(level: 2, [c]),
+  [z],
+  grid.footer([d]),
+)
+
+--- grid-subfooters-repeat-replace-gutter ---
+#set page(height: 8em)
+#grid(
+  gutter: 3pt,
+  ..([x],) * 3,
+  grid.footer(level: 2, [a]),
+  ..([y],) * 8,
+  grid.footer(level: 2, [b]),
+  [z],
+  grid.footer([c]),
+)
+
+--- grid-subfooters-repeat-replace-widow ---
+#set page(height: 8em)
+#grid(
+  ..([x],) * 14,
+  grid.footer(level: 2, [a]),
+  ..([y],) * 8,
+  grid.footer(level: 2, [b]),
+  [z],
+  grid.footer([c]),
+)
+
+--- grid-subfooters-repeat-replace-double-widow ---
+#set page(height: 8em)
+#grid(
+  ..([x],) * 12,
+  grid.footer(level: 3, [a]),
+  grid.footer(level: 2, [b]),
+  ..([y],) * 11,
+  grid.footer(level: 2, [c]),
+  [z],
+  grid.footer([d]),
+)

From a2f559317495b6df20875e38c1c37f9aa02c4115 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 03:34:53 -0300
Subject: [PATCH 25/28] improve check to pull next repeating footer

---
 crates/typst-layout/src/grid/repeated.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index a93acd98d..1a8733102 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -518,10 +518,9 @@ impl<'a> GridLayouter<'a> {
             || self
                 .upcoming_sorted_footers
                 .first()
-                .is_none_or(|f| f.level >= footer.level)
+                .is_some_and(|f| f.level >= footer.level)
         {
             self.prepare_next_repeating_footers(false, engine)?;
-            return Ok(());
         }
 
         Ok(())

From f3cc3bdae77793e73d4a72bab55ed3331b23e2a1 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Fri, 13 Jun 2025 03:45:42 -0300
Subject: [PATCH 26/28] fix space calculation of new footers

however, there are widows...
---
 crates/typst-layout/src/grid/layouter.rs      |  12 ------------
 crates/typst-layout/src/grid/repeated.rs      |   9 +++++++++
 tests/ref/grid-subfooters-demo.png            | Bin 7234 -> 6989 bytes
 ...subfooters-repeat-replace-double-widow.png | Bin 1033 -> 973 bytes
 .../grid-subfooters-repeat-replace-gutter.png | Bin 772 -> 721 bytes
 ...footers-repeat-replace-multiple-levels.png | Bin 0 -> 910 bytes
 .../grid-subfooters-repeat-replace-widow.png  | Bin 979 -> 970 bytes
 tests/ref/grid-subfooters-repeat-replace.png  | Bin 975 -> 963 bytes
 8 files changed, 9 insertions(+), 12 deletions(-)
 create mode 100644 tests/ref/grid-subfooters-repeat-replace-multiple-levels.png

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index d46040910..fd846b6e9 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -298,11 +298,6 @@ impl<'a> GridLayouter<'a> {
 
         self.prepare_next_repeating_footers(true, engine)?;
 
-        // Ensure rows in the first region will be aware of the possible
-        // presence of the footer.
-        self.regions.size.y -= self.current.footer_height;
-        self.current.initial_after_repeats = self.regions.size.y;
-
         let mut y = 0;
         let mut consecutive_header_count = 0;
         while y < self.grid.rows.len() {
@@ -1785,13 +1780,6 @@ impl<'a> GridLayouter<'a> {
                 )?;
             }
 
-            // Ensure rows don't try to overrun the footer.
-            // Note that header layout will only subtract this again if it has
-            // to skip regions to fit headers, so there is no risk of
-            // subtracting this twice.
-            self.regions.size.y -= self.current.footer_height;
-            self.current.initial_after_repeats = self.regions.size.y;
-
             if !self.repeating_headers.is_empty() || !self.pending_headers.is_empty() {
                 // Add headers to the new region.
                 self.layout_active_headers(engine)?;
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 1a8733102..86506df79 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -632,9 +632,18 @@ impl<'a> GridLayouter<'a> {
                 .simulate_footer_heights(footers, &self.regions, engine, disambiguator)?;
         }
 
+        // Ensure rows don't try to overrun the new footers.
+        // Note that header layout will only subtract this again if it has
+        // to skip regions to fit headers, so there is no risk of
+        // subtracting this twice.
+        self.regions.size.y -= expected_footer_height;
         self.current.footer_height += expected_footer_height;
         self.current.repeating_footer_heights.extend(expected_footer_heights);
 
+        if at_region_top {
+            self.current.initial_after_repeats = self.regions.size.y;
+        }
+
         Ok(())
     }
 
diff --git a/tests/ref/grid-subfooters-demo.png b/tests/ref/grid-subfooters-demo.png
index dc64e29af496dc0032c7aa32733fa2beec95b6c5..f4a3f1731bcf06c28664bf24e155716a7f734c2e 100644
GIT binary patch
delta 4433
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
aKgl!M$a!^F*xP^oI?+(QgDg?D3j7b^vK%r1

delta 4680
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
AMgRZ+

diff --git a/tests/ref/grid-subfooters-repeat-replace-double-widow.png b/tests/ref/grid-subfooters-repeat-replace-double-widow.png
index 86d92a83201b0679d6283dad34f8d479611d567f..37ecbca3440b915a6a7e6e3e14a65ad7cd485b21 100644
GIT binary patch
delta 932
zcmeC=ILkgkrGAR1i(^Q|t+%&sdrb+HIQH?~!o?a^6F9yom>yK%ci}wMvc=$~gD|u1
zZOdhznG#Eur7jB7dS~ptRK)z|iVo=#AMd0sQm#d5b5<Uiwaid7{drA(_=Qe(yAw9|
zdH*D={rYho>;G7$UuA-7J~Ip+>K^bvcRSdWBce0={V|=bmG{}|S;D&5^_?DEtBTH=
zA3pb${4d{TR>ti=Erp*6ZZJ7kC(iLl@sBdgyfZQ1X1g9>Tbz9DP3ZpM!?D$kY>eyO
z&Rt3J`+EJa98XMar96|l_${TX%ICNEc6?c2>($(#YX5k$!-L9tVV1aartRyL9xR+V
z^;>yd>8k2iZ+e9}BILiVzEI!Xkosyuu)>GeTf}E5PE7pzbi$2!ih_yz8zhCowc1#j
zX4ix%Y*-y2&E0rA{wCM2y|2rSzE>)IaPf^6WGU0X;^O?EPbgZ2<($`=?{nP`9Q8~R
zX0e&6)zqkb`m_kg9G%R+3zp_-H66IFTFS@xdXt=+Uvt}$tA-qFW`qjdSSIz!yZu1x
z-ARm%`DRTCzAJv+P-W3^d;7?0zCjD8u-cz`iLZtIK!(o@MM-C)wiKR|5|a#7l0A-1
z=uwn>AA`hoZc>z-{FYI?o&%!#`wWA`LoMZeF_T_M>{!U~;HtyYa=}ekUgp1IVUp(C
zbNqmizQm17jg6*;dfjr2*X7Ij)07i9H`)|CKREVAt?|G)+b|v-eio*Dn`?;=+zb0A
z+ORU{vz}fdw&{4MRKUSywnhz&Pj@6F9QWo~W52zzv6xvVmXnJitiI{m?CXlvF+ukf
z1b)2FGiIBXbMV04#}Ye~&KU+SXLz8mXtcCVr*sRSi3;0dE5i*eI}J80k5bs6`O}<D
z&*I?=??8qP$`|hb6y9{)a_xflpO@~Pmx$2gW;0u1Sa3b^dJ`MtcNXo(sT>i9_FvT$
z*rB`BRpG<3^HOZnf*KFh7xhTg-zZzZkCW;96fb6$u+naa2dh*Jof4Khl+J>MAW8s9
zB7ze&d~=SsrL<X}FBPazEB-9SvhQyg3)Azb-NH=K{&%w;AFhdhFm2DG5)PZSbAZOL
zT*DO0lC(sKiT}E<9j^rY+^nk-EZe>vcTNbt6(qrOF3_8e<=na{UjkWd%D4PcSteMp
nc1@ubI7<K{2^hb7THnjBI#Td;Lt)cN1|aZs^>bP0l+XkKMfa6V

delta 1011
zcmX@h-pMgRrT&7ai(^Q|t+%(Ly+smbj(@!893EIADEP!REGSmQLonn`Yuplz8A%hL
zHeR`-GUd&oGhe67%3QFnJ<QzmsPen6%w@@8LenY_6xrse&3ajNN|xXHf1IPa<G+r-
zXQh7_oHssfeBSteEYq$sK{cNl1`qc)d~TY1k&EeCQ<k)$bMF26?R<?}*L;%}*s<z}
zU~cK^<-d04R@cZeUa!b$=}}71{61fd<Ilf4>>Pj0>aHbAF!uYeI9#^9YOdFN>tIoq
zJ&S&a=x{{rdsm+L;Lvh@#SJ$f>_~ZNe%<eYW&0dEE~aTBe;XVg1fJLAu$i6nJ<jof
z>|F1y`FCEe%rmn(T`job?VEc3W^P9B`xAK^4_w_SDsW>>yu}&UB=-k%yw9zk;i|Oh
z!BmF_E1A6oDlT7m&)=9GZxIxI_jT!}=vaXr+gGSDGv)V+{&ae<E2o{0Nxfy7jGXI%
z$m>TNExS6z4j$O`Cx(})-7`l!V}-Azz>jGz{R$5jwv^m;zn~;|mABEfnun#V{zyrM
zQ-bs27m6R|7747W*gj`}XG7|u`l8-wi9;=%!vBnWc3B(;GStpY=uwn(Hfl@ZIVmy8
zP$k*p*o2<@F-V+l7BpFea&Xu?8=W&u1e*EZzMyQyt+Ht51KP(;>QAertav=DhpF*6
z|GvWqid+po)X1`h>E)lhEl_as<Jxa7EIP}dpWdcWP`Suc;lr_ctUNlIOpVv&`4b<U
zQP}#qk*y)!&nw(MrO#P3;NZ3TRlLlnSq~n_Qf1r5x+eL-lf_xi9c&Gz>rIWH37A^%
z4^jB=DbJd1n#;ih)8u$!1eVl)lQLznsfhX&rQrP5nk7o*R_!ap4Hdab3E>NYA-`e1
zgvHlIS-jU7HdN)TuH!R0?isqE_ve{==OrSPSeW~_Cp=)=f7Xzd(R}`usv^M+bAG2?
zQ7G{JQQUaoHhY-ih9?{>aXzyS9C*o?^*ffg@Oa#%Z>&bg1J^EaO}gTI@W3PWdWnji
zQp~rTmKl6VT5?sK$$r(eP>wbFVvPrC)z^r==7@MU%df;KVd9QFjz7DuNHb|?3NbZ)
z6$_Bd^qAT)ouk6iK=qN_{~5w*9>**}2|N)cejqXMUrQzW=z;x@d=Cm(><?O|Sg^*E
zg{gd=<OYWX$s8m7UDy4RE@Z50Kd@}(nsk8(Hzro5{MXOe6bo){Z8DzWJ9`JyE(3!X
z^INnxUlC@S9^%Er(zlkGw>0&{siW!~5vM+_37c08j$lya3WFV?@JBkRt>9v%##?0u
OAn<hcb6Mw<&;$Tfo5S<~

diff --git a/tests/ref/grid-subfooters-repeat-replace-gutter.png b/tests/ref/grid-subfooters-repeat-replace-gutter.png
index 2ca221533c8ea53a9bac241667ac3484f7f884fd..61bdabeb6f301158767f5e0f4afcbe5023eacecc 100644
GIT binary patch
literal 721
zcmeAS@N?(olHy`uVBq!ia0vp^6$}iF&Ky7n!<C~`uP`t$&G2+_45_&F_SQk~%ZW0_
z3;(zKIhMS7vQnt)#Whu@w;~S@3N>rIFwih?@;R8XY)S~XV)kj3+X*XmlNvo0gTn+D
zd%7J>(^-AAU+Uy6>DzVp|FviQ4%s)q{sHU#_V<U2E6iuSFkxT@g8ytaUq8%JU)FH<
zTeaZX6~?o<gl_D$sP<uE|7&?(`5NaAu@B2bRNrbmC`exUcrDYmjm_F>jq~4EYBoNO
zy?IQPbxxd~Uh0kH2T=za@0sTNFs?V-ziXl7*WYJDd24E)>|vQFapG<FCcgt)8@;6}
zeqMU%$+_o|&sNU|Pi`Jf<Gdr>_2!i3gBT6#w`<myYIQ#_R(JW(<j!)u|DJEwgK6*A
zdUC$mcsow;&UY6^eVGrup9C5H?N2B_abLahxO=W2Q}v-mf$iV_*C;mT?)oqLnuP}h
z)-;5+TeAVdzvT}eo_lo0Gn`?4Uh!gimBn^nA1w2H@MT)M)D6CwY-P(#3SN1%vM;gw
za6IIyr)I+cZ=Z6uGi|$jZtW%(xz}>$oH4h4_%h#SoqV8Gd%fw0>BnnoU$OLm6PZ7+
znDxVRS+nUAdUhGBY26UAPB+=`)|5A9&*H}5Tvpy3J^k>x5B{w^`dfA#L)q+4!j&gi
zw6ACNVfue#!o>sEa-}S+);C_Zb25U!gai<MjZ*>yW=!Y-yIoC183%m)R0&0fnGK{i
zd2T}^2ymX<k(`i_@L)erUq$U+p^AOC_GvWgS|kWr+z#UPdeA<d*?Em{LGFW7v%6US
zRoUFrYGhYmtJ1jJ&82)!4p*znhNr@!-@q=xLj35T6F*Jw;dzxgj|D+#)zj6_Wt~$(
F69DgOGM)ec

delta 762
zcmV<W0tNli1%w8W7JmTp2mk;80HY*cumAu8%Sl8*RCwC$++RymaU92SpF>wcbk&tt
zm5_vYLPV^87ZwYuvC4vkMg>I-%UERpOfjY0+#g-7Ml+{T3v3j&)RK_aG%7ZAEnCby
zG;E&bcD_A@2+lq@KEEgMg74vb&hO&QsSwbqAWWDrVZ#3b-+wx|WQibPZGYb&X4J_w
zIS8z^gpWbs2QJ0(jO#>L5BOWWkjNn5KxN+a2?0yb-jqP#x3%ve@YtDj<rD%=Osi8#
z?lECKVE2Wk<_H4L8s2wfM*U@N5d+(AUxvWGE6TPI*NLz`a2^9s-#q&W0;e+lMhF}|
z|G@x(8~uZu6@LV*_|w4*_n5FAaGygRb!q@ORwLt2A*0?s3A%HIcLg!9RQ<ugMY}-Y
z*`xCq_{l@T!2S~;c+7%=w{)J&L*NFv=m(A3(++{_3rA82IN|7u@ghK2A9x|GK;W6<
zvwI-0Z2&ZCYa0lTSGV1Tz#?hxG2ya+QHRf%Fk!-kSAP`TYF39%X#hC8K?}`5Mt%CR
zQy_3+-5U%n2LuCW`Y~|)P=POy(!gKi#Y`LlyEZO|tq53ZGM;4!+++0$1kSJiiGk&+
zK;T^aBnJNeoL8R`!H!1t<s}UO&ux<73CO6;k#2#&6V*c)ShflVR_|fpxG{%;MdO>R
zM6hkWI)7l&0I*iI=v#!0y0z0S5ct=sBnB3%VBpYe44mi?41BHu1dqUSjQaag47`0|
zM--G}^frUwrWXi!q^{!{zsH2j3)Zf?njo;(A;S>Z5&(@lu=Dpg1eT!fGuMeQVZww7
z6J|)pXH1wdVZsc_7?Lq0V@Sr3j3F6AGKORf$#WQzF(hM1RyHA--76S4jQcHz27+tv
z7_*=%;)WdrcexPoXkFT@AmH??z&tMkgmr;qPG1lLd*@nuA+UVhClI(`_z{D^p2Kbv
s*NHGgGKORf$+%902@@tvnD9TGzcOfwlu~$am;e9(07*qoM6N<$g2roK&;S4c

diff --git a/tests/ref/grid-subfooters-repeat-replace-multiple-levels.png b/tests/ref/grid-subfooters-repeat-replace-multiple-levels.png
new file mode 100644
index 0000000000000000000000000000000000000000..6247969a0c037631110f9d932a05bf770d861f7e
GIT binary patch
literal 910
zcmV;919AL`P)<h;3K|Lk000e1NJLTq004LZ008m`00000qa<Fi000A3Nkl<Zc-rmU
zZA+6;7zc2_L$9KUhzRmUW=6d*5G^RN(m*uA5`&&J*etU`DnWD06&sdDPPf*|thSsc
zYKRZ%?OaK%ECs9iaARUko5|YlJ>6Gt`UJk%AK7)jzz?o-9nLxT{pZ9HXv8thFvAQp
zyaM>{3BN)>z;d3o4O41yy$=G*cY4l1;AVqI(G^o&{lgWWbR%F(d?0@U0h1|bmLTxE
zwD%C$Q92(#j({hpq;WB(mXq;@UnL;m<%~}an6Cb|A%cPH?^i+KCbcKMlh0hyfOT8^
znF0c)n<b+JfhQ7XAn<&Jn6iw3d;6EH_L%DG_C~*H7y-Ldf2kt~m`1h*2m-$-ehh(|
zN*1^BCJ_}_m+n7_*(8eU`UnEgY+8cALA5gn0$ZPZRIg)eIf-2n2t2H}XdrOtyFLp7
zw`e^X5LjEP-{?TVwBSv916occgAmwk+zEkg^;8Ifi`zk^uDwjhYzR1XrAk-BXD)^r
zW|(1y8D=;NFlz7|Gt4l<46iC!TOf5`kOA;=qTD$RDfPuyjRb)wH^0Tebeu4-y9EOa
z*+I7p0ULINddd(mCA%MnAh4;-Ob|G*b`b;9ErP(lnlTJ~J5TDblmYPEE*fw`=D0ur
zCD@$1yD>2BCk!k-!N9JgJ`7y3U24sj0kE9pZSq3qSX*l(2>fS_h=Hk$FmUG(2CmDK
zh8tx7{3V%2Iv}Oa8Ut+-J()HPOi4iu9H}P=Jac*h1FH^5UFT!~EG33)KOu8`y%}^d
zpIi4C0#{xu1l^AdIxw&`(YXYH9jW%c(-2re4H^(!-HL#RQlAxv5wH|?$J%FOlfevu
z+jV4wz{)mIsUMu8DF`g9lt(^-y88Se1eQf51okL<6Ckj<4HS>OWCFoLO2@vl2$-gv
z(_a3!$S}hUGt5CUZZ3uyW|(0Pl5voXgJc{e;~*Ia$v8;HK{5`KagdCIWdFw^C`fj-
z2oxl<XANQCmwTR$LSV<i--kvau!0_`KyY~<q`9*1RrAF>DzL0EltW;%o(3SW!U8I_
z<?!DT2u!w$ud&tDvx5Bt1g`7Xs334;J|hBwDR*KH0-JMf>23rZ@QC~(8NW!zFOu<@
ki(!TtW|(1y8D7cw2MmH&+l`WNIsgCw07*qoM6N<$g8F8Nu>b%7

literal 0
HcmV?d00001

diff --git a/tests/ref/grid-subfooters-repeat-replace-widow.png b/tests/ref/grid-subfooters-repeat-replace-widow.png
index 35633b0a4f828e6759be8b5f4e7d28c3710adeb7..090ebca36f18005191d64da6bc3d5ed7cbaeee99 100644
GIT binary patch
delta 948
zcmcc2eu{m9O8rDn7srr_TW@bgdWR&+9RGOFIXqCrgQYTX<q~nRg#lV|83C7CHQ6H7
zEN47&-6jwvm6^4)$-*yb){ZA#+IlAnJq1s%J)%4PNNq{lEX#8i&+lu$SjJs{^v^lz
z9|u0y^PMlYxbMtV#V4rdGsEEF{)YQ*H%hpet{qza+R%G%#Tl;p#;s@itOa)LIk6(U
zaAoY@;<EZYX2$TH?_K>A6Eyjv#W-wU*z+{9PYS!MF8JZj9;=-%g4R!dxKh{G@xZbN
z>sx2U+ScCbY~=nF@9<z#NpgVk`xth{^!b}wH8>*XsrPZQ%(L3f&=?*prax1lApN^v
z>3r|EuiW;o-679-{@2>&*7brLc;?;|=7^E}&&V`gHE-@S#X^OGvI%d+o=xaD`&x)&
z&x38ujc;EnCkpJ?b!f)5S3$e0LN<Osr|>|}e|8=(qxavZxs3<rhVND=NWSxnla+Dy
zS--_cm&U1YRr+epA}1rgpS!XAGtWVRACb3%6j<cyV#IBqCY7%f<=G>9TZpT%K0drl
zl1W{xDb1#2-&0|hX<PH8|LY0?Lu<nyNjKX$hKYw-IE_`3J&sN2QIvExYD?icDKW`V
z<?-BZ1oz{F1ax`02B3D~G>>DF!ayTG{AW&gUHO*ZgdykCg<16u)2tTOJL(HmynB+)
zqhrp>oPQ-D;pwc}WHCnZN-L{Lf*XG1?J0M7@aTz9<AG}TZ3Y|mh;Zc88aFl?AG-Q3
zgqLA`h4*=mlw*NhD-xtXW*$Evq#zNYd-T9&^EDC{Pv=C5uVhR(dpans@r;G`bp?Tn
z?;n)drllM_aCWbRg?`N2>)8wyck092W+`~fS}|IwSUF`GZm76vxM8z{!Uv}>YHWVo
zA<;=D3~Q<^vJ6k2om{ln;lb3!$r2IoIN9c9A39Ka{jD(<Q{I<rRmB1ue(1k6<%kje
z94PSNi@3Ql%eg)Cbp>{uO_yWd9)ITSMS%|vTaIjZN|-xkPt$?IMZen`)aCYN3$>-x
zLxNKom^u^NQV_viW>Db9rlIn>bKSuMSKoQ_ao9WvFHRL@daYv5&5|Cj@WAf>yxUq#
zX1RS?>q<Q|X12v}+)40#(Qx3Bu)4qvp@g?h2cGuxaIPzRe(U&w{gb?u6bkZI>Nr36
zA#|Z<w|<YAbHYrG+t1W_bV2b8iW>uD#(&Qr=8TRrvhV&d@nrx4Pgg&ebxsLQ0E~^F
Ak^lez

delta 957
zcmX@bewlrOO8qQP7srr_TW@bgdy5oG951}@93Cj*;Zhm6GDSSD#c4@I#)L<$sa1)y
zCWfdrE$Nt+#%}7bux|E}XO^b@o$N(E!7iUdrmbG7I`6vh?#-{?+3an~+x4OSP5!+D
z?K9Kc(jWXU6}s@$WrjiGp_c#5=XPfH1qy5s3%cD=dF8XauRuh7_039Yrf?DI<XbYY
z*8WT0aCVK-11WLu7a~m4CM~$n)X2WKUGam%ok^!vnC8t4Revt~s`!%n%*!Gyd)|KE
z>LIY<k4@U~1Ffw7iUpOsE^eRtKjt@M`dpLW+8hz{j`VS{%(Jp)Z=4?VOg~Tg!Mb^8
zZ=L7+8fO0TjOt&G8xOWl%5$$jU{rEUNnppXI?XiCBkSfrn{;Eo>cecl<2s!${^T_t
zC_Xn^;KnRFA(qDM)jgSSfx7#(uI<ZYx$`!yFVgM6rHV{vg@Wr_^EmF5<Uiff)KFgb
z=2&d|uQ^v%U3o81QIKOJ#FYQ^^<Ra8Psds1Ic)yyP)s^?@ZU}`!w+sH(F`ng^`W}f
z0v6jiOdc=%oLedoF|GQHO|*&+FuZ=6_w2GrKGeb~oaS+CLXV=Pvr$_L&q;|%hAPP(
z$LjTvII0IR<Y59p?P_Nx^cbrFjeOY5oZhxlmfwV7&)Zd7|25gXYL~AsVQNhGt2ua}
z$l2h-t7@J#G27Qk2^4I+9hc6;BzFF)d9}a}m4|B`5>7uX<<U9M!ZbV1KjDG6VwV3Z
zwgz$ACzm-=jwN!fNRZxnp|SDlri6s8Jj~Kfz7iHs=iCxl#h7rmcDqdRrD-#li*xKL
z&5&dEZc2D?&5mb|{GxBKO&Dz6)oVKIPH>ksV2l!)`|qnn#GSPgH{vt|D)f?gnV0`u
zksBz*5ElFWmElR>q*gzL5054q^5~SaFrVL&@Sx4%^_HfF**07D<*?}7<F?{uy6&=9
zm?Nk7-oXQtSh)g((hUpTHr$e2ulVjptW}*uTFrLZEh@`mL^$Tm71t2hp}tCr`Fj1l
zsKW=C<CfNC3s|@n6*&~-Nix0rF3Wr0^?-C+TzB(a-LjX}iUswXR2(0;pJlproHMEA
zz_RF%x;BRD@NoUxDt)<VvO>Xp+Y}xqZ`WN850+|w<Knn8XKnqvg!z--&gNy(cjt>~
zJs??{)Oetfb%A96uJACYgqyM(%?hmrL2(1j9>AEwVAw@`h@WJ+NU>q&c{c_i@O1Ta
JS?83{1OVastMUK<

diff --git a/tests/ref/grid-subfooters-repeat-replace.png b/tests/ref/grid-subfooters-repeat-replace.png
index 0d7803b8516af57beb0f5f078c2c69c8bdf4d917..95025f8b3be24b0eaa2478d2c7c9b8f0121a388e 100644
GIT binary patch
literal 963
zcmeAS@N?(olHy`uVBq!ia0vp^6$}iF&Ky7n!<C~`uP`t$cX_%vhE&{odn?j=N}$Z~
zkN2Fz14TSoDg#$8X>n0;>1t(Djf+SUU*^d-O+rO$;nLK+r%cZ>l4ky%w)2rwPi9xd
zy3T05POFzIj4jUh7@yxCe!*A#-<qGc`45<%*YiC;@Yz;j!Fz_pLoJ-b|G0l#)!ppY
z-f(rnE4DL1`Z6~g4`f9hm*t2F%eb(`;>x;zmdUfPDnHOl_x_;5H0@D?YU6>wam@ld
z^wW-3$}pZkr}>zhuXIkA(3z7~EPLMmUdym~_42-3h6Q!^f;nPlC4I<zHalDY!5QH+
zds(Jw>K6|)HLClccYZMSNGtbkjvbq;H~-q~{PvaG+MPSZ8PCVWcyClrkhDk@<cN{{
zD#kS3ZT<WwsvFe{mi7NMdp4=##9JW_oA+Bd8`o+&GYah3b!ft!R{^`LBGTW^bUP5c
zF72!q)3i2kX{JW&^@-;Slb_r&lw~rLddoK1Syp|i(o1WWck+_F%?F})y6zMBQFwci
zIg4D+YW}$;8_cg8vEA#)_}G5n<<z8>0~c8rNb=9gUD<eG)2-ZR`&~gHHO>C;ihg4?
zpBV;;Z7Dn_B_<iFBzqj2(4#2nY}A(W`|H`%g9nOV@@Ff2n6%GKfQkQj{|~1JJ3h4)
zv$5o8#IL+;eWh?!-P$i%p$s;!G?{%TEd3_WeAiF5u2dr8&Kiju^YjHO?7oPz`F#tE
zIuy#VX2+XriIZmkFk0*I;OSvyiHLVxZ1Zvt9r$X#=CT#bofqrAr6?wRjJmQ)V29S9
zy$TOjuJ?1}m{X=7tWYrfxC~pK{rt&Gl^*O1=*((8Af@TqdSK$BnGOe%`!~&QfjF4w
zB!@82Gm4VwARit2&3uj{@Yeg)3>CLsbN?|$zG9c(!qk}FUw`mGQLw>=ePYb7*F}Fd
z=Gbwebi1+`WB2lZXZ2Y0`g8?3axAy>H9no`@L=xrWQiZH6E4kN!t@}u{HF=a%)$=7
zD;zwPTapuY>PSRXwl}6Tl^Ya1l3Z#R!FpiT?3Gu5O5FS=Iy_k0%q<a-#L8^`J>kI}
z1uVgf65jP$LSUCW8-Y`B|AV$CZ&*0)B=bu(9tfJIBvA3RYcCH|{TVH<(hZMOW^ZtO
zaCO7J)dD{%dm|JIeB?5Y9nO3DR3O5~+3cPlFk-<`3Ni_u@n83c`6kO{-kN{U@`G}x
Mr>mdKI;Vst0Ah-)ng9R*

delta 967
zcmV;&133J{2hRtP7JmTp2mk;80HY*cumAu9mPtfGRCwC$+*wOhVHgK+ze8716i7sQ
zQK@8v7oia;UTBcwg=I=uW+axCAS$NiQn_Rrnd2m>xs5tzE{O|yTvB9cTxiM}bu>{&
z9d%^p%yynWK@dUygY&#!;Kz9vo|p6fc{~U-JQ!w}VTKw03xBxesx47Kz*3Z|4Kvlo
zgH{MEJ@35%f$J*GiCwbV)j#zvg9!mQdD)|N2$-rOmIwlm1x`TV(FZGDGYHr)C(amU
zb)1wLwj2Qg?}U7<!0hTDhuj#r{M8c(T$^hS?&LeyUcg01ZJ`1JrpL)zg21|y3lMlE
z%Xn@F0rw4TseguLwX53|wyF^XtPfbrbt7OJKVc^b+?Z62DH6#W$GJ%CO_2z;#bSy?
zLRmjS;04bu2<*t!L_lCwgE^;LR=Zj&IEH2saKDc&aTNhm+l5Vnz<rl6=eYgO+F=0!
zTP$w#uB?ue*pU4V0*_5j-Gso~Wy%l;ocU=n2m()}sej{iGP`pvW8lq%t}qB(&`1^t
zoLm7~<MGp7%@CMY2W<Sd$S}hUGfcmSQG?f*VTKuIn1f^-B;z0%2gx`{#z8U;l5voX
zgJl2foy(4a=L#M+L*OM-OC$u=rcZ`I;I#U-vt|Tru3u?2$?7<%-iRX#2>?&|(|8AD
zs>7y1)qklsv=sxBuLA?S%LxK6#I0lCoFK6)UIM_Px3d)!xk;~65CmR6Fo}Wb7GYpR
z2L@J$J7xt0-0mk06(e8@TvSL9xGDZUL134s1p`wND1eeahk^4W#oiPN@x{K>^BuCr
zx4S__Lgytw;NsG7g1`gujTl&UY#jrS22_WvLx12zDk%ZMFKZC+NU%0`7XfeT2kkO@
zTkKN~Lg0~1%7DQ4KN6@Or;-^0Td$>b@QXRa93<m4W|(1y8QxpCFh=aTD*@mgZ>e)0
zGS&A!C<p=@j(owubcHamsRaWImmMZO0<QFN_NF3W@;AM8Lg1>@cLag$`!_H!<q-t7
zzJHj;z|W$@four?FZ<DF4P=dD1W-mmbEXFa(?!C-Vhsk?M_Ms()+tdPEdgN3cefVP
zvZ1h4Nf3B@pAiF7Dq-NxAq-p=#X&L-l5voXgJc{e`$IT84HP63VmdIe%3HGq$_Naf
zp9ekFS3Cv5`Dz3_6i}b!LcpTSB(uM_-9UM-b0Bb^^ZGahrnYo~z#G9%H3V+SS3V-{
pNX8w>xFZ>NBx9Iih8h0%;}>EMPW8W(JCy(c002ovPDHLkV1gm1qYwZ9


From 315612b1f7be637c0c1a6a123f8802e09bee332a Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 14 Jun 2025 19:31:27 -0300
Subject: [PATCH 27/28] detect short lived headers and footers at the table
 edges

even if headers and footers are interleaved
---
 .../typst-library/src/layout/grid/resolve.rs  | 83 +++++++++----------
 1 file changed, 40 insertions(+), 43 deletions(-)

diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index d51b55516..1fe7ae277 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -1042,9 +1042,11 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         let mut headers: Vec<Repeatable<Header>> = vec![];
         let mut footers: Vec<Repeatable<Footer>> = vec![];
 
-        // If true, there has been at least one cell besides headers and
-        // footers. When false, footers at the end are forced to not repeat.
-        let mut at_least_one_cell = false;
+        // The first and last rows containing a cell outside a row group, that
+        // is, outside a header or footer. Headers after the last such row and
+        // footers before the first such row have no "children" cells and thus
+        // are not repeated.
+        let mut first_last_cell_rows = None;
 
         // We can't just use the cell's index in the 'cells' vector to
         // determine its automatic position, since cells could have arbitrary
@@ -1094,7 +1096,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 &mut next_header,
                 &mut next_footer,
                 &mut resolved_cells,
-                &mut at_least_one_cell,
+                &mut first_last_cell_rows,
                 child,
             )?;
         }
@@ -1115,7 +1117,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
             &mut headers,
             &mut footers,
             row_amount,
-            at_least_one_cell,
+            first_last_cell_rows,
         )?;
 
         Ok(CellGrid::new_internal(
@@ -1149,7 +1151,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         next_header: &mut usize,
         next_footer: &mut usize,
         resolved_cells: &mut Vec<Option<Entry<'x>>>,
-        at_least_one_cell: &mut bool,
+        first_last_cell_rows: &mut Option<(usize, usize)>,
         child: ResolvableGridChild<T, I>,
     ) -> SourceResult<()>
     where
@@ -1260,13 +1262,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
 
                 (Some(items), None)
             }
-            ResolvableGridChild::Item(item) => {
-                if matches!(item, ResolvableGridItem::Cell(_)) {
-                    *at_least_one_cell = true;
-                }
-
-                (None, Some(item))
-            }
+            ResolvableGridChild::Item(item) => (None, Some(item)),
         };
 
         let items = header_footer_items.into_iter().flatten().chain(simple_item);
@@ -1448,6 +1444,13 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                     // no longer appear at the top.
                     *top_hlines_end = Some(pending_hlines.len());
                 }
+            } else {
+                // This is a cell outside a row group.
+                *first_last_cell_rows = Some(
+                    first_last_cell_rows
+                        .map(|(first, last)| (first.min(y), last.max(y)))
+                        .unwrap_or((y, y)),
+                );
             }
 
             // Let's resolve the cell so it can determine its own fields
@@ -1788,42 +1791,41 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
     ///    an adjacent gutter row to be repeated alongside that header or
     ///    footer, if there is gutter;
     /// 3. Wrap headers and footers in the correct [`Repeatable`] variant.
-    #[allow(clippy::type_complexity)]
     fn finalize_headers_and_footers(
         &self,
         has_gutter: bool,
         headers: &mut [Repeatable<Header>],
         footers: &mut [Repeatable<Footer>],
         row_amount: usize,
-        at_least_one_cell: bool,
+        first_last_cell_rows: Option<(usize, usize)>,
     ) -> SourceResult<()> {
         // Mark consecutive headers right before the end of the table, or the
-        // final footer, as short lived, given that there are no normal rows
-        // after them, so repeating them is pointless.
+        // footers at the end, as short lived, given that there are no normal
+        // rows after them, so repeating them is pointless.
         //
-        // TODO(subfooters): take the last footer if it is at the end and
-        // backtrack through consecutive footers until the first one in the
-        // sequence is found. If there is no footer at the end, there are no
-        // haeders to turn short-lived.
-        //
-        // TODO: interleaved headers and footers?
-        let mut first_end_footer = row_amount;
-        for end_footer in footers.iter().rev() {
-            if end_footer.range.end != first_end_footer {
-                break;
+        // Same for consecutive footers right after the start of the table or
+        // any initial headers.
+        if let Some((first_cell_row, last_cell_row)) = first_last_cell_rows {
+            for header in
+                headers.iter_mut().rev().take_while(|h| h.range.start > last_cell_row)
+            {
+                header.short_lived = true;
             }
 
-            first_end_footer = end_footer.range.start;
-        }
-
-        let mut consecutive_header_start = first_end_footer;
-        for header_at_the_end in headers.iter_mut().rev().take_while(move |h| {
-            let at_the_end = h.range.end == consecutive_header_start;
-
-            consecutive_header_start = h.range.start;
-            at_the_end
-        }) {
-            header_at_the_end.short_lived = true;
+            for footer in footers.iter_mut().take_while(|f| f.range.end <= first_cell_row)
+            {
+                // TODO(subfooters): short lived
+                footer.repeated = false;
+            }
+        } else {
+            // No cells outside headers or footers, so nobody repeats!
+            for header in &mut *headers {
+                header.short_lived = true;
+            }
+            for footer in &mut *footers {
+                // TODO(subfooters): short lived
+                footer.repeated = false;
+            }
         }
 
         // Repeat the gutter below a header (hence why we don't
@@ -1891,11 +1893,6 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                 // It also keeps us within the total amount of rows, so we
                 // don't need to '.min()' later.
                 footer.range.end = (2 * footer.range.end).saturating_sub(1);
-
-                if !at_least_one_cell {
-                    // TODO: short-lived (and remove this?)
-                    footer.repeated = false;
-                }
             }
         }
 

From d13617ed9b9dd95376b8d068b85513cba8b1b702 Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Sat, 21 Jun 2025 23:36:31 -0300
Subject: [PATCH 28/28] skip layout of redundant gutter at the top of footer

---
 crates/typst-layout/src/grid/layouter.rs     |   2 +-
 crates/typst-layout/src/grid/repeated.rs     |  20 ++++++++++++++++---
 tests/ref/grid-footer-gutter-short-lived.png | Bin 0 -> 321 bytes
 tests/suite/layout/grid/footers.typ          |  14 +++++++++++++
 4 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 tests/ref/grid-footer-gutter-short-lived.png

diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index fd846b6e9..8e810e32b 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -232,7 +232,7 @@ pub(super) enum Row {
 
 impl Row {
     /// Returns the `y` index of this row.
-    fn index(&self) -> usize {
+    pub(super) fn index(&self) -> usize {
         match self {
             Self::Frame(_, y, _) => *y,
             Self::Fr(_, y, _) => *y,
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 86506df79..6a76cb71a 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -679,9 +679,23 @@ impl<'a> GridLayouter<'a> {
         let footer_len = footer.range.end - footer.range.start;
         self.unbreakable_rows_left += footer_len;
 
-        // TODO(subfooters): also consider omitted gutter before the footer
-        // when there is a header right before it taking it.
-        for y in footer.range.clone() {
+        let footer_start = if self.grid.is_gutter_track(footer.range.start)
+            && self
+                .current
+                .lrows
+                .last()
+                .is_none_or(|r| self.grid.is_gutter_track(r.index()))
+        {
+            // Skip gutter at the top of footer if there's already a gutter
+            // from a repeated header right before it in the current region.
+            // Normally, that shouldn't happen as it indicates we have a widow,
+            // but we can't fully prevent widows anyway.
+            footer.range.start + 1
+        } else {
+            footer.range.start
+        };
+
+        for y in footer_start..footer.range.end {
             self.layout_row_with_state(
                 y,
                 engine,
diff --git a/tests/ref/grid-footer-gutter-short-lived.png b/tests/ref/grid-footer-gutter-short-lived.png
new file mode 100644
index 0000000000000000000000000000000000000000..2eb74a8615bcd06de1de819fadd855cb4622a9a4
GIT binary patch
literal 321
zcmV-H0lxl;P)<h;3K|Lk000e1NJLTq004LZ003?X00000$$*H600039Nkl<Zc-rmQ
z%?bfg7>98e>n@aRCL)m{Wv_fhW@e!VXY#or8&aaAB<yEtbZp$gc`?s_WBFUm%yD{R
zq0nN$z`%b5pB$y<9!<keLFtt`reUStKNBxX@W#E%zz4f70~efhl%8=f+t<stO~aSr
zLT_|74euL$z2?p|?3NdL)vmzHwU#<S5>l`=7|Xz!(2{}6Y8t7N%d+({Ez|IAw$htl
zxn%+a{~9bco-r^mF!6=>LVO{<5MM;%3n!NW_~8#^;9~HUftQsn@rC#T3=B+s;pGAb
zCcY3~h%dw!;tTP`w}s+MkP`Zi{iF<>3x&SpnimfzUR3@TKNkV+T)@D<Uk<+jMJWU>
TiOG=>00000NkvXXu0mjf{<w>4

literal 0
HcmV?d00001

diff --git a/tests/suite/layout/grid/footers.typ b/tests/suite/layout/grid/footers.typ
index 286928b85..b79841219 100644
--- a/tests/suite/layout/grid/footers.typ
+++ b/tests/suite/layout/grid/footers.typ
@@ -41,6 +41,20 @@
   )
 )
 
+--- grid-footer-gutter-short-lived ---
+// Gutter, no repetition, short-lived
+#set page(height: 6em)
+#set text(6pt)
+#set table(inset: 2pt, stroke: 0.5pt)
+#table(
+  gutter: 2pt,
+  align: center + horizon,
+  table.header([a]),
+  table.footer([b]),
+  table.footer([c]),
+  [d],
+)
+
 --- grid-cell-override-in-header-and-footer ---
 #table(
   table.header(table.cell(stroke: red)[Hello]),