From 4365e18454af4f8f53fe1198182cb5dc8f3d628e Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 26 Aug 2024 19:17:58 +0200
Subject: [PATCH] Improve realization and page layout (#4840)

---
 crates/typst-utils/src/lib.rs                 |  35 +
 crates/typst/src/eval/rules.rs                |   4 +-
 crates/typst/src/foundations/content.rs       |   2 +-
 crates/typst/src/foundations/styles.rs        | 289 +++++-
 crates/typst/src/introspection/counter.rs     |   2 +-
 .../typst/src/introspection/introspector.rs   |  13 +-
 crates/typst/src/introspection/mod.rs         |  74 +-
 crates/typst/src/introspection/tag.rs         | 111 +++
 crates/typst/src/layout/flow.rs               | 833 ++++++++++++------
 crates/typst/src/layout/inline/collect.rs     |   2 +-
 crates/typst/src/layout/inline/mod.rs         |   3 +-
 crates/typst/src/layout/page.rs               | 148 +++-
 crates/typst/src/layout/place.rs              |   2 +-
 crates/typst/src/math/ctx.rs                  |   3 +-
 crates/typst/src/math/fragment.rs             |   9 +
 crates/typst/src/math/mod.rs                  |  29 +-
 crates/typst/src/model/par.rs                 |   4 +-
 crates/typst/src/realize/arenas.rs            |   9 +-
 crates/typst/src/realize/behaviour.rs         | 182 +---
 crates/typst/src/realize/mod.rs               | 698 +++++++--------
 crates/typst/src/realize/process.rs           |  28 +-
 tests/ref/counter-page-between-pages.png      | Bin 0 -> 299 bytes
 .../counter-page-footer-before-set-page.png   | Bin 0 -> 535 bytes
 tests/ref/counter-page-footer-only-update.png | Bin 0 -> 205 bytes
 .../counter-page-header-before-set-page.png   | Bin 0 -> 551 bytes
 tests/ref/counter-page-header-only-update.png | Bin 0 -> 131 bytes
 tests/ref/issue-1833-locate-place.png         | Bin 0 -> 136 bytes
 .../ref/issue-1886-locate-after-metadata.png  | Bin 0 -> 830 bytes
 tests/ref/issue-2326-context-set-page.png     | Bin 0 -> 676 bytes
 tests/ref/issue-2841-pagebreak-to-weak.png    | Bin 0 -> 391 bytes
 .../ref/issue-4029-locate-after-pagebreak.png | Bin 0 -> 698 bytes
 ...ue-4029-locate-after-par-and-pagebreak.png | Bin 0 -> 785 bytes
 tests/ref/issue-4029-locate-after-spacing.png | Bin 0 -> 706 bytes
 tests/ref/issue-4363-set-page-after-tag.png   | Bin 0 -> 278 bytes
 tests/ref/list-item-styling.png               | Bin 0 -> 1459 bytes
 tests/ref/list-items-context.png              | Bin 0 -> 382 bytes
 tests/ref/locate-between-pages.png            | Bin 0 -> 231 bytes
 tests/ref/page-marginal-style-context.png     | Bin 0 -> 348 bytes
 tests/ref/page-marginal-style-empty.png       | Bin 0 -> 152 bytes
 tests/ref/page-marginal-style-page-call.png   | Bin 0 -> 300 bytes
 ...ginal-style-shared-initial-interaction.png | Bin 0 -> 504 bytes
 ...arginal-style-show-rule-with-page-call.png | Bin 0 -> 1514 bytes
 ...arginal-style-show-rule-with-pagebreak.png | Bin 0 -> 716 bytes
 ...marginal-style-show-rule-with-set-page.png | Bin 0 -> 727 bytes
 tests/ref/page-marginal-style-show-rule.png   | Bin 0 -> 716 bytes
 ...ginal-style-text-call-around-page-call.png | Bin 0 -> 529 bytes
 ...ginal-style-text-call-around-pagebreak.png | Bin 0 -> 510 bytes
 ...rginal-style-text-call-around-set-page.png | Bin 0 -> 531 bytes
 .../page-marginal-style-text-call-code.png    | Bin 0 -> 473 bytes
 tests/ref/page-marginal-style-text-call.png   | Bin 0 -> 473 bytes
 .../page-marginal-style-text-set-first.png    | Bin 0 -> 457 bytes
 tests/ref/page-marginal-style-text-set.png    | Bin 0 -> 457 bytes
 tests/suite/introspection/counter.typ         |  40 +
 tests/suite/introspection/locate.typ          |  90 ++
 tests/suite/layout/page.typ                   | 111 +++
 tests/suite/layout/pagebreak.typ              |   9 +
 tests/suite/model/list.typ                    |  10 +
 57 files changed, 1710 insertions(+), 1030 deletions(-)
 create mode 100644 crates/typst/src/introspection/tag.rs
 create mode 100644 tests/ref/counter-page-between-pages.png
 create mode 100644 tests/ref/counter-page-footer-before-set-page.png
 create mode 100644 tests/ref/counter-page-footer-only-update.png
 create mode 100644 tests/ref/counter-page-header-before-set-page.png
 create mode 100644 tests/ref/counter-page-header-only-update.png
 create mode 100644 tests/ref/issue-1833-locate-place.png
 create mode 100644 tests/ref/issue-1886-locate-after-metadata.png
 create mode 100644 tests/ref/issue-2326-context-set-page.png
 create mode 100644 tests/ref/issue-2841-pagebreak-to-weak.png
 create mode 100644 tests/ref/issue-4029-locate-after-pagebreak.png
 create mode 100644 tests/ref/issue-4029-locate-after-par-and-pagebreak.png
 create mode 100644 tests/ref/issue-4029-locate-after-spacing.png
 create mode 100644 tests/ref/issue-4363-set-page-after-tag.png
 create mode 100644 tests/ref/list-item-styling.png
 create mode 100644 tests/ref/list-items-context.png
 create mode 100644 tests/ref/locate-between-pages.png
 create mode 100644 tests/ref/page-marginal-style-context.png
 create mode 100644 tests/ref/page-marginal-style-empty.png
 create mode 100644 tests/ref/page-marginal-style-page-call.png
 create mode 100644 tests/ref/page-marginal-style-shared-initial-interaction.png
 create mode 100644 tests/ref/page-marginal-style-show-rule-with-page-call.png
 create mode 100644 tests/ref/page-marginal-style-show-rule-with-pagebreak.png
 create mode 100644 tests/ref/page-marginal-style-show-rule-with-set-page.png
 create mode 100644 tests/ref/page-marginal-style-show-rule.png
 create mode 100644 tests/ref/page-marginal-style-text-call-around-page-call.png
 create mode 100644 tests/ref/page-marginal-style-text-call-around-pagebreak.png
 create mode 100644 tests/ref/page-marginal-style-text-call-around-set-page.png
 create mode 100644 tests/ref/page-marginal-style-text-call-code.png
 create mode 100644 tests/ref/page-marginal-style-text-call.png
 create mode 100644 tests/ref/page-marginal-style-text-set-first.png
 create mode 100644 tests/ref/page-marginal-style-text-set.png

diff --git a/crates/typst-utils/src/lib.rs b/crates/typst-utils/src/lib.rs
index 831b2374c..79d4bb09b 100644
--- a/crates/typst-utils/src/lib.rs
+++ b/crates/typst-utils/src/lib.rs
@@ -106,6 +106,18 @@ impl<T> OptionExt<T> for Option<T> {
 
 /// Extra methods for [`[T]`](slice).
 pub trait SliceExt<T> {
+    /// Returns a slice with all matching elements from the start of the slice
+    /// removed.
+    fn trim_start_matches<F>(&self, f: F) -> &[T]
+    where
+        F: FnMut(&T) -> bool;
+
+    /// Returns a slice with all matching elements from the end of the slice
+    /// removed.
+    fn trim_end_matches<F>(&self, f: F) -> &[T]
+    where
+        F: FnMut(&T) -> bool;
+
     /// Split a slice into consecutive runs with the same key and yield for
     /// each such run the key and the slice of elements with that key.
     fn group_by_key<K, F>(&self, f: F) -> GroupByKey<'_, T, F>
@@ -115,6 +127,29 @@ pub trait SliceExt<T> {
 }
 
 impl<T> SliceExt<T> for [T] {
+    fn trim_start_matches<F>(&self, mut f: F) -> &[T]
+    where
+        F: FnMut(&T) -> bool,
+    {
+        let len = self.len();
+        let mut i = 0;
+        while i < len && f(&self[i]) {
+            i += 1;
+        }
+        &self[i..]
+    }
+
+    fn trim_end_matches<F>(&self, mut f: F) -> &[T]
+    where
+        F: FnMut(&T) -> bool,
+    {
+        let mut i = self.len();
+        while i > 0 && f(&self[i - 1]) {
+            i -= 1;
+        }
+        &self[..i]
+    }
+
     fn group_by_key<K, F>(&self, f: F) -> GroupByKey<'_, T, F> {
         GroupByKey { slice: self, f }
     }
diff --git a/crates/typst/src/eval/rules.rs b/crates/typst/src/eval/rules.rs
index f5d7da178..61fee84a1 100644
--- a/crates/typst/src/eval/rules.rs
+++ b/crates/typst/src/eval/rules.rs
@@ -24,7 +24,7 @@ impl Eval for ast::SetRule<'_> {
             })
             .at(target.span())?;
         let args = self.args().eval(vm)?.spanned(self.span());
-        Ok(target.set(&mut vm.engine, args)?.spanned(self.span()))
+        Ok(target.set(&mut vm.engine, args)?.spanned(self.span()).liftable())
     }
 }
 
@@ -46,6 +46,6 @@ impl Eval for ast::ShowRule<'_> {
             expr => expr.eval(vm)?.cast::<Transformation>().at(span)?,
         };
 
-        Ok(Recipe { span, selector, transform })
+        Ok(Recipe::new(selector, transform, span))
     }
 }
diff --git a/crates/typst/src/foundations/content.rs b/crates/typst/src/foundations/content.rs
index 656049dd5..b9d1b1897 100644
--- a/crates/typst/src/foundations/content.rs
+++ b/crates/typst/src/foundations/content.rs
@@ -369,7 +369,7 @@ impl Content {
         context: Tracked<Context>,
         recipe: Recipe,
     ) -> SourceResult<Self> {
-        if recipe.selector.is_none() {
+        if recipe.selector().is_none() {
             recipe.apply(engine, context, self)
         } else {
             Ok(self.styled(recipe))
diff --git a/crates/typst/src/foundations/styles.rs b/crates/typst/src/foundations/styles.rs
index 55bb348a0..e74a16499 100644
--- a/crates/typst/src/foundations/styles.rs
+++ b/crates/typst/src/foundations/styles.rs
@@ -93,6 +93,11 @@ impl Styles {
         self.0.iter().map(|style| &**style)
     }
 
+    /// Iterate over the contained styles.
+    pub fn as_slice(&self) -> &[LazyHash<Style>] {
+        self.0.as_slice()
+    }
+
     /// Set an inner value for a style property.
     ///
     /// If the property needs folding and the value is already contained in the
@@ -118,16 +123,33 @@ impl Styles {
         self.0.insert(0, LazyHash::new(outer));
     }
 
-    /// Apply a slice of outer styles.
-    pub fn apply_slice(&mut self, outer: &[LazyHash<Style>]) {
-        self.0 = outer.iter().cloned().chain(mem::take(self).0).collect();
-    }
-
     /// Add an origin span to all contained properties.
     pub fn spanned(mut self, span: Span) -> Self {
         for entry in self.0.make_mut() {
             if let Style::Property(property) = &mut **entry {
-                property.span = Some(span);
+                property.span = span;
+            }
+        }
+        self
+    }
+
+    /// Marks the styles as having been applied outside of any show rule.
+    pub fn outside(mut self) -> Self {
+        for entry in self.0.make_mut() {
+            match &mut **entry {
+                Style::Property(property) => property.outside = true,
+                Style::Recipe(recipe) => recipe.outside = true,
+                _ => {}
+            }
+        }
+        self
+    }
+
+    /// Marks the styles as being allowed to be lifted up to the page level.
+    pub fn liftable(mut self) -> Self {
+        for entry in self.0.make_mut() {
+            if let Style::Property(property) = &mut **entry {
+                property.liftable = true;
             }
         }
         self
@@ -144,13 +166,8 @@ impl Styles {
 
     /// Returns `Some(_)` with an optional span if this list contains
     /// styles for the given element.
-    pub fn interruption<T: NativeElement>(&self) -> Option<Option<Span>> {
-        let elem = T::elem();
-        self.0.iter().find_map(|entry| match &**entry {
-            Style::Property(property) => property.is_of(elem).then_some(property.span),
-            Style::Recipe(recipe) => recipe.is_of(elem).then_some(Some(recipe.span)),
-            Style::Revocation(_) => None,
-        })
+    pub fn interruption<T: NativeElement>(&self) -> Option<Span> {
+        self.0.iter().find_map(|entry| entry.interruption::<T>())
     }
 
     /// Set a font family composed of a preferred family and existing families
@@ -176,6 +193,21 @@ impl From<Style> for Styles {
     }
 }
 
+impl IntoIterator for Styles {
+    type Item = LazyHash<Style>;
+    type IntoIter = ecow::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl FromIterator<LazyHash<Style>> for Styles {
+    fn from_iter<T: IntoIterator<Item = LazyHash<Style>>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
 impl Debug for Styles {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         f.write_str("Styles ")?;
@@ -216,6 +248,37 @@ impl Style {
             _ => None,
         }
     }
+
+    /// Returns `Some(_)` with an optional span if this style is of
+    /// the given element.
+    pub fn interruption<T: NativeElement>(&self) -> Option<Span> {
+        let elem = T::elem();
+        match self {
+            Style::Property(property) => property.is_of(elem).then_some(property.span),
+            Style::Recipe(recipe) => recipe.is_of(elem).then_some(recipe.span),
+            Style::Revocation(_) => None,
+        }
+    }
+
+    /// Whether the style is allowed to be lifted up to the page level. Only
+    /// true for styles originating from set rules.
+    pub fn liftable(&self) -> bool {
+        match self {
+            Self::Property(property) => property.liftable,
+            Self::Recipe(_) => true,
+            Self::Revocation(_) => false,
+        }
+    }
+
+    /// Whether the style was applied outside of any show rule. This is set
+    /// during realization.
+    pub fn outside(&self) -> bool {
+        match self {
+            Self::Property(property) => property.outside,
+            Self::Recipe(recipe) => recipe.outside,
+            Self::Revocation(_) => false,
+        }
+    }
 }
 
 impl Debug for Style {
@@ -250,7 +313,11 @@ pub struct Property {
     /// The property's value.
     value: Block,
     /// The span of the set rule the property stems from.
-    span: Option<Span>,
+    span: Span,
+    /// Whether the property is allowed to be lifted up to the page level.
+    liftable: bool,
+    /// Whether the property was applied outside of any show rule.
+    outside: bool,
 }
 
 impl Property {
@@ -264,7 +331,9 @@ impl Property {
             elem: E::elem(),
             id,
             value: Block::new(value),
-            span: None,
+            span: Span::detached(),
+            liftable: false,
+            outside: false,
         }
     }
 
@@ -370,19 +439,41 @@ impl Hash for dyn Blockable {
 /// A show rule recipe.
 #[derive(Clone, PartialEq, Hash)]
 pub struct Recipe {
-    /// The span that errors are reported with.
-    pub span: Span,
     /// Determines whether the recipe applies to an element.
     ///
     /// If this is `None`, then this recipe is from a show rule with
     /// no selector (`show: rest => ...`), which is [eagerly applied][Content::styled_with_recipe]
     /// to the rest of the content in the scope.
-    pub selector: Option<Selector>,
+    selector: Option<Selector>,
     /// The transformation to perform on the match.
-    pub transform: Transformation,
+    transform: Transformation,
+    /// The span that errors are reported with.
+    span: Span,
+    /// Relevant properties of the kind of construct the style originated from
+    /// and where it was applied.
+    outside: bool,
 }
 
 impl Recipe {
+    /// Create a new recipe from a key-value pair.
+    pub fn new(
+        selector: Option<Selector>,
+        transform: Transformation,
+        span: Span,
+    ) -> Self {
+        Self { selector, transform, span, outside: false }
+    }
+
+    /// The recipe's selector.
+    pub fn selector(&self) -> Option<&Selector> {
+        self.selector.as_ref()
+    }
+
+    /// The recipe's transformation.
+    pub fn transform(&self) -> &Transformation {
+        &self.transform
+    }
+
     /// Whether this recipe is for the given type of element.
     pub fn is_of(&self, element: Element) -> bool {
         match self.selector {
@@ -494,7 +585,7 @@ impl<'a> StyleChain<'a> {
     /// `self`. For folded properties `local` contributes the inner value.
     pub fn chain<'b, C>(&'b self, local: &'b C) -> StyleChain<'b>
     where
-        C: Chainable,
+        C: Chainable + ?Sized,
     {
         Chainable::chain(local, self)
     }
@@ -557,7 +648,7 @@ impl<'a> StyleChain<'a> {
     ) -> impl Iterator<Item = &'a T> {
         inherent.into_iter().chain(
             self.entries()
-                .filter_map(Style::property)
+                .filter_map(|style| style.property())
                 .filter(move |property| property.is(func, id))
                 .map(|property| &property.value)
                 .map(move |value| {
@@ -573,15 +664,6 @@ impl<'a> StyleChain<'a> {
         )
     }
 
-    /// Convert to a style map.
-    pub fn to_map(self) -> Styles {
-        let mut suffix = Styles::new();
-        for link in self.links() {
-            suffix.apply_slice(link);
-        }
-        suffix
-    }
-
     /// Iterate over the entries of the chain.
     pub fn entries(self) -> Entries<'a> {
         Entries { inner: [].as_slice().iter(), links: self.links() }
@@ -592,21 +674,59 @@ impl<'a> StyleChain<'a> {
         Links(Some(self))
     }
 
+    /// Convert to a style map.
+    pub fn to_map(self) -> Styles {
+        let mut styles: EcoVec<_> = self.entries().cloned().collect();
+        styles.make_mut().reverse();
+        Styles(styles)
+    }
+
     /// Build owned styles from the suffix (all links beyond the `len`) of the
     /// chain.
     pub fn suffix(self, len: usize) -> Styles {
-        let mut suffix = Styles::new();
+        let mut styles = EcoVec::new();
         let take = self.links().count().saturating_sub(len);
         for link in self.links().take(take) {
-            suffix.apply_slice(link);
+            styles.extend(link.iter().cloned().rev());
         }
-        suffix
+        styles.make_mut().reverse();
+        Styles(styles)
     }
 
     /// Remove the last link from the chain.
     pub fn pop(&mut self) {
         *self = self.tail.copied().unwrap_or_default();
     }
+
+    /// Determine the shared trunk of a collection of style chains.
+    pub fn trunk(iter: impl IntoIterator<Item = Self>) -> Option<Self> {
+        // Determine shared style depth and first span.
+        let mut iter = iter.into_iter();
+        let mut trunk = iter.next()?;
+        let mut depth = trunk.links().count();
+
+        for mut chain in iter {
+            let len = chain.links().count();
+            if len < depth {
+                for _ in 0..depth - len {
+                    trunk.pop();
+                }
+                depth = len;
+            } else if len > depth {
+                for _ in 0..len - depth {
+                    chain.pop();
+                }
+            }
+
+            while depth > 0 && chain != trunk {
+                trunk.pop();
+                chain.pop();
+                depth -= 1;
+            }
+        }
+
+        Some(trunk)
+    }
 }
 
 impl Debug for StyleChain<'_> {
@@ -673,7 +793,7 @@ pub struct Entries<'a> {
 }
 
 impl<'a> Iterator for Entries<'a> {
-    type Item = &'a Style;
+    type Item = &'a LazyHash<Style>;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -702,6 +822,107 @@ impl<'a> Iterator for Links<'a> {
     }
 }
 
+/// A sequence of elements with associated styles.
+#[derive(Clone, PartialEq, Hash)]
+pub struct StyleVec {
+    /// The elements themselves.
+    elements: EcoVec<Content>,
+    /// A run-length encoded list of style lists.
+    ///
+    /// Each element is a (styles, count) pair. Any elements whose
+    /// style falls after the end of this list is considered to
+    /// have an empty style list.
+    styles: EcoVec<(Styles, usize)>,
+}
+
+impl StyleVec {
+    /// Create a style vector from an unstyled vector content.
+    pub fn wrap(elements: EcoVec<Content>) -> Self {
+        Self { elements, styles: EcoVec::new() }
+    }
+
+    /// Create a `StyleVec` from a list of content with style chains.
+    pub fn create<'a>(buf: &[(&'a Content, StyleChain<'a>)]) -> (Self, StyleChain<'a>) {
+        let trunk = StyleChain::trunk(buf.iter().map(|&(_, s)| s)).unwrap_or_default();
+        let depth = trunk.links().count();
+
+        let mut elements = EcoVec::with_capacity(buf.len());
+        let mut styles = EcoVec::<(Styles, usize)>::new();
+        let mut last: Option<(StyleChain<'a>, usize)> = None;
+
+        for &(element, chain) in buf {
+            elements.push(element.clone());
+
+            if let Some((prev, run)) = &mut last {
+                if chain == *prev {
+                    *run += 1;
+                } else {
+                    styles.push((prev.suffix(depth), *run));
+                    last = Some((chain, 1));
+                }
+            } else {
+                last = Some((chain, 1));
+            }
+        }
+
+        if let Some((last, run)) = last {
+            let skippable = styles.is_empty() && last == trunk;
+            if !skippable {
+                styles.push((last.suffix(depth), run));
+            }
+        }
+
+        (StyleVec { elements, styles }, trunk)
+    }
+
+    /// Whether there are no elements.
+    pub fn is_empty(&self) -> bool {
+        self.elements.is_empty()
+    }
+
+    /// The number of elements.
+    pub fn len(&self) -> usize {
+        self.elements.len()
+    }
+
+    /// Iterate over the contained content and style chains.
+    pub fn iter<'a>(
+        &'a self,
+        outer: &'a StyleChain<'_>,
+    ) -> impl Iterator<Item = (&'a Content, StyleChain<'a>)> {
+        static EMPTY: Styles = Styles::new();
+        self.elements
+            .iter()
+            .zip(
+                self.styles
+                    .iter()
+                    .flat_map(|(local, count)| std::iter::repeat(local).take(*count))
+                    .chain(std::iter::repeat(&EMPTY)),
+            )
+            .map(|(element, local)| (element, outer.chain(local)))
+    }
+
+    /// Get a style property, but only if it is the same for all children of the
+    /// style vector.
+    pub fn shared_get<T: PartialEq>(
+        &self,
+        styles: StyleChain<'_>,
+        getter: fn(StyleChain) -> T,
+    ) -> Option<T> {
+        let value = getter(styles);
+        self.styles
+            .iter()
+            .all(|(local, _)| getter(styles.chain(local)) == value)
+            .then_some(value)
+    }
+}
+
+impl Debug for StyleVec {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        f.debug_list().entries(&self.elements).finish()
+    }
+}
+
 /// A property that is resolved with other properties from the style chain.
 pub trait Resolve {
     /// The type of the resolved output.
diff --git a/crates/typst/src/introspection/counter.rs b/crates/typst/src/introspection/counter.rs
index da44a2275..e7dd2ba08 100644
--- a/crates/typst/src/introspection/counter.rs
+++ b/crates/typst/src/introspection/counter.rs
@@ -825,7 +825,7 @@ impl ManualPageCounter {
             match item {
                 FrameItem::Group(group) => self.visit(engine, &group.frame)?,
                 FrameItem::Tag(tag) => {
-                    let Some(elem) = tag.elem.to_packed::<CounterUpdateElem>() else {
+                    let Some(elem) = tag.elem().to_packed::<CounterUpdateElem>() else {
                         continue;
                     };
                     if *elem.key() == CounterKey::Page {
diff --git a/crates/typst/src/introspection/introspector.rs b/crates/typst/src/introspection/introspector.rs
index fe59cb007..453077689 100644
--- a/crates/typst/src/introspection/introspector.rs
+++ b/crates/typst/src/introspection/introspector.rs
@@ -10,7 +10,7 @@ use smallvec::SmallVec;
 
 use crate::diag::{bail, StrResult};
 use crate::foundations::{Content, Label, Repr, Selector};
-use crate::introspection::Location;
+use crate::introspection::{Location, TagKind};
 use crate::layout::{Frame, FrameItem, Page, Point, Position, Transform};
 use crate::model::Numbering;
 use crate::utils::NonZeroExt;
@@ -66,20 +66,21 @@ impl Introspector {
                     self.extract(&group.frame, page, ts);
                 }
                 FrameItem::Tag(tag)
-                    if !self.elems.contains_key(&tag.elem.location().unwrap()) =>
+                    if tag.kind() == TagKind::Start
+                        && !self.elems.contains_key(&tag.location()) =>
                 {
                     let pos = pos.transform(ts);
-                    let loc = tag.elem.location().unwrap();
+                    let loc = tag.location();
                     let ret = self
                         .elems
-                        .insert(loc, (tag.elem.clone(), Position { page, point: pos }));
+                        .insert(loc, (tag.elem().clone(), Position { page, point: pos }));
                     assert!(ret.is_none(), "duplicate locations");
 
                     // Build the key map.
-                    self.keys.entry(tag.key).or_default().push(loc);
+                    self.keys.entry(tag.key()).or_default().push(loc);
 
                     // Build the label cache.
-                    if let Some(label) = tag.elem.label() {
+                    if let Some(label) = tag.elem().label() {
                         self.labels.entry(label).or_default().push(self.elems.len() - 1);
                     }
                 }
diff --git a/crates/typst/src/introspection/mod.rs b/crates/typst/src/introspection/mod.rs
index 6c982afb4..b1ff2e080 100644
--- a/crates/typst/src/introspection/mod.rs
+++ b/crates/typst/src/introspection/mod.rs
@@ -12,6 +12,7 @@ mod metadata;
 #[path = "query.rs"]
 mod query_;
 mod state;
+mod tag;
 
 pub use self::counter::*;
 pub use self::here_::*;
@@ -22,16 +23,9 @@ pub use self::locator::*;
 pub use self::metadata::*;
 pub use self::query_::*;
 pub use self::state::*;
+pub use self::tag::*;
 
-use std::fmt::{self, Debug, Formatter};
-
-use crate::diag::{bail, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    category, elem, Args, Category, Construct, Content, NativeElement, Packed, Scope,
-    Unlabellable,
-};
-use crate::realize::{Behave, Behaviour};
+use crate::foundations::{category, Category, Scope};
 
 /// Interactions between document parts.
 ///
@@ -57,65 +51,3 @@ pub fn define(global: &mut Scope) {
     global.define_func::<query>();
     global.define_func::<locate>();
 }
-
-/// Holds a tag for a locatable element that was realized.
-///
-/// The `TagElem` is handled by all layouters. The held element becomes
-/// available for introspection in the next compiler iteration.
-#[elem(Behave, Unlabellable, Construct)]
-pub struct TagElem {
-    /// The introspectible element.
-    #[required]
-    #[internal]
-    pub tag: Tag,
-}
-
-impl TagElem {
-    /// Create a packed tag element.
-    pub fn packed(tag: Tag) -> Content {
-        let mut content = Self::new(tag).pack();
-        // We can skip preparation for the `TagElem`.
-        content.mark_prepared();
-        content
-    }
-}
-
-impl Construct for TagElem {
-    fn construct(_: &mut Engine, args: &mut Args) -> SourceResult<Content> {
-        bail!(args.span, "cannot be constructed manually")
-    }
-}
-
-impl Unlabellable for Packed<TagElem> {}
-
-impl Behave for Packed<TagElem> {
-    fn behaviour(&self) -> Behaviour {
-        Behaviour::Invisible
-    }
-}
-
-/// Holds a locatable element that was realized.
-#[derive(Clone, PartialEq, Hash)]
-pub struct Tag {
-    /// The introspectible element.
-    pub elem: Content,
-    /// The element's key hash, which forms the base of its location (but is
-    /// locally disambiguated and combined with outer hashes).
-    ///
-    /// We need to retain this for introspector-assisted location assignment
-    /// during measurement.
-    pub(crate) key: u128,
-}
-
-impl Tag {
-    /// Create a tag from an element and its key hash.
-    pub fn new(elem: Content, key: u128) -> Self {
-        Self { elem, key }
-    }
-}
-
-impl Debug for Tag {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Tag({:?})", self.elem.elem().name())
-    }
-}
diff --git a/crates/typst/src/introspection/tag.rs b/crates/typst/src/introspection/tag.rs
new file mode 100644
index 000000000..51a6454ad
--- /dev/null
+++ b/crates/typst/src/introspection/tag.rs
@@ -0,0 +1,111 @@
+use std::fmt::{self, Debug, Formatter};
+
+use crate::diag::{bail, SourceResult};
+use crate::engine::Engine;
+use crate::foundations::{
+    elem, Args, Construct, Content, NativeElement, Packed, Unlabellable,
+};
+use crate::introspection::Location;
+use crate::realize::{Behave, Behaviour};
+
+/// Holds a locatable element that was realized.
+#[derive(Clone, PartialEq, Hash)]
+pub struct Tag {
+    /// Whether this is a start or end tag.
+    kind: TagKind,
+    /// The introspectible element.
+    elem: Content,
+    /// The element's key hash.
+    key: u128,
+}
+
+impl Tag {
+    /// Create a start tag from an element and its key hash.
+    ///
+    /// Panics if the element does not have a [`Location`].
+    #[track_caller]
+    pub fn new(elem: Content, key: u128) -> Self {
+        assert!(elem.location().is_some());
+        Self { elem, key, kind: TagKind::Start }
+    }
+
+    /// Returns the same tag with the given kind.
+    pub fn with_kind(self, kind: TagKind) -> Self {
+        Self { kind, ..self }
+    }
+
+    /// Whether this is a start or end tag.
+    pub fn kind(&self) -> TagKind {
+        self.kind
+    }
+
+    /// The locatable element that the tag holds.
+    pub fn elem(&self) -> &Content {
+        &self.elem
+    }
+
+    /// Access the location of the element.
+    pub fn location(&self) -> Location {
+        self.elem.location().unwrap()
+    }
+
+    /// The element's key hash, which forms the base of its location (but is
+    /// locally disambiguated and combined with outer hashes).
+    ///
+    /// We need to retain this for introspector-assisted location assignment
+    /// during measurement.
+    pub fn key(&self) -> u128 {
+        self.key
+    }
+}
+
+impl Debug for Tag {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "Tag({:?}, {:?})", self.kind, self.elem.elem().name())
+    }
+}
+
+/// Determines whether a tag marks the start or end of an element.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum TagKind {
+    /// The tag indicates that the element starts here.
+    Start,
+    /// The tag indicates that the element end here.
+    End,
+}
+
+/// Holds a tag for a locatable element that was realized.
+///
+/// The `TagElem` is handled by all layouters. The held element becomes
+/// available for introspection in the next compiler iteration.
+#[elem(Behave, Unlabellable, Construct)]
+pub struct TagElem {
+    /// The introspectible element.
+    #[required]
+    #[internal]
+    pub tag: Tag,
+}
+
+impl TagElem {
+    /// Create a packed tag element.
+    pub fn packed(tag: Tag) -> Content {
+        let mut content = Self::new(tag).pack();
+        // We can skip preparation for the `TagElem`.
+        content.mark_prepared();
+        content
+    }
+}
+
+impl Construct for TagElem {
+    fn construct(_: &mut Engine, args: &mut Args) -> SourceResult<Content> {
+        bail!(args.span, "cannot be constructed manually")
+    }
+}
+
+impl Unlabellable for Packed<TagElem> {}
+
+impl Behave for Packed<TagElem> {
+    fn behaviour(&self) -> Behaviour {
+        Behaviour::Ignorant
+    }
+}
diff --git a/crates/typst/src/layout/flow.rs b/crates/typst/src/layout/flow.rs
index 1566febcb..f1148604d 100644
--- a/crates/typst/src/layout/flow.rs
+++ b/crates/typst/src/layout/flow.rs
@@ -2,35 +2,65 @@
 //! - at the top-level, into a [`Document`].
 //! - inside of a container, into a [`Frame`] or [`Fragment`].
 
-use std::fmt::{self, Debug, Formatter};
+use std::collections::HashSet;
 use std::num::NonZeroUsize;
-use std::ptr;
 
 use comemo::{Track, Tracked, TrackedMut};
 
 use crate::diag::{bail, SourceResult};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
-    elem, Args, Construct, Content, NativeElement, Packed, Resolve, Smart, StyleChain,
+    Content, NativeElement, Packed, Resolve, Smart, StyleChain, Styles,
 };
 use crate::introspection::{
-    Counter, CounterDisplayElem, CounterKey, Introspector, Locator, LocatorLink,
-    ManualPageCounter, SplitLocator, Tag, TagElem,
+    Counter, CounterDisplayElem, CounterKey, Introspector, Location, Locator,
+    LocatorLink, ManualPageCounter, SplitLocator, Tag, TagElem, TagKind,
 };
 use crate::layout::{
     Abs, AlignElem, Alignment, Axes, Binding, BlockElem, ColbreakElem, ColumnsElem, Dir,
     FixedAlignment, FlushElem, Fr, Fragment, Frame, FrameItem, HAlignment, Length,
-    OuterVAlignment, Page, PageElem, Paper, Parity, PlaceElem, Point, Ratio, Region,
-    Regions, Rel, Sides, Size, Spacing, VAlignment, VElem,
+    OuterVAlignment, Page, PageElem, PagebreakElem, Paper, Parity, PlaceElem, Point,
+    Ratio, Region, Regions, Rel, Sides, Size, Spacing, VAlignment, VElem,
 };
-use crate::model::{Document, Numbering};
-use crate::model::{FootnoteElem, FootnoteEntry, ParElem};
-use crate::realize::StyleVec;
-use crate::realize::{realize_flow, realize_root, Arenas};
+use crate::model::{Document, FootnoteElem, FootnoteEntry, Numbering, ParElem};
+use crate::realize::{first_span, realize_root, realizer_container, Arenas, Pair};
+use crate::syntax::Span;
 use crate::text::TextElem;
 use crate::utils::{NonZeroExt, Numeric};
+use crate::visualize::Paint;
 use crate::World;
 
+/// An item in page layout.
+enum PageItem<'a> {
+    /// A page run containing content. All runs will be layouted in parallel.
+    Run(&'a [Pair<'a>], StyleChain<'a>, Locator<'a>),
+    /// Tags in between pages. These will be preprended to the first start of
+    /// the next page, or appended at the very end of the final page if there is
+    /// no next page.
+    Tags(&'a [Pair<'a>]),
+    /// An instruction to possibly add a page to bring the page number parity to
+    /// the desired state. Can only be done at the end, sequentially, because it
+    /// requires knowledge of the concrete page number.
+    Parity(Parity, StyleChain<'a>, Locator<'a>),
+}
+
+/// A mostly finished layout for one page. Needs only knowledge of its exact
+/// page number to be finalized into a `Page`. (Because the margins can depend
+/// on the page number.)
+#[derive(Clone)]
+struct LayoutedPage {
+    inner: Frame,
+    margin: Sides<Abs>,
+    binding: Binding,
+    two_sided: bool,
+    header: Option<Frame>,
+    footer: Option<Frame>,
+    background: Option<Frame>,
+    foreground: Option<Frame>,
+    fill: Smart<Option<Paint>>,
+    numbering: Option<Numbering>,
+}
+
 /// Layout content into a document.
 ///
 /// This first performs root-level realization and then lays out the resulting
@@ -74,74 +104,297 @@ fn layout_document_impl(
         route: Route::extend(route).unnested(),
     };
 
+    // Mark the external styles as "outside" so that they are valid at the page
+    // level.
+    let styles = styles.to_map().outside();
+    let styles = StyleChain::new(&styles);
+
     let arenas = Arenas::default();
-    let (children, styles, info) =
+    let (mut children, info) =
         realize_root(&mut engine, &mut locator, &arenas, content, styles)?;
 
-    let mut peekable = children.chain(&styles).peekable();
-    let iter = std::iter::from_fn(|| {
-        let (child, styles) = peekable.next()?;
-        let extend_to = peekable
-            .peek()
-            .and_then(|(next, _)| *next.to_packed::<PageElem>()?.clear_to()?);
-        let locator = locator.next(&child.span());
-        Some((child, styles, extend_to, locator))
-    });
-
-    let layouts =
-        engine.parallelize(iter, |engine, (child, styles, extend_to, locator)| {
-            if let Some(page) = child.to_packed::<PageElem>() {
-                layout_page_run(engine, page, locator, styles, extend_to)
-            } else {
-                bail!(child.span(), "expected page element");
-            }
-        });
-
-    let mut page_counter = ManualPageCounter::new();
-    let mut pages = Vec::with_capacity(children.len());
-    for result in layouts {
-        let layout = result?;
-        pages.extend(finalize_page_run(&mut engine, layout, &mut page_counter)?);
-    }
+    let pages = layout_pages(&mut engine, &mut children, locator, styles)?;
 
     Ok(Document { pages, info, introspector: Introspector::default() })
 }
 
-/// A prepared layout of a page run that can be finalized with access to the
-/// page counter.
-struct PageRunLayout<'a> {
-    page: &'a Packed<PageElem>,
+/// Layouts the document's pages.
+fn layout_pages<'a>(
+    engine: &mut Engine,
+    children: &'a mut [Pair<'a>],
     locator: SplitLocator<'a>,
     styles: StyleChain<'a>,
-    extend_to: Option<Parity>,
-    area: Size,
-    margin: Sides<Abs>,
-    two_sided: bool,
-    frames: Vec<Frame>,
+) -> SourceResult<Vec<Page>> {
+    // Slice up the children into logical parts.
+    let items = collect_page_items(children, locator, styles);
+
+    // Layout the page runs in parallel.
+    let mut runs = engine.parallelize(
+        items.iter().filter_map(|item| match item {
+            PageItem::Run(children, initial, locator) => {
+                Some((children, initial, locator.relayout()))
+            }
+            _ => None,
+        }),
+        |engine, (children, initial, locator)| {
+            layout_page_run(engine, children, locator, *initial)
+        },
+    );
+
+    let mut pages = vec![];
+    let mut tags = vec![];
+    let mut counter = ManualPageCounter::new();
+
+    // Collect and finalize the runs, handling things like page parity and tags
+    // between pages.
+    for item in &items {
+        match item {
+            PageItem::Run(..) => {
+                let layouted = runs.next().unwrap()?;
+                for layouted in layouted {
+                    let page = finalize_page(engine, &mut counter, &mut tags, layouted)?;
+                    pages.push(page);
+                }
+            }
+            PageItem::Parity(parity, initial, locator) => {
+                if !parity.matches(pages.len()) {
+                    continue;
+                }
+
+                let layouted = layout_blank_page(engine, locator.relayout(), *initial)?;
+                let page = finalize_page(engine, &mut counter, &mut tags, layouted)?;
+                pages.push(page);
+            }
+            PageItem::Tags(items) => {
+                tags.extend(
+                    items
+                        .iter()
+                        .filter_map(|(c, _)| c.to_packed::<TagElem>())
+                        .map(|elem| elem.tag.clone()),
+                );
+            }
+        }
+    }
+
+    // Add the remaining tags to the very end of the last page.
+    if !tags.is_empty() {
+        let last = pages.last_mut().unwrap();
+        let pos = Point::with_y(last.frame.height());
+        last.frame
+            .push_multiple(tags.into_iter().map(|tag| (pos, FrameItem::Tag(tag))));
+    }
+
+    Ok(pages)
 }
 
-/// A document can consist of multiple `PageElem`s, one per run of pages
-/// with equal properties (not one per actual output page!). The `number` is
-/// the physical page number of the first page of this run. It is mutated
-/// while we post-process the pages in this function. This function returns
-/// a fragment consisting of multiple frames, one per output page of this
-/// page run.
-#[typst_macros::time(name = "pages", span = page.span())]
-fn layout_page_run<'a>(
+/// Slices up the children into logical parts, processing styles and handling
+/// things like tags and weak pagebreaks.
+fn collect_page_items<'a>(
+    mut children: &'a mut [Pair<'a>],
+    mut locator: SplitLocator<'a>,
+    mut initial: StyleChain<'a>,
+) -> Vec<PageItem<'a>> {
+    // The collected page-level items.
+    let mut items: Vec<PageItem<'a>> = vec![];
+    // When this is true, an empty page should be added to `pages` at the end.
+    let mut staged_empty_page = true;
+
+    // The `children` are a flat list of flow-level items and pagebreaks. This
+    // loops splits it up into pagebreaks and consecutive slices of
+    // non-pagebreaks. From these pieces, we build page items that we can then
+    // layout in parallel.
+    while let Some(&(elem, styles)) = children.first() {
+        if let Some(pagebreak) = elem.to_packed::<PagebreakElem>() {
+            // Add a blank page if we encounter a strong pagebreak and there was
+            // a staged empty page.
+            let strong = !pagebreak.weak(styles);
+            if strong && staged_empty_page {
+                let locator = locator.next(&elem.span());
+                items.push(PageItem::Run(&[], initial, locator));
+            }
+
+            // Add an instruction to adjust the page parity if requested.
+            if let Some(parity) = pagebreak.to(styles) {
+                let locator = locator.next(&elem.span());
+                items.push(PageItem::Parity(parity, styles, locator));
+            }
+
+            // The initial styles for the next page are ours unless this is a
+            // "boundary" pagebreak. Such a pagebreak is generated at the end of
+            // the scope of a page set rule to ensure a page boundary. It's
+            // styles correspond to the styles _before_ the page set rule, so we
+            // don't want to apply it to a potential empty page.
+            if !pagebreak.boundary(styles) {
+                initial = styles;
+            }
+
+            // Stage an empty page after a strong pagebreak.
+            staged_empty_page |= strong;
+
+            // Advance to the next child.
+            children = &mut children[1..];
+        } else {
+            // Find the end of the consecutive non-pagebreak run.
+            let end =
+                children.iter().take_while(|(c, _)| !c.is::<PagebreakElem>()).count();
+
+            // Migrate start tags without accompanying end tags from before a
+            // pagebreak to after it.
+            let end = migrate_unterminated_tags(children, end);
+            if end == 0 {
+                continue;
+            }
+
+            // Advance to the rest of the children.
+            let (group, rest) = children.split_at_mut(end);
+            children = rest;
+
+            // If all that is left now are tags, then we don't want to add a
+            // page just for them (since no group would have been detected in a
+            // tagless layout and tags should never affect the layout). For this
+            // reason, we remember them in a `PageItem::Tags` and later insert
+            // them at the _very start_ of the next page, even before the
+            // header.
+            //
+            // We don't do this if all that's left is end boundary pagebreaks
+            // and if an empty page is still staged, since then we can just
+            // conceptually replace that final page with us.
+            if group.iter().all(|(c, _)| c.is::<TagElem>())
+                && !(staged_empty_page
+                    && children.iter().all(|&(c, s)| {
+                        c.to_packed::<PagebreakElem>().is_some_and(|c| c.boundary(s))
+                    }))
+            {
+                items.push(PageItem::Tags(group));
+                continue;
+            }
+
+            // Record a page run and then disregard a staged empty page because
+            // we have real content now.
+            let locator = locator.next(&elem.span());
+            items.push(PageItem::Run(group, initial, locator));
+            staged_empty_page = false;
+        }
+    }
+
+    // Flush a staged empty page.
+    if staged_empty_page {
+        items.push(PageItem::Run(&[], initial, locator.next(&())));
+    }
+
+    items
+}
+
+/// Migrates trailing start tags without accompanying end tags tags from before
+/// a pagebreak to after it. Returns the position right after the last
+/// non-migrated tag.
+///
+/// This is important because we want the positions of introspectible elements
+/// that technically started before a pagebreak, but have no visible content
+/// yet, to be after the pagebreak. A typical case where this happens is `show
+/// heading: it => pagebreak() + it`.
+fn migrate_unterminated_tags(children: &mut [Pair], mid: usize) -> usize {
+    // Compute the range from before the first trailing tag to after the last
+    // following pagebreak.
+    let (before, after) = children.split_at(mid);
+    let start = mid - before.iter().rev().take_while(|&(c, _)| c.is::<TagElem>()).count();
+    let end = mid + after.iter().take_while(|&(c, _)| c.is::<PagebreakElem>()).count();
+
+    // Determine the set of tag locations which we won't migrate (because they
+    // are terminated).
+    let excluded: HashSet<_> = children[start..mid]
+        .iter()
+        .filter_map(|(c, _)| c.to_packed::<TagElem>())
+        .filter(|elem| elem.tag.kind() == TagKind::End)
+        .map(|elem| elem.tag.location())
+        .collect();
+
+    // A key function that partitions the area of interest into three groups:
+    // Excluded tags (-1) | Pagebreaks (0) | Migrated tags (1).
+    let key = |(c, _): &Pair| match c.to_packed::<TagElem>() {
+        Some(elem) => {
+            if excluded.contains(&elem.tag.location()) {
+                -1
+            } else {
+                1
+            }
+        }
+        None => 0,
+    };
+
+    // Partition the children using a *stable* sort. While it would be possible
+    // to write a more efficient direct algorithm for this, the sort version is
+    // less likely to have bugs and this is absolutely not on a hot path.
+    children[start..end].sort_by_key(key);
+
+    // Compute the new end index, right before the pagebreaks.
+    start + children[start..end].iter().take_while(|pair| key(pair) == -1).count()
+}
+
+/// Layout a page run with uniform properties.
+#[typst_macros::time(name = "page run")]
+fn layout_page_run(
     engine: &mut Engine,
-    page: &'a Packed<PageElem>,
-    locator: Locator<'a>,
-    styles: StyleChain<'a>,
-    extend_to: Option<Parity>,
-) -> SourceResult<PageRunLayout<'a>> {
-    let mut locator = locator.split();
+    children: &[Pair],
+    locator: Locator,
+    initial: StyleChain,
+) -> SourceResult<Vec<LayoutedPage>> {
+    layout_page_run_impl(
+        engine.world,
+        engine.introspector,
+        engine.traced,
+        TrackedMut::reborrow_mut(&mut engine.sink),
+        engine.route.track(),
+        children,
+        locator.track(),
+        initial,
+    )
+}
+
+/// Layout a single page suitable  for parity adjustment.
+fn layout_blank_page(
+    engine: &mut Engine,
+    locator: Locator,
+    initial: StyleChain,
+) -> SourceResult<LayoutedPage> {
+    let layouted = layout_page_run(engine, &[], locator, initial)?;
+    Ok(layouted.into_iter().next().unwrap())
+}
+
+/// The internal implementation of `layout_page_run`.
+#[comemo::memoize]
+#[allow(clippy::too_many_arguments)]
+fn layout_page_run_impl(
+    world: Tracked<dyn World + '_>,
+    introspector: Tracked<Introspector>,
+    traced: Tracked<Traced>,
+    sink: TrackedMut<Sink>,
+    route: Tracked<Route>,
+    children: &[Pair],
+    locator: Tracked<Locator>,
+    initial: StyleChain,
+) -> SourceResult<Vec<LayoutedPage>> {
+    let link = LocatorLink::new(locator);
+    let mut locator = Locator::link(&link).split();
+    let mut engine = Engine {
+        world,
+        introspector,
+        traced,
+        sink,
+        route: Route::extend(route),
+    };
+
+    // Determine the page-wide styles.
+    let styles = determine_page_styles(children, initial);
+    let styles = StyleChain::new(&styles);
+    let span = first_span(children);
 
     // When one of the lengths is infinite the page fits its content along
     // that axis.
-    let width = page.width(styles).unwrap_or(Abs::inf());
-    let height = page.height(styles).unwrap_or(Abs::inf());
+    let width = PageElem::width_in(styles).unwrap_or(Abs::inf());
+    let height = PageElem::height_in(styles).unwrap_or(Abs::inf());
     let mut size = Size::new(width, height);
-    if page.flipped(styles) {
+    if PageElem::flipped_in(styles) {
         std::mem::swap(&mut size.x, &mut size.y);
     }
 
@@ -152,7 +405,7 @@ fn layout_page_run<'a>(
 
     // Determine the margins.
     let default = Rel::<Length>::from((2.5 / 21.0) * min);
-    let margin = page.margin(styles);
+    let margin = PageElem::margin_in(styles);
     let two_sided = margin.two_sided.unwrap_or(false);
     let margin = margin
         .sides
@@ -165,72 +418,18 @@ fn layout_page_run<'a>(
     let mut regions = Regions::repeat(area, area.map(Abs::is_finite));
     regions.root = true;
 
-    // Layout the child.
-    let columns = page.columns(styles);
-    let fragment = if columns.get() > 1 {
-        layout_fragment_with_columns(
-            engine,
-            &page.body,
-            locator.next(&page.span()),
-            styles,
-            regions,
-            columns,
-            ColumnsElem::gutter_in(styles),
-        )?
-    } else {
-        layout_fragment(engine, &page.body, locator.next(&page.span()), styles, regions)?
-    };
-
-    Ok(PageRunLayout {
-        page,
-        locator,
-        styles,
-        extend_to,
-        area,
-        margin,
-        two_sided,
-        frames: fragment.into_frames(),
-    })
-}
-
-/// Finalize the layout with access to the next page counter.
-#[typst_macros::time(name = "finalize pages", span = page.span())]
-fn finalize_page_run(
-    engine: &mut Engine,
-    PageRunLayout {
-        page,
-        mut locator,
-        styles,
-        extend_to,
-        area,
-        margin,
-        two_sided,
-        mut frames,
-    }: PageRunLayout<'_>,
-    page_counter: &mut ManualPageCounter,
-) -> SourceResult<Vec<Page>> {
-    // Align the child to the pagebreak's parity.
-    // Check for page count after adding the pending frames
-    if extend_to.is_some_and(|p| !p.matches(page_counter.physical().get() + frames.len()))
-    {
-        // Insert empty page after the current pages.
-        let size = area.map(Abs::is_finite).select(area, Size::zero());
-        frames.push(Frame::hard(size));
-    }
-
-    let fill = page.fill(styles);
-    let foreground = page.foreground(styles);
-    let background = page.background(styles);
-    let header_ascent = page.header_ascent(styles);
-    let footer_descent = page.footer_descent(styles);
-    let numbering = page.numbering(styles);
-    let number_align = page.number_align(styles);
+    let fill = PageElem::fill_in(styles);
+    let foreground = PageElem::foreground_in(styles);
+    let background = PageElem::background_in(styles);
+    let header_ascent = PageElem::header_ascent_in(styles).relative_to(margin.top);
+    let footer_descent = PageElem::footer_descent_in(styles).relative_to(margin.bottom);
+    let numbering = PageElem::numbering_in(styles);
+    let number_align = PageElem::number_align_in(styles);
     let binding =
-        page.binding(styles)
-            .unwrap_or_else(|| match TextElem::dir_in(styles) {
-                Dir::LTR => Binding::Left,
-                _ => Binding::Right,
-            });
+        PageElem::binding_in(styles).unwrap_or_else(|| match TextElem::dir_in(styles) {
+            Dir::LTR => Binding::Left,
+            _ => Binding::Right,
+        });
 
     // Construct the numbering (for header or footer).
     let numbering_marginal = numbering.as_ref().map(|numbering| {
@@ -245,7 +444,7 @@ fn finalize_page_run(
             both,
         )
         .pack()
-        .spanned(page.span());
+        .spanned(span);
 
         // We interpret the Y alignment as selecting header or footer
         // and then ignore it for aligning the actual number.
@@ -256,96 +455,180 @@ fn finalize_page_run(
         counter
     });
 
-    let header = page.header(styles);
-    let footer = page.footer(styles);
+    let header = PageElem::header_in(styles);
+    let footer = PageElem::footer_in(styles);
     let (header, footer) = if matches!(number_align.y(), Some(OuterVAlignment::Top)) {
         (header.as_ref().unwrap_or(&numbering_marginal), footer.as_ref().unwrap_or(&None))
     } else {
         (header.as_ref().unwrap_or(&None), footer.as_ref().unwrap_or(&numbering_marginal))
     };
 
-    // Post-process pages.
-    let mut pages = Vec::with_capacity(frames.len());
-    for mut frame in frames {
-        // The padded width of the page's content without margins.
-        let pw = frame.width();
+    // Layout the children.
+    let fragment = FlowLayouter::new(
+        &mut engine,
+        children,
+        locator.next(&span).split(),
+        styles,
+        regions,
+        PageElem::columns_in(styles),
+        ColumnsElem::gutter_in(styles),
+        span,
+        &mut vec![],
+    )
+    .layout(regions)?;
 
-        // If two sided, left becomes inside and right becomes outside.
-        // Thus, for left-bound pages, we want to swap on even pages and
-        // for right-bound pages, we want to swap on odd pages.
-        let mut margin = margin;
-        if two_sided && binding.swap(page_counter.physical()) {
-            std::mem::swap(&mut margin.left, &mut margin.right);
-        }
+    // Layouts a single marginal.
+    let mut layout_marginal = |content: &Option<Content>, area, align| {
+        let Some(content) = content else { return Ok(None) };
+        let aligned = content.clone().styled(AlignElem::set_alignment(align));
+        layout_frame(
+            &mut engine,
+            &aligned,
+            locator.next(&content.span()),
+            styles,
+            Region::new(area, Axes::splat(true)),
+        )
+        .map(Some)
+    };
 
-        // Realize margins.
-        frame.set_size(frame.size() + margin.sum_by_axis());
-        frame.translate(Point::new(margin.left, margin.top));
-
-        // The page size with margins.
-        let size = frame.size();
-
-        // Realize overlays.
-        for marginal in [header, footer, background, foreground] {
-            let Some(content) = marginal.as_ref() else { continue };
-
-            let (pos, area, align);
-            if ptr::eq(marginal, header) {
-                let ascent = header_ascent.relative_to(margin.top);
-                pos = Point::with_x(margin.left);
-                area = Size::new(pw, margin.top - ascent);
-                align = Alignment::BOTTOM;
-            } else if ptr::eq(marginal, footer) {
-                let descent = footer_descent.relative_to(margin.bottom);
-                pos = Point::new(margin.left, size.y - margin.bottom + descent);
-                area = Size::new(pw, margin.bottom - descent);
-                align = Alignment::TOP;
-            } else {
-                pos = Point::zero();
-                area = size;
-                align = HAlignment::Center + VAlignment::Horizon;
-            };
-
-            let aligned = content.clone().styled(AlignElem::set_alignment(align));
-            let sub = layout_frame(
-                engine,
-                &aligned,
-                locator.next(&content.span()),
-                styles,
-                Region::new(area, Axes::splat(true)),
-            )?;
-
-            if ptr::eq(marginal, header) || ptr::eq(marginal, background) {
-                frame.prepend_frame(pos, sub);
-            } else {
-                frame.push_frame(pos, sub);
-            }
-        }
-
-        page_counter.visit(engine, &frame)?;
-        pages.push(Page {
-            frame,
+    // Layout marginals.
+    let mut layouted = Vec::with_capacity(fragment.len());
+    for inner in fragment {
+        let header_size = Size::new(inner.width(), margin.top - header_ascent);
+        let footer_size = Size::new(inner.width(), margin.bottom - footer_descent);
+        let full_size = inner.size() + margin.sum_by_axis();
+        let mid = HAlignment::Center + VAlignment::Horizon;
+        layouted.push(LayoutedPage {
+            inner,
             fill: fill.clone(),
             numbering: numbering.clone(),
-            number: page_counter.logical(),
+            header: layout_marginal(header, header_size, Alignment::BOTTOM)?,
+            footer: layout_marginal(footer, footer_size, Alignment::TOP)?,
+            background: layout_marginal(background, full_size, mid)?,
+            foreground: layout_marginal(foreground, full_size, mid)?,
+            margin,
+            binding,
+            two_sided,
         });
-
-        page_counter.step();
     }
 
-    Ok(pages)
+    Ok(layouted)
 }
 
-/// Layout content into a single region.
-pub fn layout_frame(
+/// Determines the styles used for a page run itself and page-level content like
+/// marginals and footnotes.
+///
+/// As a base, we collect the styles that are shared by all elements on the page
+/// run. As a fallback if there are no elements, we use the styles active at the
+/// pagebreak that introduced the page (at the very start, we use the default
+/// styles). Then, to produce our page styles, we filter this list of styles
+/// according to a few rules:
+///
+/// - Other styles are only kept if they are `outside && (initial || liftable)`.
+/// - "Outside" means they were not produced within a show rule or that the
+///   show rule "broke free" to the page level by emitting page styles.
+/// - "Initial" means they were active at the pagebreak that introduced the
+///   page. Since these are intuitively already active, they should be kept even
+///   if not liftable. (E.g. `text(red, page(..)`) makes the footer red.)
+/// - "Liftable" means they can be lifted to the page-level even though they
+///   weren't yet active at the very beginning. Set rule styles are liftable as
+///   opposed to direct constructor calls:
+///   - For `set page(..); set text(red)` the red text is kept even though it
+///     comes after the weak pagebreak from set page.
+///   - For `set page(..); text(red)[..]` the red isn't kept because the
+///     constructor styles are not liftable.
+fn determine_page_styles(children: &[Pair], initial: StyleChain) -> Styles {
+    // Determine the shared styles (excluding tags).
+    let tagless = children.iter().filter(|(c, _)| !c.is::<TagElem>()).map(|&(_, s)| s);
+    let base = StyleChain::trunk(tagless).unwrap_or(initial).to_map();
+
+    // Determine the initial styles that are also shared by everything. We can't
+    // use `StyleChain::trunk` because it currently doesn't deal with partially
+    // shared links (where a subslice matches).
+    let trunk_len = initial
+        .to_map()
+        .as_slice()
+        .iter()
+        .zip(base.as_slice())
+        .take_while(|&(a, b)| a == b)
+        .count();
+
+    // Filter the base styles according to our rules.
+    base.into_iter()
+        .enumerate()
+        .filter(|(i, style)| {
+            let initial = *i < trunk_len;
+            style.outside() && (initial || style.liftable())
+        })
+        .map(|(_, style)| style)
+        .collect()
+}
+
+/// Piece together the inner page frame and the marginals. We can only do this
+/// at the very end because inside/outside margins require knowledge of the
+/// physical page number, which is unknown during parallel layout.
+fn finalize_page(
     engine: &mut Engine,
-    content: &Content,
-    locator: Locator,
-    styles: StyleChain,
-    region: Region,
-) -> SourceResult<Frame> {
-    layout_fragment(engine, content, locator, styles, region.into())
-        .map(Fragment::into_frame)
+    counter: &mut ManualPageCounter,
+    tags: &mut Vec<Tag>,
+    LayoutedPage {
+        inner,
+        mut margin,
+        binding,
+        two_sided,
+        header,
+        footer,
+        background,
+        foreground,
+        fill,
+        numbering,
+    }: LayoutedPage,
+) -> SourceResult<Page> {
+    // If two sided, left becomes inside and right becomes outside.
+    // Thus, for left-bound pages, we want to swap on even pages and
+    // for right-bound pages, we want to swap on odd pages.
+    if two_sided && binding.swap(counter.physical()) {
+        std::mem::swap(&mut margin.left, &mut margin.right);
+    }
+
+    // Create a frame for the full page.
+    let mut frame = Frame::hard(inner.size() + margin.sum_by_axis());
+
+    // Add tags.
+    for tag in tags.drain(..) {
+        frame.push(Point::zero(), FrameItem::Tag(tag));
+    }
+
+    // Add the "before" marginals. The order in which we push things here is
+    // important as it affects the relative ordering of introspectible elements
+    // and thus how counters resolve.
+    if let Some(background) = background {
+        frame.push_frame(Point::zero(), background);
+    }
+    if let Some(header) = header {
+        frame.push_frame(Point::with_x(margin.left), header);
+    }
+
+    // Add the inner contents.
+    frame.push_frame(Point::new(margin.left, margin.top), inner);
+
+    // Add the "after" marginals.
+    if let Some(footer) = footer {
+        let y = frame.height() - footer.height();
+        frame.push_frame(Point::new(margin.left, y), footer);
+    }
+    if let Some(foreground) = foreground {
+        frame.push_frame(Point::zero(), foreground);
+    }
+
+    // Apply counter updates from within the page to the manual page counter.
+    counter.visit(engine, &frame)?;
+
+    // Get this page's number and then bump the counter for the next page.
+    let number = counter.logical();
+    counter.step();
+
+    Ok(Page { frame, fill, numbering, number })
 }
 
 /// Layout content into multiple regions.
@@ -403,9 +686,21 @@ pub fn layout_fragment_with_columns(
     )
 }
 
+/// Layout content into a single region.
+pub fn layout_frame(
+    engine: &mut Engine,
+    content: &Content,
+    locator: Locator,
+    styles: StyleChain,
+    region: Region,
+) -> SourceResult<Frame> {
+    layout_fragment(engine, content, locator, styles, region.into())
+        .map(Fragment::into_frame)
+}
+
 /// The internal implementation of [`layout_fragment`].
-#[allow(clippy::too_many_arguments)]
 #[comemo::memoize]
+#[allow(clippy::too_many_arguments)]
 fn layout_fragment_impl(
     world: Tracked<dyn World + '_>,
     introspector: Tracked<Introspector>,
@@ -414,7 +709,7 @@ fn layout_fragment_impl(
     route: Tracked<Route>,
     content: &Content,
     locator: Tracked<Locator>,
-    mut styles: StyleChain,
+    styles: StyleChain,
     regions: Regions,
     columns: NonZeroUsize,
     column_gutter: Rel<Abs>,
@@ -435,71 +730,40 @@ fn layout_fragment_impl(
             hint: "try to reduce the amount of nesting in your layout",
         );
     }
-    // Layout the content by first turning it into a `FlowElem` and then
-    // layouting that.
-    let arenas = Arenas::default();
 
     // If we are in a `PageElem`, this might already be a realized flow.
-    let stored;
-    let flow = if let Some(flow) = content.to_packed::<FlowElem>() {
-        flow
-    } else {
-        (stored, styles) =
-            realize_flow(&mut engine, &mut locator, &arenas, content, styles)?;
-        &stored
-    };
+    let arenas = Arenas::default();
+    let children =
+        realizer_container(&mut engine, &mut locator, &arenas, content, styles)?;
 
     FlowLayouter::new(
         &mut engine,
-        flow,
+        &children,
         locator,
-        &styles,
+        styles,
         regions,
         columns,
         column_gutter,
+        content.span(),
         &mut vec![],
     )
     .layout(regions)
 }
 
-/// A collection of block-level layoutable elements. This is analogous to a
-/// paragraph, which is a collection of inline-level layoutable elements.
-///
-/// This element is responsible for layouting both the top-level content flow
-/// and the contents of any containers.
-#[elem(Debug, Construct)]
-pub struct FlowElem {
-    /// The children that will be arranged into a flow.
-    #[internal]
-    #[variadic]
-    pub children: StyleVec,
-}
-
-impl Construct for FlowElem {
-    fn construct(_: &mut Engine, args: &mut Args) -> SourceResult<Content> {
-        bail!(args.span, "cannot be constructed manually");
-    }
-}
-
-impl Debug for FlowElem {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Flow ")?;
-        self.children.fmt(f)
-    }
-}
-
-/// Performs flow layout.
+/// Layouts a collection of block-level elements.
 struct FlowLayouter<'a, 'e> {
     /// The engine.
     engine: &'a mut Engine<'e>,
     /// The children that will be arranged into a flow.
-    flow: &'a Packed<FlowElem>,
+    children: &'a [Pair<'a>],
+    /// A span to use for errors.
+    span: Span,
     /// Whether this is the root flow.
     root: bool,
     /// Provides unique locations to the flow's children.
     locator: SplitLocator<'a>,
     /// The shared styles.
-    styles: &'a StyleChain<'a>,
+    shared: StyleChain<'a>,
     /// The number of columns.
     columns: usize,
     /// The gutter between columns.
@@ -526,6 +790,8 @@ struct FlowLayouter<'a, 'e> {
     has_footnotes: bool,
     /// Footnote configuration.
     footnote_config: FootnoteConfig,
+    /// Footnotes that we have already processed.
+    visited_footnotes: HashSet<Location>,
     /// Finished frames for previous regions.
     finished: Vec<Frame>,
 }
@@ -602,12 +868,13 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
     #[allow(clippy::too_many_arguments)]
     fn new(
         engine: &'a mut Engine<'e>,
-        flow: &'a Packed<FlowElem>,
+        children: &'a [Pair<'a>],
         locator: SplitLocator<'a>,
-        styles: &'a StyleChain<'a>,
+        shared: StyleChain<'a>,
         mut regions: Regions<'a>,
         columns: NonZeroUsize,
         column_gutter: Rel<Abs>,
+        span: Span,
         backlog: &'a mut Vec<Abs>,
     ) -> Self {
         // Separating the infinite space into infinite columns does not make
@@ -650,7 +917,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
         // passed all the way through the block & pad and reach the innermost
         // flow, so that things are properly bottom-aligned.
         let mut alone = false;
-        if let [child] = flow.children.elements() {
+        if let [(child, _)] = children {
             alone = child.is::<BlockElem>();
         }
 
@@ -666,10 +933,11 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
 
         Self {
             engine,
-            flow,
+            children,
+            span,
             root,
             locator,
-            styles,
+            shared,
             columns,
             column_gutter,
             regions,
@@ -681,17 +949,18 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
             pending_floats: vec![],
             has_footnotes: false,
             footnote_config: FootnoteConfig {
-                separator: FootnoteEntry::separator_in(*styles),
-                clearance: FootnoteEntry::clearance_in(*styles),
-                gap: FootnoteEntry::gap_in(*styles),
+                separator: FootnoteEntry::separator_in(shared),
+                clearance: FootnoteEntry::clearance_in(shared),
+                gap: FootnoteEntry::gap_in(shared),
             },
+            visited_footnotes: HashSet::new(),
             finished: vec![],
         }
     }
 
     /// Layout the flow.
     fn layout(mut self, regions: Regions) -> SourceResult<Fragment> {
-        for (child, styles) in self.flow.children.chain(self.styles) {
+        for &(child, styles) in self.children {
             if let Some(elem) = child.to_packed::<TagElem>() {
                 self.handle_tag(elem);
             } else if let Some(elem) = child.to_packed::<VElem>() {
@@ -873,7 +1142,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
         for (i, mut frame) in fragment.into_iter().enumerate() {
             // Find footnotes in the frame.
             if self.root {
-                collect_footnotes(&mut notes, &frame);
+                self.collect_footnotes(&mut notes, &frame);
             }
 
             if i > 0 {
@@ -966,7 +1235,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
                 self.regions.size.y -= height;
                 if self.root && movable {
                     let mut notes = Vec::new();
-                    collect_footnotes(&mut notes, frame);
+                    self.collect_footnotes(&mut notes, frame);
                     self.items.push(item);
 
                     // When we are already in_last, we can directly force the
@@ -1024,7 +1293,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
                 // Find footnotes in the frame.
                 if self.root {
                     let mut notes = vec![];
-                    collect_footnotes(&mut notes, frame);
+                    self.collect_footnotes(&mut notes, frame);
                     self.try_handle_footnotes(notes)?;
                 }
             }
@@ -1143,10 +1412,10 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
         }
 
         if !self.regions.size.x.is_finite() && self.expand.x {
-            bail!(self.flow.span(), "cannot expand into infinite width");
+            bail!(self.span, "cannot expand into infinite width");
         }
         if !self.regions.size.y.is_finite() && self.expand.y {
-            bail!(self.flow.span(), "cannot expand into infinite height");
+            bail!(self.span, "cannot expand into infinite height");
         }
 
         let mut output = Frame::soft(size);
@@ -1255,7 +1524,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
         }
 
         // Stitch together the column for each region.
-        let dir = TextElem::dir_in(*self.styles);
+        let dir = TextElem::dir_in(self.shared);
         let total = (self.finished.len() as f32 / self.columns as f32).ceil() as usize;
 
         let mut collected = vec![];
@@ -1342,7 +1611,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
                 self.engine,
                 &FootnoteEntry::new(notes[k].clone()).pack(),
                 Locator::synthesize(notes[k].location().unwrap()),
-                *self.styles,
+                self.shared,
                 self.regions.with_root(false),
             )?
             .into_frames();
@@ -1363,7 +1632,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
 
             let prev = notes.len();
             for (i, frame) in frames.into_iter().enumerate() {
-                collect_footnotes(notes, &frame);
+                self.collect_footnotes(notes, &frame);
                 if i > 0 {
                     self.finish_region(false)?;
                     self.layout_footnote_separator()?;
@@ -1394,7 +1663,7 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
 
         // FIXME: Shouldn't use `root()` here.
         let mut frame =
-            layout_frame(self.engine, separator, Locator::root(), *self.styles, pod)?;
+            layout_frame(self.engine, separator, Locator::root(), self.shared, pod)?;
         frame.size_mut().y += self.footnote_config.clearance;
         frame.translate(Point::with_y(self.footnote_config.clearance));
 
@@ -1404,22 +1673,26 @@ impl<'a, 'e> FlowLayouter<'a, 'e> {
 
         Ok(())
     }
-}
 
-/// Collect all footnotes in a frame.
-fn collect_footnotes(notes: &mut Vec<Packed<FootnoteElem>>, frame: &Frame) {
-    for (_, item) in frame.items() {
-        match item {
-            FrameItem::Group(group) => collect_footnotes(notes, &group.frame),
-            FrameItem::Tag(tag)
-                if !notes.iter().any(|note| note.location() == tag.elem.location()) =>
-            {
-                let Some(footnote) = tag.elem.to_packed::<FootnoteElem>() else {
-                    continue;
-                };
-                notes.push(footnote.clone());
+    /// Collect all footnotes in a frame.
+    fn collect_footnotes(
+        &mut self,
+        notes: &mut Vec<Packed<FootnoteElem>>,
+        frame: &Frame,
+    ) {
+        for (_, item) in frame.items() {
+            match item {
+                FrameItem::Group(group) => self.collect_footnotes(notes, &group.frame),
+                FrameItem::Tag(tag) => {
+                    let Some(footnote) = tag.elem().to_packed::<FootnoteElem>() else {
+                        continue;
+                    };
+                    if self.visited_footnotes.insert(tag.location()) {
+                        notes.push(footnote.clone());
+                    }
+                }
+                _ => {}
             }
-            _ => {}
         }
     }
 }
diff --git a/crates/typst/src/layout/inline/collect.rs b/crates/typst/src/layout/inline/collect.rs
index 5021dc555..53c684d15 100644
--- a/crates/typst/src/layout/inline/collect.rs
+++ b/crates/typst/src/layout/inline/collect.rs
@@ -125,7 +125,7 @@ pub fn collect<'a>(
     consecutive: bool,
 ) -> SourceResult<(String, Vec<Segment<'a>>, SpanMapper)> {
     let mut collector = Collector::new(2 + children.len());
-    let mut iter = children.chain(styles).peekable();
+    let mut iter = children.iter(styles).peekable();
     let mut locator = locator.split();
 
     let outer_dir = TextElem::dir_in(*styles);
diff --git a/crates/typst/src/layout/inline/mod.rs b/crates/typst/src/layout/inline/mod.rs
index 44b6ee3c2..192b37e9d 100644
--- a/crates/typst/src/layout/inline/mod.rs
+++ b/crates/typst/src/layout/inline/mod.rs
@@ -18,11 +18,10 @@ use self::shaping::{
 };
 use crate::diag::SourceResult;
 use crate::engine::{Engine, Route, Sink, Traced};
-use crate::foundations::StyleChain;
+use crate::foundations::{StyleChain, StyleVec};
 use crate::introspection::{Introspector, Locator, LocatorLink};
 use crate::layout::{Fragment, Size};
 use crate::model::ParElem;
-use crate::realize::StyleVec;
 use crate::World;
 
 /// Range of a substring of text.
diff --git a/crates/typst/src/layout/page.rs b/crates/typst/src/layout/page.rs
index f52f59e94..3d94ab79d 100644
--- a/crates/typst/src/layout/page.rs
+++ b/crates/typst/src/layout/page.rs
@@ -8,15 +8,16 @@ use comemo::Track;
 use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, AutoValue, Cast, Content, Context, Dict, Fold, Func, Smart, StyleChain,
-    Value,
+    cast, elem, Args, AutoValue, Cast, Construct, Content, Context, Dict, Fold, Func,
+    NativeElement, Packed, Set, Smart, StyleChain, Value,
 };
 use crate::layout::{
-    Abs, Alignment, Frame, HAlignment, Length, OuterVAlignment, Ratio, Rel, Sides,
-    SpecificAlignment,
+    Abs, Alignment, FlushElem, Frame, HAlignment, Length, OuterVAlignment, Ratio, Rel,
+    Sides, SpecificAlignment,
 };
 use crate::model::Numbering;
-use crate::utils::{NonZeroExt, Scalar};
+use crate::realize::{Behave, Behaviour};
+use crate::utils::{singleton, NonZeroExt, Scalar};
 use crate::visualize::{Color, Paint};
 
 /// Layouts its child onto one or multiple pages.
@@ -38,11 +39,12 @@ use crate::visualize::{Color, Paint};
 ///
 /// There you go, US friends!
 /// ```
-#[elem]
+#[elem(Construct)]
 pub struct PageElem {
     /// A standard paper size to set width and height.
     #[external]
     #[default(Paper::A4)]
+    #[ghost]
     pub paper: Paper,
 
     /// The width of the page.
@@ -64,6 +66,7 @@ pub struct PageElem {
             .or_else(|| paper.map(|paper| Smart::Custom(paper.width().into())))
     )]
     #[default(Smart::Custom(Paper::A4.width().into()))]
+    #[ghost]
     pub width: Smart<Length>,
 
     /// The height of the page.
@@ -78,6 +81,7 @@ pub struct PageElem {
             .or_else(|| paper.map(|paper| Smart::Custom(paper.height().into())))
     )]
     #[default(Smart::Custom(Paper::A4.height().into()))]
+    #[ghost]
     pub height: Smart<Length>,
 
     /// Whether the page is flipped into landscape orientation.
@@ -99,6 +103,7 @@ pub struct PageElem {
     /// +1 555 555 5555
     /// ```
     #[default(false)]
+    #[ghost]
     pub flipped: bool,
 
     /// The page's margins.
@@ -138,6 +143,7 @@ pub struct PageElem {
     /// )
     /// ```
     #[fold]
+    #[ghost]
     pub margin: Margin,
 
     /// On which side the pages will be bound.
@@ -149,6 +155,7 @@ pub struct PageElem {
     ///
     /// This affects the meaning of the `inside` and `outside` options for
     /// margins.
+    #[ghost]
     pub binding: Smart<Binding>,
 
     /// How many columns the page has.
@@ -169,6 +176,7 @@ pub struct PageElem {
     /// of a rapidly changing climate.
     /// ```
     #[default(NonZeroUsize::ONE)]
+    #[ghost]
     pub columns: NonZeroUsize,
 
     /// The page's background fill.
@@ -192,6 +200,7 @@ pub struct PageElem {
     /// *Dark mode enabled.*
     /// ```
     #[borrowed]
+    #[ghost]
     pub fill: Smart<Option<Paint>>,
 
     /// How to [number]($numbering) the pages.
@@ -209,6 +218,7 @@ pub struct PageElem {
     /// #lorem(48)
     /// ```
     #[borrowed]
+    #[ghost]
     pub numbering: Option<Numbering>,
 
     /// The alignment of the page numbering.
@@ -228,6 +238,7 @@ pub struct PageElem {
     /// #lorem(30)
     /// ```
     #[default(SpecificAlignment::Both(HAlignment::Center, OuterVAlignment::Bottom))]
+    #[ghost]
     pub number_align: SpecificAlignment<HAlignment, OuterVAlignment>,
 
     /// The page's header. Fills the top margin of each page.
@@ -251,11 +262,13 @@ pub struct PageElem {
     /// #lorem(19)
     /// ```
     #[borrowed]
+    #[ghost]
     pub header: Smart<Option<Content>>,
 
     /// The amount the header is raised into the top margin.
     #[resolve]
     #[default(Ratio::new(0.3).into())]
+    #[ghost]
     pub header_ascent: Rel<Length>,
 
     /// The page's footer. Fills the bottom margin of each page.
@@ -287,11 +300,13 @@ pub struct PageElem {
     /// #lorem(48)
     /// ```
     #[borrowed]
+    #[ghost]
     pub footer: Smart<Option<Content>>,
 
     /// The amount the footer is lowered into the bottom margin.
     #[resolve]
     #[default(Ratio::new(0.3).into())]
+    #[ghost]
     pub footer_descent: Rel<Length>,
 
     /// Content in the page's background.
@@ -311,6 +326,7 @@ pub struct PageElem {
     /// over the world (of typesetting).
     /// ```
     #[borrowed]
+    #[ghost]
     pub background: Option<Content>,
 
     /// Content in the page's foreground.
@@ -325,6 +341,7 @@ pub struct PageElem {
     /// not understand our approach...
     /// ```
     #[borrowed]
+    #[ghost]
     pub foreground: Option<Content>,
 
     /// The contents of the page(s).
@@ -332,13 +349,93 @@ pub struct PageElem {
     /// Multiple pages will be created if the content does not fit on a single
     /// page. A new page with the page properties prior to the function invocation
     /// will be created after the body has been typeset.
+    #[external]
     #[required]
     pub body: Content,
+}
 
-    /// Whether the page should be aligned to an even or odd page.
+impl Construct for PageElem {
+    fn construct(engine: &mut Engine, args: &mut Args) -> SourceResult<Content> {
+        // The page constructor is special: It doesn't create a page element.
+        // Instead, it just ensures that the passed content lives in a separate
+        // page and styles it.
+        let styles = Self::set(engine, args)?;
+        let body = args.expect::<Content>("body")?;
+        Ok(Content::sequence([
+            PagebreakElem::shared_weak().clone(),
+            // We put an effectless, invisible non-tag element on the page.
+            // This has two desirable consequences:
+            // - The page is kept even if the body is empty
+            // - The page doesn't inherit shared styles from the body
+            FlushElem::new().pack(),
+            body,
+            PagebreakElem::shared_boundary().clone(),
+        ])
+        .styled_with_map(styles))
+    }
+}
+
+/// A manual page break.
+///
+/// Must not be used inside any containers.
+///
+/// # Example
+/// ```example
+/// The next page contains
+/// more details on compound theory.
+/// #pagebreak()
+///
+/// == Compound Theory
+/// In 1984, the first ...
+/// ```
+#[elem(title = "Page Break", Behave)]
+pub struct PagebreakElem {
+    /// If `{true}`, the page break is skipped if the current page is already
+    /// empty.
+    #[default(false)]
+    pub weak: bool,
+
+    /// If given, ensures that the next page will be an even/odd page, with an
+    /// empty page in between if necessary.
+    ///
+    /// ```example
+    /// #set page(height: 30pt)
+    ///
+    /// First.
+    /// #pagebreak(to: "odd")
+    /// Third.
+    /// ```
+    pub to: Option<Parity>,
+
+    /// Whether this pagebreak designates an end boundary of a page run. This is
+    /// an even weaker version of pagebreak `weak` because it not only doesn't
+    /// force an empty page, but also doesn't force its initial styles onto a
+    /// staged empty page.
     #[internal]
-    #[synthesized]
-    pub clear_to: Option<Parity>,
+    #[parse(None)]
+    #[default(false)]
+    pub boundary: bool,
+}
+
+impl Behave for Packed<PagebreakElem> {
+    fn behaviour(&self) -> Behaviour {
+        Behaviour::Destructive
+    }
+}
+
+impl PagebreakElem {
+    /// Get the globally shared weak pagebreak element.
+    pub fn shared_weak() -> &'static Content {
+        singleton!(Content, PagebreakElem::new().with_weak(true).pack())
+    }
+
+    /// Get the globally shared boundary pagebreak element.
+    pub fn shared_boundary() -> &'static Content {
+        singleton!(
+            Content,
+            PagebreakElem::new().with_weak(true).with_boundary(true).pack()
+        )
+    }
 }
 
 /// A finished page.
@@ -598,39 +695,6 @@ impl PageRanges {
     }
 }
 
-/// A manual page break.
-///
-/// Must not be used inside any containers.
-///
-/// # Example
-/// ```example
-/// The next page contains
-/// more details on compound theory.
-/// #pagebreak()
-///
-/// == Compound Theory
-/// In 1984, the first ...
-/// ```
-#[elem(title = "Page Break")]
-pub struct PagebreakElem {
-    /// If `{true}`, the page break is skipped if the current page is already
-    /// empty.
-    #[default(false)]
-    pub weak: bool,
-
-    /// If given, ensures that the next page will be an even/odd page, with an
-    /// empty page in between if necessary.
-    ///
-    /// ```example
-    /// #set page(height: 30pt)
-    ///
-    /// First.
-    /// #pagebreak(to: "odd")
-    /// Third.
-    /// ```
-    pub to: Option<Parity>,
-}
-
 /// Whether something should be even or odd.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
 pub enum Parity {
diff --git a/crates/typst/src/layout/place.rs b/crates/typst/src/layout/place.rs
index 51a1f5bf9..75a13fefb 100644
--- a/crates/typst/src/layout/place.rs
+++ b/crates/typst/src/layout/place.rs
@@ -177,7 +177,7 @@ pub struct FlushElem {}
 
 impl Behave for Packed<FlushElem> {
     fn behaviour(&self) -> Behaviour {
-        Behaviour::Invisible
+        Behaviour::Ignorant
     }
 }
 
diff --git a/crates/typst/src/math/ctx.rs b/crates/typst/src/math/ctx.rs
index 0eb97f9ce..06e352572 100644
--- a/crates/typst/src/math/ctx.rs
+++ b/crates/typst/src/math/ctx.rs
@@ -11,14 +11,13 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
-use crate::foundations::{Content, Packed, StyleChain};
+use crate::foundations::{Content, Packed, StyleChain, StyleVec};
 use crate::introspection::{Locator, SplitLocator};
 use crate::layout::{layout_frame, Abs, Axes, BoxElem, Em, Frame, Region, Size};
 use crate::math::{
     scaled_font_size, styled_char, EquationElem, FrameFragment, GlyphFragment,
     LayoutMath, MathFragment, MathRun, MathSize, THICK,
 };
-use crate::realize::StyleVec;
 use crate::syntax::{is_newline, Span};
 use crate::text::{
     features, BottomEdge, BottomEdgeMetric, Font, TextElem, TextSize, TopEdge,
diff --git a/crates/typst/src/math/fragment.rs b/crates/typst/src/math/fragment.rs
index 2adf2d9d0..959e4c8f4 100644
--- a/crates/typst/src/math/fragment.rs
+++ b/crates/typst/src/math/fragment.rs
@@ -6,6 +6,7 @@ use ttf_parser::{GlyphId, Rect};
 use unicode_math_class::MathClass;
 
 use crate::foundations::StyleChain;
+use crate::introspection::Tag;
 use crate::layout::{
     Abs, Corner, Em, Frame, FrameItem, HideElem, Point, Size, VAlignment,
 };
@@ -26,6 +27,7 @@ pub enum MathFragment {
     Space(Abs),
     Linebreak,
     Align,
+    Tag(Tag),
 }
 
 impl MathFragment {
@@ -74,6 +76,7 @@ impl MathFragment {
     pub fn is_ignorant(&self) -> bool {
         match self {
             Self::Frame(fragment) => fragment.ignorant,
+            Self::Tag(_) => true,
             _ => false,
         }
     }
@@ -87,6 +90,7 @@ impl MathFragment {
             Self::Space(_) => MathClass::Space,
             Self::Linebreak => MathClass::Space,
             Self::Align => MathClass::Special,
+            Self::Tag(_) => MathClass::Special,
         }
     }
 
@@ -172,6 +176,11 @@ impl MathFragment {
             Self::Glyph(glyph) => glyph.into_frame(),
             Self::Variant(variant) => variant.frame,
             Self::Frame(fragment) => fragment.frame,
+            Self::Tag(tag) => {
+                let mut frame = Frame::soft(Size::zero());
+                frame.push(Point::zero(), FrameItem::Tag(tag));
+                frame
+            }
             _ => Frame::soft(self.size()),
         }
     }
diff --git a/crates/typst/src/math/mod.rs b/crates/typst/src/math/mod.rs
index 6cf22edbc..383631a45 100644
--- a/crates/typst/src/math/mod.rs
+++ b/crates/typst/src/math/mod.rs
@@ -47,10 +47,9 @@ use crate::foundations::{
     category, Category, Content, Module, Resolve, Scope, SequenceElem, StyleChain,
     StyledElem,
 };
-use crate::introspection::TagElem;
-use crate::layout::{BoxElem, Frame, FrameItem, HElem, Point, Size, Spacing, VAlignment};
-use crate::realize::Behaviour;
-use crate::realize::{process, BehavedBuilder};
+use crate::introspection::{TagElem, TagKind};
+use crate::layout::{BoxElem, HElem, Spacing, VAlignment};
+use crate::realize::{process, BehavedBuilder, Behaviour};
 use crate::text::{LinebreakElem, SpaceElem, TextElem};
 
 /// Typst has special [syntax]($syntax/#math) and library functions to typeset
@@ -237,8 +236,17 @@ impl LayoutMath for Content {
             return elem.layout_math(ctx, styles);
         }
 
-        if let Some(realized) = process(ctx.engine, &mut ctx.locator, self, styles)? {
-            return realized.layout_math(ctx, styles);
+        if let Some((tag, realized)) =
+            process(ctx.engine, &mut ctx.locator, self, styles)?
+        {
+            if let Some(tag) = &tag {
+                ctx.push(MathFragment::Tag(tag.clone()));
+            }
+            realized.layout_math(ctx, styles)?;
+            if let Some(tag) = tag {
+                ctx.push(MathFragment::Tag(tag.with_kind(TagKind::End)));
+            }
+            return Ok(());
         }
 
         if self.is::<SequenceElem>() {
@@ -302,9 +310,7 @@ impl LayoutMath for Content {
         }
 
         if let Some(elem) = self.to_packed::<TagElem>() {
-            let mut frame = Frame::soft(Size::zero());
-            frame.push(Point::zero(), FrameItem::Tag(elem.tag.clone()));
-            ctx.push(FrameFragment::new(ctx, styles, frame).with_ignorant(true));
+            ctx.push(MathFragment::Tag(elem.tag.clone()));
             return Ok(());
         }
 
@@ -321,10 +327,7 @@ impl LayoutMath for Content {
         ctx.push(
             FrameFragment::new(ctx, styles, frame)
                 .with_spaced(true)
-                .with_ignorant(matches!(
-                    self.behaviour(),
-                    Behaviour::Invisible | Behaviour::Ignorant
-                )),
+                .with_ignorant(self.behaviour() == Behaviour::Ignorant),
         );
 
         Ok(())
diff --git a/crates/typst/src/model/par.rs b/crates/typst/src/model/par.rs
index 25e563325..7867c89da 100644
--- a/crates/typst/src/model/par.rs
+++ b/crates/typst/src/model/par.rs
@@ -3,10 +3,10 @@ use std::fmt::{self, Debug, Formatter};
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Args, Cast, Construct, Content, NativeElement, Packed, Set, Smart, Unlabellable,
+    elem, Args, Cast, Construct, Content, NativeElement, Packed, Set, Smart, StyleVec,
+    Unlabellable,
 };
 use crate::layout::{Em, Length};
-use crate::realize::StyleVec;
 use crate::utils::singleton;
 
 /// Arranges text, spacing and inline-level elements into a paragraph.
diff --git a/crates/typst/src/realize/arenas.rs b/crates/typst/src/realize/arenas.rs
index 9c90091c5..61b198589 100644
--- a/crates/typst/src/realize/arenas.rs
+++ b/crates/typst/src/realize/arenas.rs
@@ -1,12 +1,13 @@
 use typed_arena::Arena;
 
-use crate::foundations::{Content, StyleChain};
+use crate::foundations::{Content, StyleChain, Styles};
 
 /// Temporary storage arenas for building.
 #[derive(Default)]
 pub struct Arenas<'a> {
     chains: Arena<StyleChain<'a>>,
     content: Arena<Content>,
+    styles: Arena<Styles>,
 }
 
 impl<'a> Arenas<'a> {
@@ -32,3 +33,9 @@ impl<'a> Store<'a> for StyleChain<'a> {
         arenas.chains.alloc(self)
     }
 }
+
+impl<'a> Store<'a> for Styles {
+    fn store(self, arenas: &'a Arenas<'a>) -> &'a Self {
+        arenas.styles.alloc(self)
+    }
+}
diff --git a/crates/typst/src/realize/behaviour.rs b/crates/typst/src/realize/behaviour.rs
index 588e221f4..15a0a2848 100644
--- a/crates/typst/src/realize/behaviour.rs
+++ b/crates/typst/src/realize/behaviour.rs
@@ -1,10 +1,6 @@
 //! Element interaction.
 
-use std::fmt::{Debug, Formatter};
-
-use ecow::EcoVec;
-
-use crate::foundations::{Content, StyleChain, Styles};
+use crate::foundations::{Content, StyleChain};
 
 /// How an element interacts with other elements in a stream.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -19,12 +15,8 @@ pub enum Behaviour {
     /// An element that destroys adjacent weak elements.
     Destructive,
     /// An element that does not interact at all with other elements, having the
-    /// same effect as if it didn't exist, but has layout extent and/or a visual
-    /// representation.
+    /// same effect on them as if it didn't exist.
     Ignorant,
-    /// An element that does not have any layout extent or visual
-    /// representation.
-    Invisible,
 }
 
 impl Behaviour {
@@ -69,15 +61,6 @@ impl<'a> BehavedBuilder<'a> {
         self.buf.is_empty()
     }
 
-    /// Whether the builder has any proper (non-weak & visible) elements.
-    pub fn has_strong_elements(&self, last: bool) -> bool {
-        self.buf.iter().any(|(content, _)| {
-            let behaviour = content.behaviour();
-            !matches!(behaviour, Behaviour::Weak(_) | Behaviour::Invisible)
-                || (last && behaviour == Behaviour::Invisible)
-        })
-    }
-
     /// Push an item into the builder.
     pub fn push(&mut self, content: &'a Content, styles: StyleChain<'a>) {
         let mut behaviour = content.behaviour();
@@ -112,7 +95,7 @@ impl<'a> BehavedBuilder<'a> {
                     self.buf.remove(i);
                 }
             }
-            Behaviour::Ignorant | Behaviour::Invisible => {
+            Behaviour::Ignorant => {
                 behaviour = self.last;
             }
         }
@@ -152,162 +135,3 @@ impl<'a> Default for BehavedBuilder<'a> {
         Self::new()
     }
 }
-
-/// A sequence of elements with associated styles.
-#[derive(Clone, PartialEq, Hash)]
-pub struct StyleVec {
-    /// The elements themselves.
-    elements: EcoVec<Content>,
-    /// A run-length encoded list of style lists.
-    ///
-    /// Each element is a (styles, count) pair. Any elements whose
-    /// style falls after the end of this list is considered to
-    /// have an empty style list.
-    styles: EcoVec<(Styles, usize)>,
-}
-
-impl StyleVec {
-    /// Create a style vector from an unstyled vector content.
-    pub fn wrap(elements: EcoVec<Content>) -> Self {
-        Self { elements, styles: EcoVec::new() }
-    }
-
-    /// Create a `StyleVec` from a list of content with style chains.
-    pub fn create<'a>(buf: &[(&Content, StyleChain<'a>)]) -> (Self, StyleChain<'a>) {
-        let (trunk, depth) = determine_style_trunk(buf);
-
-        let mut elements = EcoVec::with_capacity(buf.len());
-        let mut styles = EcoVec::<(Styles, usize)>::new();
-        let mut last: Option<(StyleChain<'a>, usize)> = None;
-
-        for &(element, chain) in buf {
-            elements.push(element.clone());
-
-            if let Some((prev, run)) = &mut last {
-                if chain == *prev {
-                    *run += 1;
-                } else {
-                    styles.push((prev.suffix(depth), *run));
-                    last = Some((chain, 1));
-                }
-            } else {
-                last = Some((chain, 1));
-            }
-        }
-
-        if let Some((last, run)) = last {
-            let skippable = styles.is_empty() && last == trunk;
-            if !skippable {
-                styles.push((last.suffix(depth), run));
-            }
-        }
-
-        (StyleVec { elements, styles }, trunk)
-    }
-
-    /// Whether there are no elements.
-    pub fn is_empty(&self) -> bool {
-        self.elements.is_empty()
-    }
-
-    /// The number of elements.
-    pub fn len(&self) -> usize {
-        self.elements.len()
-    }
-
-    /// The raw, unstyled elements.
-    pub fn elements(&self) -> &[Content] {
-        &self.elements
-    }
-
-    /// Get a style property, but only if it is the same for all children of the
-    /// style vector.
-    pub fn shared_get<T: PartialEq>(
-        &self,
-        styles: StyleChain<'_>,
-        getter: fn(StyleChain) -> T,
-    ) -> Option<T> {
-        let value = getter(styles);
-        self.styles
-            .iter()
-            .all(|(local, _)| getter(styles.chain(local)) == value)
-            .then_some(value)
-    }
-
-    /// Iterate over the contained content and style chains.
-    pub fn chain<'a>(
-        &'a self,
-        outer: &'a StyleChain<'_>,
-    ) -> impl Iterator<Item = (&'a Content, StyleChain<'a>)> {
-        self.iter().map(|(element, local)| (element, outer.chain(local)))
-    }
-
-    /// Iterate over pairs of content and styles.
-    pub fn iter(&self) -> impl Iterator<Item = (&Content, &Styles)> {
-        static EMPTY: Styles = Styles::new();
-        self.elements.iter().zip(
-            self.styles
-                .iter()
-                .flat_map(|(local, count)| std::iter::repeat(local).take(*count))
-                .chain(std::iter::repeat(&EMPTY)),
-        )
-    }
-
-    /// Iterate over pairs of content and styles.
-    #[allow(clippy::should_implement_trait)]
-    pub fn into_iter(self) -> impl Iterator<Item = (Content, Styles)> {
-        self.elements.into_iter().zip(
-            self.styles
-                .into_iter()
-                .flat_map(|(local, count)| std::iter::repeat(local).take(count))
-                .chain(std::iter::repeat(Styles::new())),
-        )
-    }
-}
-
-impl Debug for StyleVec {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        f.debug_list()
-            .entries(self.iter().map(|(element, local)| {
-                typst_utils::debug(|f| {
-                    for style in local.iter() {
-                        writeln!(f, "#{style:?}")?;
-                    }
-                    element.fmt(f)
-                })
-            }))
-            .finish()
-    }
-}
-
-/// Determine the shared trunk style chain.
-fn determine_style_trunk<'a, T>(buf: &[(T, StyleChain<'a>)]) -> (StyleChain<'a>, usize) {
-    // Determine shared style depth and first span.
-    let mut trunk = match buf.first() {
-        Some(&(_, chain)) => chain,
-        None => Default::default(),
-    };
-
-    let mut depth = trunk.links().count();
-    for (_, mut chain) in buf {
-        let len = chain.links().count();
-        if len < depth {
-            for _ in 0..depth - len {
-                trunk.pop();
-            }
-            depth = len;
-        } else if len > depth {
-            for _ in 0..len - depth {
-                chain.pop();
-            }
-        }
-
-        while depth > 0 && chain != trunk {
-            trunk.pop();
-            chain.pop();
-            depth -= 1;
-        }
-    }
-
-    (trunk, depth)
-}
diff --git a/crates/typst/src/realize/mod.rs b/crates/typst/src/realize/mod.rs
index fa7019e0b..5f89e51d3 100644
--- a/crates/typst/src/realize/mod.rs
+++ b/crates/typst/src/realize/mod.rs
@@ -1,10 +1,7 @@
 //! Realization of content.
 //!
-//! *Realization* is the process of applying show rules to produce
-//! something that can be laid out directly.
-//!
-//! Currently, there are issues with the realization process, and
-//! it is subject to changes in the future.
+//! *Realization* is the process of recursively applying styling and, in
+//! particular, show rules to produce well-known elements that can be laid out.
 
 mod arenas;
 mod behaviour;
@@ -13,7 +10,7 @@ mod process;
 use once_cell::unsync::Lazy;
 
 pub use self::arenas::Arenas;
-pub use self::behaviour::{Behave, BehavedBuilder, Behaviour, StyleVec};
+pub use self::behaviour::{Behave, BehavedBuilder, Behaviour};
 pub use self::process::process;
 
 use std::mem;
@@ -21,12 +18,13 @@ use std::mem;
 use crate::diag::{bail, SourceResult};
 use crate::engine::{Engine, Route};
 use crate::foundations::{
-    Content, NativeElement, Packed, SequenceElem, Smart, StyleChain, StyledElem, Styles,
+    Content, ContextElem, NativeElement, Packed, SequenceElem, Smart, StyleChain,
+    StyleVec, StyledElem, Styles,
 };
-use crate::introspection::{SplitLocator, TagElem};
+use crate::introspection::{SplitLocator, TagElem, TagKind};
 use crate::layout::{
-    AlignElem, BlockElem, BoxElem, ColbreakElem, FlowElem, FlushElem, HElem, InlineElem,
-    PageElem, PagebreakElem, Parity, PlaceElem, VElem,
+    AlignElem, BlockElem, BoxElem, ColbreakElem, FlushElem, HElem, InlineElem, PageElem,
+    PagebreakElem, PlaceElem, VElem,
 };
 use crate::math::{EquationElem, LayoutMath};
 use crate::model::{
@@ -35,41 +33,42 @@ use crate::model::{
 };
 use crate::syntax::Span;
 use crate::text::{LinebreakElem, SmartQuoteElem, SpaceElem, TextElem};
+use crate::utils::SliceExt;
 
 /// A pair of content and a style chain that applies to it.
-type Pair<'a> = (&'a Content, StyleChain<'a>);
+pub type Pair<'a> = (&'a Content, StyleChain<'a>);
 
-/// Realize at the root-level.
-#[typst_macros::time(name = "realize root")]
+/// Realize at the root level.
+#[typst_macros::time(name = "realize")]
 pub fn realize_root<'a>(
     engine: &mut Engine<'a>,
     locator: &mut SplitLocator<'a>,
     arenas: &'a Arenas<'a>,
     content: &'a Content,
     styles: StyleChain<'a>,
-) -> SourceResult<(StyleVec, StyleChain<'a>, DocumentInfo)> {
+) -> SourceResult<(Vec<Pair<'a>>, DocumentInfo)> {
     let mut builder = Builder::new(engine, locator, arenas, true);
     builder.accept(content, styles)?;
-    builder.interrupt_page(Some(styles), true)?;
-    Ok(builder.doc.unwrap().finish())
+    builder.interrupt_par()?;
+    Ok((builder.sink.finish(), builder.doc_info.unwrap()))
 }
 
-/// Realize into a `FlowElem`, an element that is capable of block-level layout.
-#[typst_macros::time(name = "realize flow")]
-pub fn realize_flow<'a>(
+/// Realize at the container level.
+#[typst_macros::time(name = "realize")]
+pub fn realizer_container<'a>(
     engine: &mut Engine<'a>,
     locator: &mut SplitLocator<'a>,
     arenas: &'a Arenas<'a>,
     content: &'a Content,
     styles: StyleChain<'a>,
-) -> SourceResult<(Packed<FlowElem>, StyleChain<'a>)> {
+) -> SourceResult<Vec<Pair<'a>>> {
     let mut builder = Builder::new(engine, locator, arenas, false);
     builder.accept(content, styles)?;
     builder.interrupt_par()?;
-    Ok(builder.flow.finish())
+    Ok(builder.sink.finish())
 }
 
-/// Builds a document or a flow element from content.
+/// Realizes content into a flat list of well-known, styled elements.
 struct Builder<'a, 'v> {
     /// The engine.
     engine: &'v mut Engine<'a>,
@@ -77,34 +76,47 @@ struct Builder<'a, 'v> {
     locator: &'v mut SplitLocator<'a>,
     /// Scratch arenas for building.
     arenas: &'a Arenas<'a>,
-    /// The current document building state.
-    doc: Option<DocBuilder<'a>>,
-    /// The current flow building state.
-    flow: FlowBuilder<'a>,
-    /// The current paragraph building state.
+
+    /// The output elements of well-known types collected by the builder.
+    sink: BehavedBuilder<'a>,
+    /// Document metadata we have collected from `set document` rules. If this
+    /// is `None`, we are in a container.
+    doc_info: Option<DocumentInfo>,
+
+    /// A builder for a paragraph that might be under construction.
     par: ParBuilder<'a>,
-    /// The current list building state.
+    /// A builder for a list that might be under construction.
     list: ListBuilder<'a>,
-    /// The current citation grouping state.
+    /// A builder for a citation group that might be under construction.
     cites: CiteGroupBuilder<'a>,
+
+    /// Whether we are currently not within any container or show rule output.
+    /// This is used to determine page styles during layout.
+    outside: bool,
+    /// Whether the last item that we visited was a paragraph (with no parbreak
+    /// in between). This is used for attach spacing.
+    last_was_par: bool,
 }
 
 impl<'a, 'v> Builder<'a, 'v> {
+    /// Creates a new builder.
     fn new(
         engine: &'v mut Engine<'a>,
         locator: &'v mut SplitLocator<'a>,
         arenas: &'a Arenas<'a>,
-        top: bool,
+        root: bool,
     ) -> Self {
         Self {
             engine,
             locator,
             arenas,
-            doc: top.then(DocBuilder::default),
-            flow: FlowBuilder::default(),
+            sink: BehavedBuilder::default(),
+            doc_info: root.then(DocumentInfo::default),
             par: ParBuilder::default(),
             list: ListBuilder::default(),
             cites: CiteGroupBuilder::default(),
+            outside: root,
+            last_was_par: false,
         }
     }
 
@@ -123,7 +135,9 @@ impl<'a, 'v> Builder<'a, 'v> {
 
         // Styled elements and sequences can (at least currently) also have
         // labels, so this needs to happen before they are handled.
-        if let Some(realized) = process(self.engine, self.locator, content, styles)? {
+        if let Some((tag, realized)) =
+            process(self.engine, self.locator, content, styles)?
+        {
             self.engine.route.increase();
             if !self.engine.route.within(Route::MAX_SHOW_RULE_DEPTH) {
                 bail!(
@@ -131,9 +145,23 @@ impl<'a, 'v> Builder<'a, 'v> {
                     hint: "check whether the show rule matches its own output"
                 );
             }
-            let result = self.accept(self.arenas.store(realized), styles);
+
+            if let Some(tag) = &tag {
+                self.accept(self.arenas.store(TagElem::packed(tag.clone())), styles)?;
+            }
+
+            let prev_outside = self.outside;
+            self.outside &= content.is::<ContextElem>();
+            self.accept(self.arenas.store(realized), styles)?;
+            self.outside = prev_outside;
+
+            if let Some(tag) = tag {
+                let end = tag.with_kind(TagKind::End);
+                self.accept(self.arenas.store(TagElem::packed(end)), styles)?;
+            }
+
             self.engine.route.decrease();
-            return result;
+            return Ok(());
         }
 
         if let Some(styled) = content.to_packed::<StyledElem>() {
@@ -148,6 +176,7 @@ impl<'a, 'v> Builder<'a, 'v> {
         }
 
         // Try to merge `content` with an element under construction
+        // (cite group, list, or par).
 
         if self.cites.accept(content, styles) {
             return Ok(());
@@ -161,6 +190,7 @@ impl<'a, 'v> Builder<'a, 'v> {
 
         self.interrupt_list()?;
 
+        // Try again because it could be another kind of list.
         if self.list.accept(content, styles) {
             return Ok(());
         }
@@ -171,285 +201,165 @@ impl<'a, 'v> Builder<'a, 'v> {
 
         self.interrupt_par()?;
 
-        if self.flow.accept(self.arenas, content, styles) {
-            return Ok(());
-        }
+        self.save(content, styles)
+    }
 
-        let keep = content
-            .to_packed::<PagebreakElem>()
-            .is_some_and(|pagebreak| !pagebreak.weak(styles));
+    /// Tries to save a piece of content into the sink.
+    fn save(&mut self, content: &'a Content, styles: StyleChain<'a>) -> SourceResult<()> {
+        let last_was_par = std::mem::replace(&mut self.last_was_par, false);
+        let par_spacing = Lazy::new(|| {
+            self.arenas
+                .store(VElem::par_spacing(ParElem::spacing_in(styles).into()).pack())
+        });
 
-        self.interrupt_page(keep.then_some(styles), false)?;
-
-        if let Some(doc) = &mut self.doc {
-            if doc.accept(self.arenas, content, styles) {
-                return Ok(());
+        if content.is::<TagElem>()
+            || content.is::<PlaceElem>()
+            || content.is::<FlushElem>()
+            || content.is::<ColbreakElem>()
+        {
+            self.sink.push(content, styles);
+        } else if content.is::<PagebreakElem>() {
+            if self.doc_info.is_none() {
+                bail!(content.span(), "pagebreaks are not allowed inside of containers");
             }
-        }
+            self.sink.push(content, styles);
+        } else if let Some(elem) = content.to_packed::<VElem>() {
+            if !elem.attach(styles) || last_was_par {
+                self.sink.push(content, styles);
+            }
+        } else if content.is::<ParbreakElem>() {
+            // It's only a boundary, so we can ignore it.
+        } else if content.is::<ParElem>() {
+            self.sink.push(*par_spacing, styles);
+            self.sink.push(content, styles);
+            self.sink.push(*par_spacing, styles);
+            self.last_was_par = true;
+        } else if let Some(elem) = content.to_packed::<BlockElem>() {
+            let above = match elem.above(styles) {
+                Smart::Auto => *par_spacing,
+                Smart::Custom(above) => {
+                    self.arenas.store(VElem::block_spacing(above).pack())
+                }
+            };
 
-        if content.is::<PagebreakElem>() {
-            bail!(content.span(), "pagebreaks are not allowed inside of containers");
+            let below = match elem.below(styles) {
+                Smart::Auto => *par_spacing,
+                Smart::Custom(below) => {
+                    self.arenas.store(VElem::block_spacing(below).pack())
+                }
+            };
+
+            self.sink.push(above, styles);
+            self.sink.push(content, styles);
+            self.sink.push(below, styles);
         } else {
             bail!(content.span(), "{} is not allowed here", content.func().name());
         }
+
+        Ok(())
     }
 
+    /// Handles a styled element.
     fn styled(
         &mut self,
         styled: &'a StyledElem,
         styles: StyleChain<'a>,
     ) -> SourceResult<()> {
-        let local = &styled.styles;
-        let stored = self.arenas.store(styles);
-        let styles = stored.chain(local);
-
-        if let Some(Some(span)) = local.interruption::<DocumentElem>() {
-            let Some(doc) = &mut self.doc else {
+        if let Some(span) = styled.styles.interruption::<DocumentElem>() {
+            let Some(info) = &mut self.doc_info else {
                 bail!(span, "document set rules are not allowed inside of containers");
             };
-            doc.info.populate(local);
+            info.populate(&styled.styles);
         }
 
-        self.interrupt_style(local, None)?;
-        self.accept(&styled.child, styles)?;
-        self.interrupt_style(local, Some(styles))?;
+        let page_interruption = styled.styles.interruption::<PageElem>();
+        if let Some(span) = page_interruption {
+            if self.doc_info.is_none() {
+                bail!(span, "page configuration is not allowed inside of containers");
+            }
+
+            // When there are page styles, we "break free" from our show rule
+            // cage.
+            self.outside = true;
+        }
+
+        // If we are not within a container or show rule, mark the styles as
+        // "outside". This will allow them to be lifted to the page level.
+        let outer = self.arenas.store(styles);
+        let local = if self.outside {
+            self.arenas.store(styled.styles.clone().outside())
+        } else {
+            &styled.styles
+        };
+
+        if page_interruption.is_some() {
+            // For the starting pagebreak we only want the styles before and
+            // including the interruptions, not trailing styles that happen to
+            // be in the same `Styles` list.
+            let relevant = local
+                .as_slice()
+                .trim_end_matches(|style| style.interruption::<PageElem>().is_none());
+            self.accept(PagebreakElem::shared_weak(), outer.chain(relevant))?;
+        }
+
+        self.interrupt_styles(local)?;
+        self.accept(&styled.child, outer.chain(local))?;
+        self.interrupt_styles(local)?;
+
+        if page_interruption.is_some() {
+            // For the ending pagebreak, the styles don't really matter because
+            // the styles of a "boundary" pagebreak are ignored during layout.
+            self.accept(PagebreakElem::shared_boundary(), *outer)?;
+        }
 
         Ok(())
     }
 
-    fn interrupt_style(
-        &mut self,
-        local: &Styles,
-        outer: Option<StyleChain<'a>>,
-    ) -> SourceResult<()> {
-        if let Some(Some(span)) = local.interruption::<PageElem>() {
-            if self.doc.is_none() {
-                bail!(span, "page configuration is not allowed inside of containers");
-            }
-            self.interrupt_page(outer, false)?;
-        }
+    /// Inspects the styles and dispatches to the different interruption
+    /// handlers.
+    fn interrupt_styles(&mut self, local: &Styles) -> SourceResult<()> {
         if local.interruption::<ParElem>().is_some()
             || local.interruption::<AlignElem>().is_some()
         {
             self.interrupt_par()?;
-        }
-        if local.interruption::<ListElem>().is_some()
+        } else if local.interruption::<ListElem>().is_some()
             || local.interruption::<EnumElem>().is_some()
             || local.interruption::<TermsElem>().is_some()
         {
             self.interrupt_list()?;
+        } else if local.interruption::<CiteElem>().is_some() {
+            self.interrupt_cites()?;
         }
         Ok(())
     }
 
-    /// Interrupts citation grouping and adds the resulting citation group to the builder.
-    fn interrupt_cites(&mut self) -> SourceResult<()> {
-        if !self.cites.items.is_empty() {
-            let staged = mem::take(&mut self.cites.staged);
-            let (group, styles) = mem::take(&mut self.cites).finish();
-            self.accept(self.arenas.store(group.pack()), styles)?;
-            for (content, styles) in staged {
-                self.accept(content, styles)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Interrupts list building and adds the resulting list element to the builder.
-    fn interrupt_list(&mut self) -> SourceResult<()> {
-        self.interrupt_cites()?;
-        if !self.list.items.is_empty() {
-            let staged = mem::take(&mut self.list.staged);
-            let (list, styles) = mem::take(&mut self.list).finish();
-            self.accept(self.arenas.store(list), styles)?;
-            for (content, styles) in staged {
-                self.accept(content, styles)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Interrupts paragraph building and adds the resulting paragraph element to the builder.
+    /// Interrupts paragraph building and adds the resulting paragraph element
+    /// to the builder.
     fn interrupt_par(&mut self) -> SourceResult<()> {
         self.interrupt_list()?;
         if !self.par.0.is_empty() {
-            let (par, styles) = mem::take(&mut self.par).finish();
-            self.accept(self.arenas.store(par.pack()), styles)?;
-        }
-
-        Ok(())
-    }
-
-    /// Interrupts page building and adds the resulting page element to the builder.
-    fn interrupt_page(
-        &mut self,
-        styles: Option<StyleChain<'a>>,
-        last: bool,
-    ) -> SourceResult<()> {
-        self.interrupt_par()?;
-        let Some(doc) = &mut self.doc else { return Ok(()) };
-        if (doc.keep_next && styles.is_some()) || self.flow.0.has_strong_elements(last) {
-            let (flow, trunk) = mem::take(&mut self.flow).finish();
-            let span = flow.span();
-            let styles = if trunk == StyleChain::default() {
-                styles.unwrap_or_default()
-            } else {
-                trunk
-            };
-            let page = PageElem::new(flow.pack()).pack().spanned(span);
-            self.accept(self.arenas.store(page), styles)?;
+            mem::take(&mut self.par).finish(self)?;
         }
         Ok(())
     }
-}
 
-/// Builds a [document][DocumentElem] from pagebreaks and pages.
-struct DocBuilder<'a> {
-    /// The page runs built so far.
-    pages: BehavedBuilder<'a>,
-    /// Whether to keep a following page even if it is empty.
-    keep_next: bool,
-    /// Whether the next page should be cleared to an even or odd number.
-    clear_next: Option<Parity>,
-    /// Details about the document.
-    info: DocumentInfo,
-}
-
-impl<'a> DocBuilder<'a> {
-    /// Tries to accept a piece of content.
-    ///
-    /// Returns true if this content could be merged into the document.
-    /// If this function returns false, then the
-    /// content could not be merged, and document building should be
-    /// interrupted so that the content can be added elsewhere.
-    fn accept(
-        &mut self,
-        arenas: &'a Arenas<'a>,
-        content: &'a Content,
-        styles: StyleChain<'a>,
-    ) -> bool {
-        if let Some(pagebreak) = content.to_packed::<PagebreakElem>() {
-            self.keep_next = !pagebreak.weak(styles);
-            self.clear_next = pagebreak.to(styles);
-            return true;
+    /// Interrupts list building and adds the resulting list element to the
+    /// builder.
+    fn interrupt_list(&mut self) -> SourceResult<()> {
+        self.interrupt_cites()?;
+        if !self.list.0.is_empty() {
+            mem::take(&mut self.list).finish(self)?;
         }
-
-        if let Some(page) = content.to_packed::<PageElem>() {
-            let elem = if let Some(clear_to) = self.clear_next.take() {
-                let mut page = page.clone();
-                page.push_clear_to(Some(clear_to));
-                arenas.store(page.pack())
-            } else {
-                content
-            };
-
-            self.pages.push(elem, styles);
-            self.keep_next = false;
-            return true;
-        }
-
-        false
+        Ok(())
     }
 
-    /// Turns this builder into the resulting page runs, along with
-    /// its [style chain][StyleChain].
-    fn finish(self) -> (StyleVec, StyleChain<'a>, DocumentInfo) {
-        let buf = self.pages.finish();
-        let (children, trunk) = StyleVec::create(&buf);
-        (children, trunk, self.info)
-    }
-}
-
-impl Default for DocBuilder<'_> {
-    fn default() -> Self {
-        Self {
-            pages: BehavedBuilder::new(),
-            keep_next: true,
-            clear_next: None,
-            info: DocumentInfo::default(),
+    /// Interrupts citation grouping and adds the resulting citation group to
+    /// the builder.
+    fn interrupt_cites(&mut self) -> SourceResult<()> {
+        if !self.cites.0.is_empty() {
+            mem::take(&mut self.cites).finish(self)?;
         }
-    }
-}
-
-/// Builds a [flow][FlowElem] from flow content.
-#[derive(Default)]
-struct FlowBuilder<'a>(BehavedBuilder<'a>, bool);
-
-impl<'a> FlowBuilder<'a> {
-    /// Tries to accept a piece of content.
-    ///
-    /// Returns true if this content could be merged into the flow.
-    /// If this function returns false, then the
-    /// content could not be merged, and flow building should be
-    /// interrupted so that the content can be added elsewhere.
-    fn accept(
-        &mut self,
-        arenas: &'a Arenas<'a>,
-        content: &'a Content,
-        styles: StyleChain<'a>,
-    ) -> bool {
-        let last_was_par = self.1;
-        self.1 = false;
-
-        if content.is::<ParbreakElem>() {
-            return true;
-        }
-
-        if let Some(elem) = content.to_packed::<VElem>() {
-            if !elem.attach(styles) || last_was_par {
-                self.0.push(content, styles);
-            }
-            return true;
-        }
-
-        if content.is::<ColbreakElem>()
-            || content.is::<TagElem>()
-            || content.is::<PlaceElem>()
-            || content.is::<FlushElem>()
-        {
-            self.0.push(content, styles);
-            return true;
-        }
-
-        let par_spacing = Lazy::new(|| {
-            arenas.store(VElem::par_spacing(ParElem::spacing_in(styles).into()).pack())
-        });
-
-        if let Some(elem) = content.to_packed::<BlockElem>() {
-            let above = match elem.above(styles) {
-                Smart::Auto => *par_spacing,
-                Smart::Custom(above) => arenas.store(VElem::block_spacing(above).pack()),
-            };
-
-            let below = match elem.below(styles) {
-                Smart::Auto => *par_spacing,
-                Smart::Custom(below) => arenas.store(VElem::block_spacing(below).pack()),
-            };
-
-            self.0.push(above, styles);
-            self.0.push(content, styles);
-            self.0.push(below, styles);
-            return true;
-        }
-
-        if content.is::<ParElem>() {
-            self.0.push(*par_spacing, styles);
-            self.0.push(content, styles);
-            self.0.push(*par_spacing, styles);
-            self.1 = true;
-            return true;
-        }
-
-        false
-    }
-
-    /// Turns this builder into the resulting flow, along with
-    /// its [style chain][StyleChain].
-    fn finish(self) -> (Packed<FlowElem>, StyleChain<'a>) {
-        let buf = self.0.finish();
-        let span = determine_span(&buf);
-        let (children, trunk) = StyleVec::create(&buf);
-        (Packed::new(FlowElem::new(children)).spanned(span), trunk)
+        Ok(())
     }
 }
 
@@ -460,24 +370,12 @@ struct ParBuilder<'a>(BehavedBuilder<'a>);
 impl<'a> ParBuilder<'a> {
     /// Tries to accept a piece of content.
     ///
-    /// Returns true if this content could be merged into the paragraph.
-    /// If this function returns false, then the
-    /// content could not be merged, and paragraph building should be
-    /// interrupted so that the content can be added elsewhere.
+    /// Returns true if this content could be merged into the paragraph. If this
+    /// function returns false, then the content could not be merged, and
+    /// paragraph building should be interrupted so that the content can be
+    /// added elsewhere.
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
-        if content.is::<TagElem>() {
-            if !self.0.is_empty() {
-                self.0.push(content, styles);
-                return true;
-            }
-        } else if content.is::<SpaceElem>()
-            || content.is::<TextElem>()
-            || content.is::<HElem>()
-            || content.is::<LinebreakElem>()
-            || content.is::<SmartQuoteElem>()
-            || content.is::<InlineElem>()
-            || content.is::<BoxElem>()
-        {
+        if Self::is_primary(content) || (!self.0.is_empty() && Self::is_inner(content)) {
             self.0.push(content, styles);
             return true;
         }
@@ -485,155 +383,203 @@ impl<'a> ParBuilder<'a> {
         false
     }
 
-    /// Turns this builder into the resulting paragraph, along with
+    /// Whether this content is of interest to the builder.
+    fn is_primary(content: &'a Content) -> bool {
+        content.is::<SpaceElem>()
+            || content.is::<TextElem>()
+            || content.is::<HElem>()
+            || content.is::<LinebreakElem>()
+            || content.is::<SmartQuoteElem>()
+            || content.is::<InlineElem>()
+            || content.is::<BoxElem>()
+    }
+
+    /// Whether this content can merely exist in between interesting items.
+    fn is_inner(content: &'a Content) -> bool {
+        content.is::<TagElem>()
+    }
+
+    /// Turns this builder into the resulting list, along with
     /// its [style chain][StyleChain].
-    fn finish(self) -> (Packed<ParElem>, StyleChain<'a>) {
+    fn finish(self, builder: &mut Builder<'a, '_>) -> SourceResult<()> {
         let buf = self.0.finish();
-        let span = determine_span(&buf);
-        let (children, trunk) = StyleVec::create(&buf);
-        (Packed::new(ParElem::new(children)).spanned(span), trunk)
+        let trimmed = buf.trim_end_matches(|(c, _)| c.is::<TagElem>());
+        let staged = &buf[trimmed.len()..];
+
+        let span = first_span(trimmed);
+        let (children, trunk) = StyleVec::create(trimmed);
+        let elem = Packed::new(ParElem::new(children)).spanned(span);
+        builder.accept(builder.arenas.store(elem.pack()), trunk)?;
+
+        for &(tag, styles) in staged {
+            builder.accept(tag, styles)?;
+        }
+
+        Ok(())
     }
 }
 
-/// Builds a list (either [`ListElem`], [`EnumElem`], or [`TermsElem`])
-/// from list or enum items, spaces, and paragraph breaks.
-struct ListBuilder<'a> {
-    /// The list items collected so far.
-    items: Vec<Pair<'a>>,
-    /// Trailing content for which it is unclear whether it is part of the list.
-    staged: Vec<Pair<'a>>,
-    /// Whether the list contains no paragraph breaks.
-    tight: bool,
-}
+/// Builds a list (either [`ListElem`], [`EnumElem`], or [`TermsElem`]) from
+/// list or enum items, spaces, and paragraph breaks.
+#[derive(Default)]
+struct ListBuilder<'a>(Vec<Pair<'a>>);
 
 impl<'a> ListBuilder<'a> {
     /// Tries to accept a piece of content.
     ///
-    /// Returns true if this content could be merged into the list.
-    /// If this function returns false, then the
-    /// content could not be merged, and list building should be
-    /// interrupted so that the content can be added elsewhere.
+    /// Returns true if this content could be merged into the list. If this
+    /// function returns false, then the content could not be merged, and list
+    /// building should be interrupted so that the content can be added
+    /// elsewhere.
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
-        if !self.items.is_empty()
-            && (content.is::<SpaceElem>() || content.is::<ParbreakElem>())
+        if (Self::is_primary(content) && self.is_compatible(content))
+            || (!self.0.is_empty() && Self::is_inner(content))
         {
-            self.staged.push((content, styles));
-            return true;
-        }
-
-        if (content.is::<ListItem>()
-            || content.is::<EnumItem>()
-            || content.is::<TermItem>())
-            && self
-                .items
-                .first()
-                .map_or(true, |(first, _)| first.func() == content.func())
-        {
-            self.items.push((content, styles));
-            self.tight &= self.staged.drain(..).all(|(t, _)| !t.is::<ParbreakElem>());
+            self.0.push((content, styles));
             return true;
         }
 
         false
     }
 
+    /// Whether this content is of interest to the builder.
+    fn is_primary(content: &'a Content) -> bool {
+        content.is::<ListItem>() || content.is::<EnumItem>() || content.is::<TermItem>()
+    }
+
+    /// Whether this content can merely exist in between interesting items.
+    fn is_inner(content: &'a Content) -> bool {
+        content.is::<TagElem>()
+            || content.is::<SpaceElem>()
+            || content.is::<ParbreakElem>()
+    }
+
+    /// Whether this kind of list items is compatible with the builder's type.
+    fn is_compatible(&self, content: &'a Content) -> bool {
+        self.0
+            .first()
+            .map_or(true, |(first, _)| first.func() == content.func())
+    }
+
     /// Turns this builder into the resulting list, along with
     /// its [style chain][StyleChain].
-    fn finish(self) -> (Content, StyleChain<'a>) {
-        let span = determine_span(&self.items);
-        let (children, trunk) = StyleVec::create(&self.items);
+    fn finish(self, builder: &mut Builder<'a, '_>) -> SourceResult<()> {
+        let trimmed = self.0.trim_end_matches(|(c, _)| Self::is_inner(c));
+        let tags = trimmed.iter().filter(|(c, _)| c.is::<TagElem>());
+        let staged = &self.0[trimmed.len()..];
+        let items = trimmed.iter().copied().filter(|(c, _)| Self::is_primary(c));
+        let first = items.clone().next().unwrap().0;
+        let tight = !trimmed.iter().any(|(c, _)| c.is::<ParbreakElem>());
 
-        let mut iter = children.into_iter().peekable();
-        let (first, _) = iter.peek().unwrap();
-        let output = if first.is::<ListItem>() {
+        // Determine the styles that are shared by all items. These will be
+        // used for the list itself.
+        let trunk = StyleChain::trunk(items.clone().map(|(_, s)| s)).unwrap();
+        let depth = trunk.links().count();
+
+        // Builder the correct element.
+        let iter = items.map(|(c, s)| (c, s.suffix(depth)));
+        let elem = if first.is::<ListItem>() {
             let children = iter
                 .map(|(item, local)| {
-                    item.into_packed::<ListItem>().unwrap().styled(local)
+                    item.to_packed::<ListItem>().unwrap().clone().styled(local)
                 })
                 .collect();
-            ListElem::new(children).with_tight(self.tight).pack().spanned(span)
+            ListElem::new(children).with_tight(tight).pack()
         } else if first.is::<EnumItem>() {
             let children = iter
                 .map(|(item, local)| {
-                    item.into_packed::<EnumItem>().unwrap().styled(local)
+                    item.to_packed::<EnumItem>().unwrap().clone().styled(local)
                 })
                 .collect();
-            EnumElem::new(children).with_tight(self.tight).pack().spanned(span)
+            EnumElem::new(children).with_tight(tight).pack()
         } else if first.is::<TermItem>() {
             let children = iter
                 .map(|(item, local)| {
-                    item.into_packed::<TermItem>().unwrap().styled(local)
+                    item.to_packed::<TermItem>().unwrap().clone().styled(local)
                 })
                 .collect();
-            TermsElem::new(children).with_tight(self.tight).pack().spanned(span)
+            TermsElem::new(children).with_tight(tight).pack()
         } else {
             unreachable!()
         };
 
-        (output, trunk)
-    }
-}
+        // Add the list to the builder.
+        let span = first_span(&self.0);
+        let stored = builder.arenas.store(elem.spanned(span));
+        builder.accept(stored, trunk)?;
 
-impl Default for ListBuilder<'_> {
-    fn default() -> Self {
-        Self { items: vec![], staged: vec![], tight: true }
+        // Add the tags and staged elements to the builder.
+        for &(content, styles) in tags.chain(staged) {
+            builder.accept(content, styles)?;
+        }
+
+        Ok(())
     }
 }
 
 /// Builds a [citation group][CiteGroup] from citations.
 #[derive(Default)]
-struct CiteGroupBuilder<'a> {
-    /// The citations.
-    items: Vec<Packed<CiteElem>>,
-    /// Trailing content for which it is unclear whether it is part of the list.
-    staged: Vec<Pair<'a>>,
-    /// The styles.
-    styles: StyleChain<'a>,
-}
+struct CiteGroupBuilder<'a>(Vec<Pair<'a>>);
 
 impl<'a> CiteGroupBuilder<'a> {
     /// Tries to accept a piece of content.
     ///
-    /// Returns true if this content could be merged into the citation
-    /// group. If this function returns false, then the
-    /// content could not be merged, and citation grouping should be
-    /// interrupted so that the content can be added elsewhere.
+    /// Returns true if this content could be merged into the citation group. If
+    /// this function returns false, then the content could not be merged, and
+    /// citation grouping should be interrupted so that the content can be added
+    /// elsewhere.
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
-        if !self.items.is_empty()
-            && (content.is::<SpaceElem>() || content.is::<TagElem>())
-        {
-            self.staged.push((content, styles));
-            return true;
-        }
-
-        if let Some(citation) = content.to_packed::<CiteElem>() {
-            if self.items.is_empty() {
-                self.styles = styles;
-            }
-            self.staged.retain(|(elem, _)| !elem.is::<SpaceElem>());
-            self.items.push(citation.clone());
+        if Self::is_primary(content) || (!self.0.is_empty() && Self::is_inner(content)) {
+            self.0.push((content, styles));
             return true;
         }
 
         false
     }
 
+    /// Whether this content is of interest to the builder.
+    fn is_primary(content: &'a Content) -> bool {
+        content.is::<CiteElem>()
+    }
+
+    /// Whether this content can merely exist in between interesting items.
+    fn is_inner(content: &'a Content) -> bool {
+        content.is::<TagElem>() || content.is::<SpaceElem>()
+    }
+
     /// Turns this builder into the resulting citation group, along with
     /// its [style chain][StyleChain].
-    fn finish(self) -> (Packed<CiteGroup>, StyleChain<'a>) {
-        let span = self.items.first().map(|cite| cite.span()).unwrap_or(Span::detached());
-        (Packed::new(CiteGroup::new(self.items)).spanned(span), self.styles)
+    fn finish(self, builder: &mut Builder<'a, '_>) -> SourceResult<()> {
+        let trimmed = self.0.trim_end_matches(|(c, _)| Self::is_inner(c));
+        let tags = trimmed.iter().filter(|(c, _)| c.is::<TagElem>());
+        let staged = &self.0[trimmed.len()..];
+        let trunk = trimmed[0].1;
+        let children = trimmed
+            .iter()
+            .filter_map(|(c, _)| c.to_packed::<CiteElem>())
+            .cloned()
+            .collect();
+
+        // Add the citation group to the builder.
+        let span = first_span(&self.0);
+        let elem = CiteGroup::new(children).pack();
+        let stored = builder.arenas.store(elem.spanned(span));
+        builder.accept(stored, trunk)?;
+
+        // Add the tags and staged elements to the builder.
+        for &(content, styles) in tags.chain(staged) {
+            builder.accept(content, styles)?;
+        }
+
+        Ok(())
     }
 }
 
 /// Determine a span for the built collection.
-fn determine_span(buf: &[(&Content, StyleChain)]) -> Span {
-    let mut span = Span::detached();
-    for &(content, _) in buf {
-        span = content.span();
-        if !span.is_detached() {
-            break;
-        }
-    }
-    span
+pub fn first_span(children: &[(&Content, StyleChain)]) -> Span {
+    children
+        .iter()
+        .map(|(c, _)| c.span())
+        .find(|span| !span.is_detached())
+        .unwrap_or(Span::detached())
 }
diff --git a/crates/typst/src/realize/process.rs b/crates/typst/src/realize/process.rs
index 913ee8f0e..83c2dd4dd 100644
--- a/crates/typst/src/realize/process.rs
+++ b/crates/typst/src/realize/process.rs
@@ -8,7 +8,7 @@ use crate::foundations::{
     Content, Context, Packed, Recipe, RecipeIndex, Regex, Selector, Show, ShowSet, Style,
     StyleChain, Styles, Synthesize, Transformation,
 };
-use crate::introspection::{Locatable, SplitLocator, Tag, TagElem};
+use crate::introspection::{Locatable, SplitLocator, Tag};
 use crate::text::TextElem;
 use crate::utils::SmallBitSet;
 
@@ -37,7 +37,7 @@ pub fn process(
     locator: &mut SplitLocator,
     target: &Content,
     styles: StyleChain,
-) -> SourceResult<Option<Content>> {
+) -> SourceResult<Option<(Option<Tag>, Content)>> {
     let Some(Verdict { prepared, mut map, step }) = verdict(engine, target, styles)
     else {
         return Ok(None);
@@ -54,7 +54,7 @@ pub fn process(
     }
 
     // Apply a step, if there is one.
-    let mut output = match step {
+    let output = match step {
         Some(step) => {
             // Errors in show rules don't terminate compilation immediately. We
             // just continue with empty content for them and show all errors
@@ -67,12 +67,7 @@ pub fn process(
         None => target,
     };
 
-    // If necessary, add the tag generated in the preparation.
-    if let Some(tag) = tag {
-        output = tag + output;
-    }
-
-    Ok(Some(output.styled_with_map(map)))
+    Ok(Some((tag, output.styled_with_map(map))))
 }
 
 /// Inspects a target element and the current styles and determines how to
@@ -106,7 +101,7 @@ fn verdict<'a>(
 
     let mut r = 0;
     for entry in styles.entries() {
-        let recipe = match entry {
+        let recipe = match &**entry {
             Style::Recipe(recipe) => recipe,
             Style::Property(_) => continue,
             Style::Revocation(index) => {
@@ -124,7 +119,7 @@ fn verdict<'a>(
         // Special handling for show-set rules. Exception: Regex show rules,
         // those need to be handled like normal transformations.
         if let (Transformation::Style(transform), false) =
-            (&recipe.transform, matches!(&recipe.selector, Some(Selector::Regex(_))))
+            (recipe.transform(), matches!(recipe.selector(), Some(Selector::Regex(_))))
         {
             // If this is a show-set for an unprepared element, we need to apply
             // it.
@@ -137,8 +132,9 @@ fn verdict<'a>(
             // applied to the `target` previously. For this purpose, show rules
             // are indexed from the top of the chain as the chain might grow to
             // the bottom.
-            let depth =
-                *depth.get_or_init(|| styles.entries().filter_map(Style::recipe).count());
+            let depth = *depth.get_or_init(|| {
+                styles.entries().filter_map(|style| style.recipe()).count()
+            });
             let index = RecipeIndex(depth - r);
 
             if !target.is_guarded(index) && !revoked.contains(index.0) {
@@ -187,7 +183,7 @@ fn prepare(
     target: &mut Content,
     map: &mut Styles,
     styles: StyleChain,
-) -> SourceResult<Option<Content>> {
+) -> SourceResult<Option<Tag>> {
     // Generate a location for the element, which uniquely identifies it in
     // the document. This has some overhead, so we only do it for elements
     // that are explicitly marked as locatable and labelled elements.
@@ -226,7 +222,7 @@ fn prepare(
     // materialization, so that it includes the synthesized fields. Do it before
     // marking as prepared so that show-set rules will apply to this element
     // when queried.
-    let tag = key.map(|key| TagElem::packed(Tag::new(target.clone(), key)));
+    let tag = key.map(|key| Tag::new(target.clone(), key));
 
     // Ensure that this preparation only runs once by marking the element as
     // prepared.
@@ -246,7 +242,7 @@ fn show(
         // Apply a user-defined show rule.
         ShowStep::Recipe(recipe, guard) => {
             let context = Context::new(target.location(), Some(styles));
-            match &recipe.selector {
+            match recipe.selector() {
                 // If the selector is a regex, the `target` is guaranteed to be a
                 // text element. This invokes special regex handling.
                 Some(Selector::Regex(regex)) => {
diff --git a/tests/ref/counter-page-between-pages.png b/tests/ref/counter-page-between-pages.png
new file mode 100644
index 0000000000000000000000000000000000000000..f79c586d2c325eb8c21d91b411ef9a1c018c270b
GIT binary patch
literal 299
zcmeAS@N?(olHy`uVBq!ia0vp^6+rCG0VEjaJ(S@EQlC6s978H@y}h!R%aKvySYdf$
zc*+(D9kK3{N~&Ix8#~TAB-*yBI8A)Qq;jgnC&_hVREx(a!w03TW|e-G^Q3=V{e3N7
zeZfl(VKtv0)*Fhu8<#(1Vhi&t<Ji-^;+iT`nA+zcA%^(JO68|Ne=o4xI<;`i$p!(n
zKh-}jo=SXBYTVYCD)ir4qU2Tet&PnGw%<%T50qWQDq;F>hC!n4f%V6q@-+UIi|1zw
z=UWgQZoE#EMeJpp!-o_6jhnYVU}8Ew^QqFB(jBRJDr_7PJw;m_6D}`{YdO%i@X=m{
ugv}lccpK(d32x_Vu%1{Ho$3H~<l}pRuQJb1Wn0V-3I$JBKbLh*2~7ZtdV5L$

literal 0
HcmV?d00001

diff --git a/tests/ref/counter-page-footer-before-set-page.png b/tests/ref/counter-page-footer-before-set-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..2c6cd4ad88fecf7aa5b233ff9253d9ee941a2720
GIT binary patch
literal 535
zcmV+y0_gpTP)<h;3K|Lk000e1NJLTq004LZ002t}0{{R3j8wDZ00033P)t-sf7}26
z|Ns5{{rvp=`1ttu_xJYp_VMxY?Ck98>+9<3>f__%+1c6F*4EY4)zs9~%gf8k%F4*d
z$bQ-V!NI|N*7|zV^>@whbjj*;$mw&(=%b^fp`oE<t;%Gq$zrL+mX?-arov#Q!C$1m
zl9G~<k&%#)kX@j=jg5_4p16X7f>V&FQ;(;Ae}7VrrG9>XQH-NciJ(r1o=%6IOM;kl
zb8~WXa!G%baBy%&d5vppYieq0M0Scpb%;Q4f<0+^JZE?{Tx&F0Xfju2FHv4dNJuP9
zSVKcYD@#`?M^h<BQa(ODCqz#*H8n6WFdQ*C6eB1TAtn+aB@rDW3ltXs006|^>jnS-
z0MJQ9K~#9!?bKCvLQw!i(cG2_RH@Taqk_A;yW9My!X#KPu*jak`AT3&ps>OUE4-a>
z+rbIn7JoTm-`S87wih18myEE_dHoe7giq7P*d|BThyTJ3bC+}LKonNk`tb4FKPP<Q
z&TzuUnLfC1h7-00x^_zV<mT#J2codTyAWQJKtyDp#b)uU9}EjTPr)#MO=iKc^yWKH
zAeaHI2&{L%0{R|UFH}!OJQ}wM!*_2K1Vh3Fj&h~>0*+V>93KNPls+3jV0e6YY1$&Y
ZU;_yLNeG&ql1cyo002ovPDHLkV1gb80Z0G<

literal 0
HcmV?d00001

diff --git a/tests/ref/counter-page-footer-only-update.png b/tests/ref/counter-page-footer-only-update.png
new file mode 100644
index 0000000000000000000000000000000000000000..e179face593dd0c1af5c961de22f1a683f79f42d
GIT binary patch
literal 205
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS<0VEg>Eo$`yQd2x#978H@CI7H@Xh^*BD6rdI
zS8i(sgt6?zqu$9;`<h<_Z*M&Es8hCN^NwFnG!1N-U8czG_b~7NT(*bpvT@^&@N<3V
zOEy<r7CU_3;nfXQg^#(fv!t!m)~#rMFrkfMHG9dXAD3_bFFW7(MMvQI&9nAw_AgRC
z-k;~`-f(52w!*pVefw6IoIC#B&3hfldN)P}{j(p|XuNT|19GRQtDnm{r-UW|Y!X{%

literal 0
HcmV?d00001

diff --git a/tests/ref/counter-page-header-before-set-page.png b/tests/ref/counter-page-header-before-set-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..960776cfc20487042c35d59a3211f8e7812ebbf9
GIT binary patch
literal 551
zcmV+?0@(eDP)<h;3K|Lk000e1NJLTq004LZ002t}0{{R3j8wDZ0003CP)t-s|Ns90
z004j6|9Q~!deZfM*!+Il{#%{5OoN$r%<e&OgH45-Pl=!uBPdafqfLgKL2-m)Vq)*_
z@7UPbGBPr8adF7V$oTm9mX?-&ety~6*)=saK0ZDwNmVUPT3Va6%gf7ZYHE^_lIrT}
ze}8|Gk&*WH_H%P{%F4>s)z!hl!SV6&jg5`#>+5T4YjALIp`oGu{rxa7FegJ!Y`fYt
zT4`CCvtXveFjHY_x7ICATS!PqFHv48M^j*>!BUQ;OM;j+Tx(O0r+(S}3ltX-9U>DU
zCK4be95Fdtp13_}dUwt5PKTXy$LL+4yGD79EKFEQf0S}^a=^gA^YioV?d^MedwP0$
z{{H@aZkb8|007rXL_t(|+U?XuasogQh2hRXJj6p1+}+*X-QoTxVatXs4~q9);IE#V
zZXu$xuoH;&W-Ab@<w7ug-fIi%e+1(5<NHe>c04F_0g6t6u-P2~5ek|FAsh)94UmC-
z{=a`f*W(rWO~mEo+%Bi+qcQF_5z#R>AfiARW|-jvceh#%Bz$kSSRvtuN6=G0KP6M3
z&y`7o!r1~O{Qj29V<y({axr}F;aA<upbwe2tA;&DxHBHjA>sC9I@2P;I;BcgK)Bgb
ps$2nt8}(YX!UMuE!wfTg)E<oaGxiLZH3t9y002ovPDHLkV1h(m2u%P0

literal 0
HcmV?d00001

diff --git a/tests/ref/counter-page-header-only-update.png b/tests/ref/counter-page-header-only-update.png
new file mode 100644
index 0000000000000000000000000000000000000000..07bb19d98c7d61de5d13e40af5039bc6dc4cfc19
GIT binary patch
literal 131
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS<0VEg>Eo$`yQeK`ejv*Ddl7HAcG$dYm6xi*q
z>&Et<?bxI3S3{YTKR#!6Wfr-zyvu#oQFSi%V~@Ujx|y>bJO1CzdmTur+|~++o@GEw
Xny37^{?m!W2V}aZtDnm{r-UW|l5Z|~

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-1833-locate-place.png b/tests/ref/issue-1833-locate-place.png
new file mode 100644
index 0000000000000000000000000000000000000000..82b74e6d2716e882aa442da6c2833daf8e90704d
GIT binary patch
literal 136
zcmeAS@N?(olHy`uVBq!ia0vp^6+mpm#0(@a9G+$kq<8{+LR|m<|KHHiP+wo~;NZZR
zIBh>r+}zW}F{I*FvIOhmhBOBg5k9639^q@7nq?!F2n+ah2EGKs%vavi+YULhie>7$
g@WmQL&3VYcFfB$UI_O9LZlDnip00i_>zopr082tD>;M1&

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-1886-locate-after-metadata.png b/tests/ref/issue-1886-locate-after-metadata.png
new file mode 100644
index 0000000000000000000000000000000000000000..3fb4708d98638b3593eb5c4e4dde6018701a84a1
GIT binary patch
literal 830
zcmV-E1Ht@>P)<h;3K|Lk000e1NJLTq004LZ004mq00000E|MYN00098Nkl<Zc-rmP
zSx8h-7zc2_leQAQ6m42sWFhU5W?4ZZMVg|9s2P^DNLel=gqV?;X%P{DnV=|Ak`k5>
zkuQ}<w%DRlAUe3rq?uW2bI0pAGyiZj7pR^*<IDFw+;h+O^5cHr;huBsFiBy@FvAQp
zJOOawvSPg6a@Kgd)7D??0wDMU`fXn7m5QPS)wTraYz;3hC@Ao#g}=?=RRBV25o~MN
zJRg8>6?_|Q3>Td&!JGKZy7)Z)fiTQ4!wml|>?SL?#|$&fFvAQp%rL`z*yA2E%rL|M
zh0SJIOn?cNf#HnyMr<L<E{7>{;m2;YFdq$pBofr2On(xkK<h-kl1qJyP622p=aEb)
zT?Dp~A{o9zX8^R3>)@nEJ09+7vPguF>vXzz<O--!2X?IO7=_z?f{)F;D-Yfj7Z-Pw
zT!F-C#^-ct6!x30z<X+q{8BHNlW@X2djvK*I0NaFE*-W^n?G)GDfTmrxJ~I&S9J@y
z06Xd0_p19SrewgKy5U0=IA>oi2QFVL9PdFBDyAg$*RLaoefny5T3(huLxlfm-|L#V
zBu~=fQWe$E2eZDfPY<A@8yHYjgQ^V8f3;e8lVF%(hWWP0J!Y6;h8bp<VTKvz!yfmT
zVTKw0H*5k-=0C4yjE#!S$i~6()zzqv6A!1(r0tbJS{HDbJTw>+ou2gGI_{xo5=wo6
zqJhsM3us%S$GC{38tWKKFC@VA!VyRoUO-MNfUZ_+_A7dfIAn#5nrJC7Hi~MjUooW_
zK22!!hzfChf(K5bc=rAwIK%6@vm7{6q`W+mDXx6m1#DVmf!k~y{6$7qxfRZ#I!UEQ
zv)B+*+3v6=I~Q8o3dB$WB19cvh1ZJ#Sui}sX24&#^+H2Vz<J6?1brHY7m{8Yd{d+W
zk3<-N)zpZCvzie~H2}itErO^75mYJ#ZkyQ(m=-?;(BQQp*5x6J7Kp$O<j$kr8ttlC
z0e<!#oibqbjy!;$UjV2ERc}F`LDidK*219YO@d*D8J=|bH=Eo`*a4E8L;wH)07*qo
IM6N<$f=zaKBLDyZ

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-2326-context-set-page.png b/tests/ref/issue-2326-context-set-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..f0307d44f9b3340fdd325659a30692d21bdfb4d2
GIT binary patch
literal 676
zcmV;V0$crwP)<h;3K|Lk000e1NJLTq004LZ000{Z0{{R3fZDqh0004EP)t-sf7}0l
z+Wvjm{C(H^d(`)O)AoAO^?A|sdC>EC&+>TB@psMdcFgW}%k6c_>~+cObH?X##pZFt
z<Z;8}aKhqn!QpSe-)_F%ZoS=Xy4h>F*lM@dYPZ#AvCn3)&StR9Wv<I)tjS}m$6=_%
zV5PxdrNCaJzFwleU7@^Ppu1e3xm%sLTAQ_5nzUJ&vsag}SC+3<l&w{htW}e%RFbMw
zkEc?Orc#cjQH`WgjH6JCqECsSPKTXMhMY}>n@oh7OoN$Af|yExl}LS(NPLk;e2_<b
zk41QlMR$utc8WuEheC3NL2-mYaDqT@fj@13J!*SBX?i?ocspiyJ7sn{WOX@Xb2wmd
zH(zfzUT!vCZ8lwOHC$^nS!gp@W-?c0F;!zRRAMkwVK7o)FHv4CPFpNYSu09bDoIr-
zM^h<BQYc1ICP7RhJ4GTpL?1Oi8!tB-FE$!2G#M*05gsED93bex5TF160R2fsK~#9!
z?bJy(LU90w@yAdqGIc{`j++oNRH8xLB&6I1^E_k-8NR<wJLj;u*EyZ@|E=ELvwIN)
zL8xnEsg;t4KNyG5n(YZ1-}?Dg-<68i(g|QA=P!gVM}SOf{l?l5h`W)3=^bxJbjt<c
z-bZUE%fS4F;nO%?0w!-+-L_8{o;h?37b*MJ?sN((Dv(Szy)tkL$T^&k&56Y-p=f-X
zubytJPT`h!7v_75smkazAm>?#MPjB8GWJ%e%whwWIzn@1CA?(8f8dA|x<GyjhLQGs
z*}=fs`9oW0QIUZ5-MkZhc~xr4;F0+^$CcjN%5Kihh?f%t;fHV0!X=~wXCy!X0000<
KMNUMnLSTZ}Ts;v0

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-2841-pagebreak-to-weak.png b/tests/ref/issue-2841-pagebreak-to-weak.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6404766217e8502d5bd3f4051bdb1521d671f5b
GIT binary patch
literal 391
zcmV;20eJq2P)<h;3K|Lk000e1NJLTq004LZ002w~00000gXAo=0003_Nkl<Zc-rmO
zJxfAi7{+nGMPm>}t(D-=&_}2ib!e(wa*2r4au6&u6tqkTO|hhGu($n0r)HrSsGvon
zoEkza^W?FAt7AhvF8B2XesEuKaa-t6ECLHGu)zNS@AM^>{ZC#10A5wW^ui?u006_v
z;C|!ebK7gUGWL2llP>jSzZAjUg{j)3lZfZt7_DDp14ZxvCS@n_0u+Wcb+Fk5Jd6{{
za&z@E#$cnR2HtlUAvIs}2i__xTen0vOc@Y?1r}J~cDPfKjs+H2V1We|SYUzW*^`b1
z7FgiF!40hf-{)mz@I@pycLp>Z8Z>8)RKd>^VA}2gpALjiRl%Vou)ahxVb#ebMwG$s
zJW!lIOtYwKQC5|~aSsrSEga+1gE@t#{;=LtvsY8IEl2)f^2fEQ3Z@p{EmUa+!ns&0
l6x>^D%5n)Tu)qSh=NIcYO=yB4ks$y8002ovPDHLkV1l02rYZmc

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-4029-locate-after-pagebreak.png b/tests/ref/issue-4029-locate-after-pagebreak.png
new file mode 100644
index 0000000000000000000000000000000000000000..3b21c5d3d212d786d4e351010195f4bf43385d96
GIT binary patch
literal 698
zcmV;r0!96aP)<h;3K|Lk000e1NJLTq004LZ001%w00000vdlmP0007kNkl<Zc-rmN
zNl2AZ7=YovPc0gZf(DERGAauy5}IhVXj6z4Q8Zvs(4uIOO{k?=5;t|>P?1p>S_X+C
z(f~FQ617moi=dK*kOK}>qSyQXcY1SJNGYLGxafZuhqL+~4(Grb#~3xvf-TsBE!cuB
z*n%ziKZ3_9>y9nhf-U%Oz+Nvt4}b2xEwYv&Ya2cMe7OWYWT3AMu6dJ`4>nCm_NyE<
zOop6cps)~zC{pbFmMx$TsuPUS!<ljpXoe;axTmakxbd~p4!CL!0L;3>VmCWFJ+6*U
zH_%<{f_?JE=sz~jIu}5@NsBQ;_(QO!@6|btoc5n_s339Lg4_N{o~Y2P)6RPFUEZD&
zB=)ipeN+{yX%M^lNKo1Rd9p9ABv|usp4b>0n84>%8h3nrVEM>kE^4$dNi$*mI$*Yc
zVPbWfyu>D{BxwW3#Lf-P=ANdKBcD3wWDp_k5G6&#N-0tDn7eY+%$G|egs*Ep1$qtq
z)&h$s13RRKQVC;0AboI(=8&c7L})WWxU|6)dB#fl&I>t6t|U_-$3_e5nqGJcuti=|
zE8Cbf;a7O8Rs!sj)_yod?0l311MrAmb-d>BR4?Q64+a)a1d`<nZ{#Ln@``YIM~)_9
z(|BSu()+E1-C70FQpg2K=ZR#IEjCK!@UY?Hl{z=~?K0ijv`H5gu}4>wCI;wP@SUF?
zz4VlqnuSyM?+n<|**f2E!*N|)<_OnW`#ZQbA?Qx=64_R5o}3vI97Dx=4Q-6jnGc2w
z8xEt}X*vvtuV-UGix-E}*#+RLHvv2ibaeyXW_;}c9ewK$2WGe7@PJY826yj>uAW)e
gCt<-BY{CDgpR(EHk1lcT`~Uy|07*qoM6N<$f?bwCi2wiq

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-4029-locate-after-par-and-pagebreak.png b/tests/ref/issue-4029-locate-after-par-and-pagebreak.png
new file mode 100644
index 0000000000000000000000000000000000000000..9d34677df0bbc88da1ba62d596f2e488ac3fc726
GIT binary patch
literal 785
zcmV+s1Md8ZP)<h;3K|Lk000e1NJLTq004LZ0021%00000*bA`70008mNkl<Zc-rmN
zduYyk9Kdm(&o(;e*vYBG>5+3B(-?)U+`<^~2d%k9E=^JXAj;g@<~A0O%^%DqM8m@f
zljKsaX^B6!<Vl%qS`EuQVLkgj&+qr#-Y)w?OtQuH&-eY;_pk4(Pv39fZznpaP6jrx
zferi<;F7)vHXrK<m}KY`>IgW6Hv_nGu7t8RIcM4v{{P(eryOBQ&~o_$?K?4W+LKo2
zq(M8v;T}NUOeWX98`iGyiDid@{L=lN(<{o&17ctU8`!`t;f~6jv4IV2;GY3Uqr@V7
zzdP=%YQEX)w!@bPit8w!tD|N0W8^_g(}AM6M{S1LBg^?*dJ42GOT2uQJD~=u^6j?6
z2W1sd4=*DS?mE;86KlW+gsN=-oSJ#!bsGJVP@_K#1gb+YL!Q~qV-u_i0r(tV*{y`{
zCTa0>?fHUb@qf=fU(l`hzWBmOcIxJCE2G5LPuS@aZ)J*}c$})cA#dz_SLNY<WyZ$x
zBt1)T@#wt7e4Y-`jf*-bK4=}xTFr?S>Otr{0{AEXLP6DTxr$qMQK-*ZC|<VdaSrJ&
zJaXUPa}Sx~gKW7-o>Y)6CpjPsoHAM0N_eZ5abCAT+;AZI4`8A^p+eH>oyaG6r+O&S
zVluTJAVXfm2D!vwdCL`<L#Y(;P!_fo)?q+$S0GJpP%Y#6y~~&IIDG^#MH-sn6!CIT
zX15w{zSW!bEN65*vG^pQ&u>7HY~ZHsAYHDLA-C~p0dCzyu4YBwlrvQyLylZvjTCcA
zN;ocVDrDXd!`B9DuhLrsbkfT)+V>*UbWlY>g06(v>c4XOFOBk~&!4j<C8YTq{)-#6
zNRunA4DB(ik-c49`>*wr@m0=}?zu_1JRGU1FEX|JkspO^%MJt`%eG=47B;+!Vg-Xu
z0HIn3Ao85101&Mw<^yQ-0lc$t0=5+ayEY8rk6Sc-*votp1~#yPe@*WJ>opQM-}OI-
P00000NkvXXu0mjf=_q|3

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-4029-locate-after-spacing.png b/tests/ref/issue-4029-locate-after-spacing.png
new file mode 100644
index 0000000000000000000000000000000000000000..d2e61435acbaeb150ec243e92d5eaee6cb65160c
GIT binary patch
literal 706
zcmV;z0zLhSP)<h;3K|Lk000e1NJLTq004LZ002b@00000r0acs0007sNkl<Zc-rmN
zNl2AZ6u|M$QHutnpaG+SjLL$FgeDp-+7x0%6b%>@v?y9+6KZo3FKtm;kx>|028kll
z05%a4wNS)|ppu4=0}fQ8&-Z<A`sc8aQbL8O#r-cXcXfVTxNt`Bj~ZcM0~^@D1~#yP
z4QyZo8`!`GHn4#WY+wT$*uVxh@c#w-{RDjcx%ZCPY6h%j`0(?E684b3zS6(OHB#E&
zv>_#^eAqB)a*V#BA{d}paq?S^kQ%7GWDOrqmlHrEH2A<fZmG*lpqW;{Q*8lY*X$Li
z-PZ2&w6%MI&T0?rkS|v6vvJpW09tLDtRcc5!ZmffPOIl=@T5I?NfTz>4o>#PMP8h6
z+)v=_#_M6?EQ!!Z6_I)q64&kvE4e>IcAPH?*Bso3RwssD;`0(ce{f`I>Cj+KYkVMC
z(_!QaU}|uFQsqr~i9>FXtaTg^Cs#F-dwPQ``P4owjTmW#I4K}eiiwlQ+?D-yuACVn
zd_{A~)5{RF9GE*6*d$dHOBAz0>4C3n78#mKj5Y#9OADNnXDpWQypY{wOA2LjV7Ra@
z>xRbx>*O`nvVk$9eudX-IlvZa?u8@7$w%4M2M_62U(g($>RAH8;lS+CK#H8>ja(y2
zUJ)(t$kHSndVvIu^?xg3t5!g~<a0_=c_JBPii2X=J7~CYu};r^yFfQLtkF3IY|}->
zNg;Y10w*WN&p+a)YWDb@n?u&MH_r@Obx`M)xT1B+&Ngn13cFJ{Pc~HAhbJe5Cs4Lh
zBkN;y@`J&`mdomN+b+u$=(<?Y<j3W9cK~>5Z2(^#9i4!`kw7azThIB!h23end|=gj
o!P`BeqidE~5(YM~f&WfF0eb{H#qRl-E&u=k07*qoM6N<$f-u)ZH2?qr

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-4363-set-page-after-tag.png b/tests/ref/issue-4363-set-page-after-tag.png
new file mode 100644
index 0000000000000000000000000000000000000000..4002b2ddfa8ce82fb01bdb0f54364651e047df66
GIT binary patch
literal 278
zcmeAS@N?(olHy`uVBq!ia0vp^6+mpx!3-onY^jR`QfUD`A+G-&&FXLeue<p-VcDVZ
z=^FyN7XG$3{bg_R#m@M>jgd#~q&GH(_bl}9Sm<3b)46P_bJ$RGo1WTw9aYnq>=jzd
z%e0giYAQ`qmG4uLtCE*2m6gbm7Lzlv5mr<aQc%_5=2Yfn2U?{ibSM}|WqZ0fhE&{o
zd*wK9GlPK3#ll0!I_DJs_YGn+Kf>{HKij@<8y0tWatN#WR80SHR(Rh&_UlJ&A1*$$
zSo6<`cRU=4hgvxEFDEH6SZuBTIN3Rb{c|weL-$~XZlme0lTJOl-E!5Nt?>HRJ!T9!
a(Tp7Ca_wu+{5u7-mci52&t;ucLK6Urn`l=6

literal 0
HcmV?d00001

diff --git a/tests/ref/list-item-styling.png b/tests/ref/list-item-styling.png
new file mode 100644
index 0000000000000000000000000000000000000000..72af2e1db88af16788791ac3b874b0322c6a30ee
GIT binary patch
literal 1459
zcmV;k1x)&hP)<h;3K|Lk000e1NJLTq004LZ001=z0ssI21;DsB000GgNkl<Zc-rlj
z?N3u@7{=|N;zvK3m_?%a88Z_}gau7tLkFAD4Wy7^1e7^nK*rlZ#!wMNK|za%B8s@;
zsJv8AgQXPPQYd|awp9COp|rhrr-vX~n1<+L^!_zz&dE6^C;2_sxt@CsnE!<}tbj$c
zXof|zXco<|Xco<UN}_ExTT4re-|tr_6f&8NMXv_EULPA98y6R6Fc?T>W@ctYL_}|I
zFP307o7b*g>+|`Vnwoa)+Qp(*NpW#;d3iZPP-df}qY*}AWMnWH)M~Zy@$oErm6Vm0
zm6n!zLJSTL?%1&d03Dw_dzLPBcXx-2R;$%TMMWhgB|SYoEc)%9-MV#aMMcH3q7xGn
zFNDa;%M(P4#p0Tpn&#$aQXDRN%a$$v5bM{kr%GYbuaQcnB9UnG=FQ8BuB@y?h>?*I
zLG-3go8)pi6}QD=c}p}MtXsDZA+~MXrqk(I^c%Fdw@*$^A`D7#VPPRc3=9lJMMVKf
zN=l*y03bZFVZ#P0li}gvn3xzL(SqOY+qYA$S@gRhkJ;JTIXO8-qmh&q6cnVTrP0*k
za5%EEvglN)R8n!Lrlv|HlB%kzjEoE_Xp_m5pPx@fq*AH4qZt;>q8S#=qFMAu#6AP{
zC>C)!p;WNw|3o*2^!<2nAG5P4&d14IxZRkaM^!m4oyST@J8|#;7STM%o}DcEU6dAp
z#1UpA()L22;Q|7Ftc2qwveL1X{ok|bck%2gjviVlgs4c+KPhg!1Y)2cw^|@+1m#^n
zj=W#dC&PtvuSGi?xN;HowMdR<(Si_1LPA1)eLa?C_fC+?YnM@T2CWkG_kb#8%7o*G
zLCAYiRtO>`8IK>qI{jMo(JXk}2nMk?kwt^(?CcbYL=h1YSQcvJj@xKzfMpuLq~K};
zh^|glSAuxu!M@!fsLj3JH>x8cmaF3p0)aqXU7b>?#ImSI5&Jc)mIa%)TR}|dNcuu|
z7v(J^+UWp6cM6vh<3LwkPQ=I1J6QC4a6<xt?k-UC3P|sP3YwDccHy}SG?UzH20<&4
ze-u<NiXjvn$K5s*p1_j<7R|6|7R|6|7R{np$82!UI5)*|KY(bBSC_8Mz5k-y8<;(%
zKYe_n#N~I-2j~AZ)>NAtT5Rnp>MX2GkbdutFX+2#mo{2%(Cfa$MCXndNMFbRjCm)1
ze4c?2HB*=8g1%{=HC=NAD`1#2)3bPQdK`}iTu%Y)RQ~WKitcv~W{sTy@Y3)2YA}la
zDW@bF0ErgzUTQcabcn*E>ach9J0AmRwzhpc@)Ly=Av}Rs^c|?ZI-OTvJoy)`)5Ynl
zT`wPAv0Oi6x=3+G2(5RVUiaCG_INyEvAC_R4PgWjh*o?@A}(95|2|nkbs={?QF=xN
z(ccUw&CJ{H*&mb{&H<o40r0c>5Isdgvvqk`LW!YD=I93yKeCVdomMDSlTCM4nrf*r
z7QYog0-vquj*bqINVIX|Ml8oEeR=1Le`=?$OwJlfV%<~|070}^a~QyoTbZvf12E_s
zx;fK99<9EaaM6@#nL`d>kLmy=n!2LGcpiZ2l_o=*3&0)l&?<h;o1xF=D=I4L>+3@p
zg2$+#IK!L?z;0E_HS5hq(FZg+0G_y?(LPD1ncCj~&<<(w*~Vw}2gi<K3FplX?e@O`
z#0@7q{7w>GZmb6I&><JPh+^*ayT0i0j%pMkT5Wf2^LB)|Zo5rMB&W4gjpWqin?9mD
z)i!hQ<isC0Y<H+_DDSPdJ4?1l)3J%-`e_Mmk`n7J5}iDnPWO{#nq&myO_o-kqdzdD
z^|Y~?=je|PRe$oRnA)60e_Uu%q^72ZVbKhWX3;E~VbLs_VbPx`{{oH{=!>z^;=TX?
N002ovPDHLkV1jphu}=U1

literal 0
HcmV?d00001

diff --git a/tests/ref/list-items-context.png b/tests/ref/list-items-context.png
new file mode 100644
index 0000000000000000000000000000000000000000..a19cbec43ca3829d03662af60476150ec8a7dd3a
GIT binary patch
literal 382
zcmV-^0fGLBP)<h;3K|Lk000e1NJLTq004LZ001=z00000ugP${0003+Nkl<Zc-rmM
z&nv?L7{_sc3{pEdsi_@yAo&mc$co(NL@g<y)*|g-C6ugXlN5H4q@nGgk;@XTM%35u
zQnInlHgA`G&3WnB<@uc6x7X$AsiQ`#Q&?ez75*1EMrC<hNeV9c8mVk!a9;`r8<lwz
zj+(%yQ_=d5TEOGy7p{;P+yG~v02m&)?vR25&M-a$AnTsVvFqH^2codTRl>&Bi<$1u
z)v=TmoSIHI7RzneId(|Fj|P@}xu5L0xpgTRwihvBOK@mH42}i(h3(Ls5Q6U~S<9rp
z0Jyb6>y;23>F({veFMO3kKZ5F2codTRl}E&0_Kw5g^?X0cr$b|VD?>Ck#~m>{7?vb
z%^p4gUWH%|+m_92Ps$!wQ>Gk!VL><zEyd?=0OHmx90|cO&wLzL3IL*`ODk{sKonM3
cVTJ$h2Tr?)poaD?(EtDd07*qoM6N<$f+c6Ipa1{>

literal 0
HcmV?d00001

diff --git a/tests/ref/locate-between-pages.png b/tests/ref/locate-between-pages.png
new file mode 100644
index 0000000000000000000000000000000000000000..aac6de86944b7dff24c0b235f0e9bfae9a004c13
GIT binary patch
literal 231
zcmeAS@N?(olHy`uVBq!ia0vp^6+mpu0VEilXMMT|q}F-5IEGZ*dV58Y>rjEr(T{fz
z>1lL}H6P8{KEtL#yXou#^&jl6N0c;-_B18@GQXJffz7B{LPq=XcJCfrw)^Fc{Qd0u
z27yco2?-C19yl&)l%Kqnt!)23mVYk$eg_?R_wSA#OM#W~X{*YwAF^iN$gO(f(9j43
zPd8}g@bK`&Wd9J6dnWGrcv@|>(2l?N@>L2xzjCW*m6_F>%s9vVOj{ho{Kc_vECqn(
cCnVU$FlZirn^(2A<rc^Xp00i_>zopr015hDr2qf`

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-context.png b/tests/ref/page-marginal-style-context.png
new file mode 100644
index 0000000000000000000000000000000000000000..02c80bb14e995505afa53a38abe7e3dfc06d1367
GIT binary patch
literal 348
zcmV-i0i*tjP)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0001-P)t-s|NsC0
z*VX^)>Hn6H|CW#ctf&9+@c-7-|G&Kdes}+SbN_g8|CNvb<>UXhvj5)P|7v3Yr=tJW
z)BoMu|LEucfqDOXbpQJL|9*D=YGMDAjQ{)l|Cf>f+u8s5`2XMC|N8m=p`8EV-v4rH
z|B#CRQb_;3x&QtB|6W!9SWf?5RR38}|5{N0z`XzJ>Hq!w|M&O*xwZegw*T<&U{vCJ
z0001cNkl<Zc-rmL*Aas-5CGA|#sPz)oO8}Wg8qAR7k9&OuYvtqj4`In@^_ooV7*!v
z2zvp^h8fbH-ut;5PiqK!gb)^vj(GSEOdN@H_;vx(5os4$*Yk%c8}_rF9d3-UU*15)
uH^k_O>Xi$}sMsG)1sb-yW7FO?MjwAvSq9r7Ub_PT0000<MNUMnLSTZ_)5v51

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-empty.png b/tests/ref/page-marginal-style-empty.png
new file mode 100644
index 0000000000000000000000000000000000000000..10183129dc9545b2e1b01fab6f1b79f60642ee73
GIT binary patch
literal 152
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS<!VDxupC4Zaq_hHjLR|j?!OtK6KYjfF{OSJ(
z_x|6w_W%0T|7TDAUo`js%*p?!P53{p|9@Y{|LzuLmG-$nU7DUQjv*Ddk|kIdCy4Y2
z9FTBmOuNl1l93i|pklgNeu2a0V^c1QnA<Qg^k%Yb*?etx8c-91r>mdKI;Vst0AsR2
ArT_o{

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-page-call.png b/tests/ref/page-marginal-style-page-call.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d53a59fb7a16068b08224d379f3be457b1ddb62
GIT binary patch
literal 300
zcmV+{0n`48P)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0001lP)t-s|NsC0
z{r&v>{Qvs-|M>X$`1t?y^!NAo|M2hs@9ymE?Cb06|Kj2Q-`@Y&*5l*j|JT+3*3<vc
z&eqn})YR1fxwXp5%Kxye|E;P2t*HO1rT?Fr|DT!vmXQCHj{lH~|B#8Jqobjrq5pPn
z|8HjhXkY(iTab{Df`Wo`b8~WXazjHyaccc<0001ENkl<Zc-rmL#Sz0$00U8l<8aK(
z?Ed?67hmJCUITkth=^=lV}asRhM<VAEg0^F-Mv5%|K33g^UfJ?>JKn3N-X?yPj8Eu
ycdQ0beCrt;{<ORB42sLRJi%~torm5Q;lm2oVgyyCG0yw|0000<MNUMnLSTZPbE|v+

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-shared-initial-interaction.png b/tests/ref/page-marginal-style-shared-initial-interaction.png
new file mode 100644
index 0000000000000000000000000000000000000000..76a76588284bcef7b64c8f8e45465a0c3c73ec72
GIT binary patch
literal 504
zcmV<U0SEqxP)<h;3K|Lk000e1NJLTq004LZ002t}0{{R3j8wDZ0002<P)t-s|NsB}
z{{Q{`{rvp=_4)qz`1tqt_xASo@Am!i@$u;L{O|AY?Ck98>+9<3>gVU@<KyGr-rn2W
z+u7OK!QJ-P*Voq8*45S3)YR0w+V#`Z)4166%gf8k%F4*d$fwWprOxuB&GDei@xj5t
zoyqW+$MBTI@430Tjlu4%t*v^t>!zlrqobptp`mN8>0YPjmX?-Sq~?;6l2f7Ok&%&*
zkdTdyjf;zmgM)*Df`Wm8fjN`me}8{|etvd#b|{J8CWzi8h~9H^b0UV`a&mHUadB{P
za2J5wYinz2YHDI)Vn|3xLqkJ8K0Y-yH83zR0002x+CU=!006*AL_t(|+U?T?asp8R
zgW*)Dvu!C`$K72PceneWhFiSAknaMS$;=NCku$fpK=HpUgQEVp1%rDL*?oYZ?)xfs
zVcz`+aP6;QT(x7tKg+3Y5%X@cHBh|eCgAXmE^e4~waeMK!EpEe`J%Q(PQigh&x^=e
z3-!b4KQIjO&<4ZcDH;dE_$OJq1wkJu1YzFQ9H@9<ULYR}dKI?_gPm$6z|egDU4tXj
u0EMRm3d?~946B|q1;e{-zp8B!J{$qcNi{Lyv*}v^0000<MNUMnLSTaIz7`(<

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-show-rule-with-page-call.png b/tests/ref/page-marginal-style-show-rule-with-page-call.png
new file mode 100644
index 0000000000000000000000000000000000000000..17a171405f545380208d92c69cf0d2b304677901
GIT binary patch
literal 1514
zcmV<G1r_><P)<h;3K|Lk000e1NJLTq004LZ003180{{R3wTRFN0008JP)t-s|NsAd
z)%kwe{e9T{b;|5~*7|kH>vP8Ec+c^9(DQW3>TbQ=Yq{7&c8XS&u1S8AX0XjYYI_V8
z8AW)Ebjaxq7a9f&4M1;!Yq-~EvClYRaW-CUElpZ+!{lM7!%~i>P>Z5Se33_dkRUig
z6eB1XC@vs3KwO`?>gwtP1_uZZ5Dyz4Y`WPJASDnTAwO+@1`7;9aD)B*{XcGi4j3Fl
zbA~%+cSLrHI%IXh!NH}ar3DEJ1qus0Wp)Gz2@4b#ch2xiftGQ@<4=j8QH`WvrNLdH
zyjz{O_4W0Qjg4BHwG|{PUZcJgBPr|a>uYOkr>Ccwn3z*jQ_IWCW2?x@%F5N%)gCoH
zElyh~C@2>f7o(%2B_$=GprE0lp)5>UUS3`pDlrNX6dNx$8!t8*E;U$KSV%}nNq>|j
zK}#h-O1rzeA|fItCMM|U=x}gw$jHd}`1mj|Fn)f1mX?;;+1WKUHI$T;ot>RIIXUm|
z@3^?QdU|^C@$o)BK9Z7>YHDhKe}8jxbN2T3k&%%rOIK2krAvaC7b!1oyxTQfY7-(S
zO@^Ef867cIV;wU)Q;(-(tH&!!RtOIfI%ITSqP+(U4qc$TTAa2uTx(yXzhbGy4;mg+
zlByv(Ll!43A2vT6FgR|$-XS?cE>Bz>F*#0$oeL8dOoW;d9wT<l?sv`aN`RFpMo}|Z
zW)mSMC`C{{YJ5O&f+|Q<A2mKHM^Zm*elb*HS(>z0m#_*F6<C?FRg<eCJ4JHE<{mUW
z0|f>G1Oz^7eLQG+R+O!8z~DV;dJ!EWIbw1dD>4BC18KI@a>V6Nh@WV)(E<epCqz#s
zLQOAGUO{n$NPUt~jH5+&i$isYWv|S6(ey7;UpZrQZN1z~gPCZw(f|Pg0RjSj*ZX_a
z_j=Rze%k(e()D}Q_<!5~0000H!E-eL00QbsL_t(|+U?iXb5uzbfbqUF8RC!x2(oyB
z6JS{l>%Oe9zRSA1ySux);O_1a0x=|>Ng&KQBlmv%8Au)|v`DJp7F7Qp`mw+2sy@}#
z#<DEyB=`6r<BMB9c;EP9%)9RyKin|3@U>TcIq+?_zw)vV-H$&q=EavrnG^1l4+ohS
zp1;q|wq;q?k?it`!6!Cs!!~?Mg#!T+L5}W<a7{CZ)voQ~Yp#`?%h>Ny4wbx4x*ghd
zprK-Oo5OUF)7URBpTnq;2nPvQrb9*-ukGQTvI9tlwLyrEe9(=ONFxadHG2R!={+Rk
zq@)HzDXCE)-W-A@GSO=}HnH>&K$1fzua)7yOSNu}cHY9DMGxKIzIMpa*+rSbvhp*A
zbPteNFsWmXM6&Yr@~-9D7qaiTGbihtZ)M5SUZuL4*mvJ&=XT-CFLdd$^|{?z7v=&j
zPGss%SpP6^QPGOpjJ|ReVd+Pv_GG(6I7|C5UHeflx2AUPK$RpxnXDpP8Yz>{_*^DC
z8|Ca)hELaxwAY1D@d!|GKJcFmqfzo0n#;a$N3Cb8)={O&0M*hCHpp`N%PjtoPw6cU
zY?JM64eO&o!AM}STuHMG;Jm>HhR5q>fTtv_C7dr2ew3eD9d5bRBXl+Y>H-o)rNHnD
zfd<*YuW}A~@;lY?7xh|8SVvHzHG!GEcv8DUv8>=+spALPN*@W+C_RojJg~o>+55Wd
zb<Ns!I%5^{_5a4&O6?AbUw$tB`l|rLhX1x`P37X$w0|n5EYpH4w_2wyO5usYIhPEa
zCj&B^xhqRbOV~C+%ePeN%Bja1_FOL>b6n3&xL(|YP66CltO+2r$pHxVq$v&rl1U^1
zr0iQSc5&jK8w77t6ry{#Xxg)veI#tyhHd!xFuQzW|LK-xoz(6gckerI8$aA*-g?vc
z;o0Zjc-{EnnWx7*cD3=rIAb0d?L&9eUB=v8=tKC%u{Vt_w8L##mUTqC0kH0gSj(+W
QrvLx|07*qoM6N<$f?F%YegFUf

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-show-rule-with-pagebreak.png b/tests/ref/page-marginal-style-show-rule-with-pagebreak.png
new file mode 100644
index 0000000000000000000000000000000000000000..f05c64a75145e4782babaa39da457081c8631d30
GIT binary patch
literal 716
zcmV;-0yF)IP)<h;3K|Lk000e1NJLTq004LZ001Wl00000;n&kF0007$Nkl<Zc-rmN
zSxD4T6vy$-QHvI%par9ajLL$Fgf?0&dMU(;C|WQm2r7cI4YfUqNqZ<;$S4dggG3Q&
z0m~vJT2RbEQb|k51s5#QasL0=zPY?uN~kYGHNS_;y<9jSE?mwTgqJeN2m4?j{4c?7
zHy#&%&TC6#IlZP~;P8{#5_GTI)i-*kc9|6RG)+kGD;_Y+H96Sr6c$1+i4-fp#S%~f
zrRR)+!%1=ksD&CAI7iI4Iq}rf2sp|O0L+T*Vl|svT#n`zC(u^zfKBqn=z2Ex3I{-=
zNuAM8_)V}TZqy0Y9Pl5rEi-P^lpFr>uBgznqYk_AoLqf5NUQ}RdcP!8uR`qd9YF<m
zCdsDLdBK{Feb3U^z;k?_r>A!h4lL{+%yEtO#A^}^UIdKy&x$L(D$lUU72>suU1H^;
zrf^%YkSgz5CR`&z8X-!uiIse!<N>#2r<oxq`Uzjq3^MgR_$>sc4+qvr8Tk^%lt4P+
z%bH5ECK92w0O8UAr{pnn<vUMhD`}EIk?a~MtP48e5x@$0LAk7A*pOf0m0Aq2PU^eh
z5V7)Bw)7kB`qgJNokw~SkAE;QbtsS^r^uB{gvoQl<rS$Khegj2qmk~WJl1OoL`xRO
zB$0=bOo~{@m+gIqbLQ&Aw3oAVZOt;Bmdys8lOGqLhrx4nbo9*qZpx;P+`KkmMN9o;
zza_hMdVwum$8B!r`jDWTIWuHcskwJ-OmGZEi#4=5LdV|iD{R<|HoIvvY@YUw0d;O{
zc6%#;qtXO$Rngi8xNGq=0yKB7KWvz7hRp>=r4yVTC0g5S`G$lK{`+9_qj%u1d!oDp
y^ZtmJ;1B;DoV(9EaMRgCpL`9(2m4^}!~6t%_%k7=TXzcp0000<MNUMnLSTX<{Y>xx

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-show-rule-with-set-page.png b/tests/ref/page-marginal-style-show-rule-with-set-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..138f2272db8913f96e152a6c5646bc4fd603a921
GIT binary patch
literal 727
zcmV;|0x127P)<h;3K|Lk000e1NJLTq004LZ001Wl00000;n&kF0007>Nkl<Zc-rmN
zSxA&o6u|M$QHvI%par9ajLL$Fgf=S6qL)Ifh@u69f`X!lY(s6cBqkLqTc{|CY=JgR
zTF4d&iF#1PK~PCU$OUy!2Oa18X8Wi4Af<)+G9>eVx=-iFh08sI@Kb{VZ~zX#0}1we
z@p<@npDc0Z^jJgx;a9UI>@HpXpnJ8;q_DebLRwI9zhN%R0lJEgpoikb${$%mDxfsk
z=s$cz4gs}L;{o@G`3^U}dTfBJ+yKC=*d|uf-r{lDTiiffxeGSRccb&#I4fKLHj_G|
zkMQSk&Dfw5s@WerX6y5mQB$r4r+VTePmen2#dmyFdYD)XBJ_Sqq+Wug<=evwZcUPn
zC-cJf3C`V1lR}gEHcwCP8XQ{KH<+WE;7ipTFnAF#J~%6-^pd>6A{R;3Dt3yMb9#@P
zdXY@|+A`rXv0{UG$tFqiiI)dlmmTIaIo3z`tUlwpo`Il+!1Uq3YAGXMqL~uPFF0K@
zxuY4xYAryFG{6aY$y{mTwQS*`q){Y0`wQ!W4tN9*CGRPhl?)s5JG?@R0oF==CmbPG
zzR2b-xKFS8ls@6H9>*6P4on>iq{#_B$a$jW9Wjzirlw%gQzUAfw=s`(S^^1@#SzKi
zk=)^)Sjd-cy@qq<>cod1XX%=nWjZaJ^*Sd%B}5N`@9^k^nfttyO&z&uO-NKr{p6q}
zyL5ViBSyz<vU6of*tMJ)va;0NGd3|ik)p*KSsklmZ}%2997dbdbQlg_`@w)ZFAk@(
z6~I+#0(h!uZ3Dcu_-p`n8$h!Iv(0dLz^HVCyJJLa`>eo{2*Cd#T%79<*t{R5d;I}7
zTu9a<{(#}F9u2?)9DX4O`~p8+pySd#et_+b%}utzUmbw|+D{r?CV(%8phW-x002ov
JPDHLkV1fh&Q?vj8

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-show-rule.png b/tests/ref/page-marginal-style-show-rule.png
new file mode 100644
index 0000000000000000000000000000000000000000..f05c64a75145e4782babaa39da457081c8631d30
GIT binary patch
literal 716
zcmV;-0yF)IP)<h;3K|Lk000e1NJLTq004LZ001Wl00000;n&kF0007$Nkl<Zc-rmN
zSxD4T6vy$-QHvI%par9ajLL$Fgf?0&dMU(;C|WQm2r7cI4YfUqNqZ<;$S4dggG3Q&
z0m~vJT2RbEQb|k51s5#QasL0=zPY?uN~kYGHNS_;y<9jSE?mwTgqJeN2m4?j{4c?7
zHy#&%&TC6#IlZP~;P8{#5_GTI)i-*kc9|6RG)+kGD;_Y+H96Sr6c$1+i4-fp#S%~f
zrRR)+!%1=ksD&CAI7iI4Iq}rf2sp|O0L+T*Vl|svT#n`zC(u^zfKBqn=z2Ex3I{-=
zNuAM8_)V}TZqy0Y9Pl5rEi-P^lpFr>uBgznqYk_AoLqf5NUQ}RdcP!8uR`qd9YF<m
zCdsDLdBK{Feb3U^z;k?_r>A!h4lL{+%yEtO#A^}^UIdKy&x$L(D$lUU72>suU1H^;
zrf^%YkSgz5CR`&z8X-!uiIse!<N>#2r<oxq`Uzjq3^MgR_$>sc4+qvr8Tk^%lt4P+
z%bH5ECK92w0O8UAr{pnn<vUMhD`}EIk?a~MtP48e5x@$0LAk7A*pOf0m0Aq2PU^eh
z5V7)Bw)7kB`qgJNokw~SkAE;QbtsS^r^uB{gvoQl<rS$Khegj2qmk~WJl1OoL`xRO
zB$0=bOo~{@m+gIqbLQ&Aw3oAVZOt;Bmdys8lOGqLhrx4nbo9*qZpx;P+`KkmMN9o;
zza_hMdVwum$8B!r`jDWTIWuHcskwJ-OmGZEi#4=5LdV|iD{R<|HoIvvY@YUw0d;O{
zc6%#;qtXO$Rngi8xNGq=0yKB7KWvz7hRp>=r4yVTC0g5S`G$lK{`+9_qj%u1d!oDp
y^ZtmJ;1B;DoV(9EaMRgCpL`9(2m4^}!~6t%_%k7=TXzcp0000<MNUMnLSTX<{Y>xx

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-call-around-page-call.png b/tests/ref/page-marginal-style-text-call-around-page-call.png
new file mode 100644
index 0000000000000000000000000000000000000000..d5a2fd649949f46844b24ecdcc642cc6fd1a6442
GIT binary patch
literal 529
zcmV+s0`C2ZP)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H00039P)t-s|NsC0
z*VX^l)c=-{|CW#cxwZfI_y5+@|GT&U`uYFy@c)H=|K;QVmy!S5+5h(S|Mc_!otOV=
zV*mO0|9*G>@bCZP;s0x5|H#Gvv#<ZQvj4%o|9^P@-rWDi!T-p_|H;Px-P`}4n*YAK
z|BHnGes=$AVgG@7|9El#)zkm%>;LBE|65Z3;NJh=-T!iG|Dl}!cyRxOegEs~|If_-
zSWf?5RR38}|5{N0dvpJ#p#NS~|G&KdQb_-hivPg8|FW(Bx3mAXvHyvJ|Es3|v#$TJ
ztpAmd|HQ!mnUnvUmH(%r|E#C~`uhK%oBzwl|INz(y}AGD>Hqut|NZ>`y0-tMpa1>+
zQc5zF0002QNkl<Zc-rmM1#-er6ougfG(lRVE$+eH-Q8W1{qF?Z0=zK8{WkE=+?jho
z2q90VG#KqBFmkT7p#0MxaV7qmY*w&R1z<MdX1l@n4_K-2JRcUY+c!>+aIe3Vz(ASf
zxQLL*m+HHF*ehZ(0s~C|QNdp*9@h78APDskuP3zu#Nx@6QLCHH;r94La1HQ!`%V{%
z>GJ5)Yb0@@R*j)?IB8i3Vc~RMK^6z@3-VB?J}xZNskOPR1#<Y$q;>S$guH<ZxhoZo
TZo{cB00000NkvXXu0mjf^S4Dp

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-call-around-pagebreak.png b/tests/ref/page-marginal-style-text-call-around-pagebreak.png
new file mode 100644
index 0000000000000000000000000000000000000000..c154a6bd275c441f4a14f3f6dc31cff0b74d8433
GIT binary patch
literal 510
zcmV<a0RjGrP)<h;3K|Lk000e1NJLTq004LZ002t}0{{R3j8wDZ0002_P)t-s|NsC0
z{r&y@{rvp=|M&O!`1tqt_y6<q_V)Jw@9zKZ?f>oU@$vEh=H=|{?EmEA>+9?4>gxaD
z-~Zm+<KyH1(9ZwN$^Xm8|H{YN+1b|C*45S3)YR1f!oL5#x&OSl|GKvSxU~PavCGTL
z%F4?BvaQI-$p5dZ|Ei_`sH4Hb!T+M2|Dl}!p_~7on*W@Z|Cy8jm5=|BivNm(|A&D8
zf_wjdccY`Dp`oGwc5eS`VwRScl9G~<k&%#)kpEs)jg5`}T~q&DQ~z2}|58YTf`Wg4
ze|~;`b8~ZYa&mBRaBFL8YHDgoNJv9NLq0w}H8nLbFfafB09`x<;Q#;tz)3_wRCwC$
z(*<%uQ2;~HR48@ex76ET+}+*X+5ckL#S08M8^}y%E<{95+{y!rz_JO7?&Agw?nQk2
z34(6$yD@=zw^P8eyM%GAu?OLKRc(uycU5VF;<Y*hM{s&}!=$SnqqQ3hH$Pv`YFp$O
z>`C;zh@7<ljxX~8hCZBiF!b*I5iktiqNQsPbbz7_^Dc%!*$eaj@*&%+xJ4MO-_$!8
z63&+zIP4fGTxn3;CE)@?A)CyB;mNWd)V2s84o>JcMXOg2(f|Me07*qoM6N<$g4^OE
A5C8xG

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-call-around-set-page.png b/tests/ref/page-marginal-style-text-call-around-set-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..f4174cd27e59aa3de6edea8771c28c5ebd7b4220
GIT binary patch
literal 531
zcmV+u0_^>XP)<h;3K|Lk000e1NJLTq004LZ001Ni0{{R3b@mQy00039P)t-s|NsC0
z{{H{;^Z(@H|NQ*_-rWDv&;PWr|Dl}!iiH2dzW=77|DT!vv#<Y%f&cmV|Ac-2^z{E|
zU;mDX|JvC9vaSEq(EqBX|7v0XjfVfcxc`!j|8i>o#>4-3asRlq|MT+y?CbyC+yDCd
z|C^QnsigmnhyT;j|Ff?D<>dc!YybNB|5Qr<+1CHg%m1jO|Al`4u&n=haR2M+|LyDl
zWLy7wa{p;y|Ei|{es}-2vj2>Q|8Z&me0BfG#Q(>{|HHulgM9x}N&nc^|KHvJ=;!~X
zp#PAH|HQ!mlZ^k?)c@t<|GKvSmXQCJkN>%~|H{Yz%*p@N)Bo4i|KZ>N>goUZ`2Wz(
zCmBtc0002SNkl<Zc-rmMMV7))6oldb0STnLX?J%w+}$lmfb4%KOgM)Pa9#%7uNF|F
zDufVX9n><wWT^TRbou!%;#OS%XBT^fE?=K8s{n8rrr<*tXWuX)f0TwDt_<?{U!Glb
zI0>2N|L;S_ZE>x7IigRG7CKx^A$fmiO_|@)&&HB;x6$ETp;Fvfz1rJry%UZnXwJ}J
ze0EAXeH;jG@$s(OCZk|OK1K*Fe4!nWipMtIa0Z)J+_mw<!O@`~FR1xmK(;N!$^ul+
V71h@Zk=+0Q002ovPDHLkV1mb$LM8wJ

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-call-code.png b/tests/ref/page-marginal-style-text-call-code.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c8f155f4357aa295ae7f20076b15bf1cbefc3a5
GIT binary patch
literal 473
zcmV;~0Ve*5P)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0002<P)t-s|NsC0
z{rvy@{QUg<|N8p>_xJzy_4xSs|Mm3u_xJzv^8fDb|Lp7k>*@dM>Hp^C|K;QC?Ck67
z>;K~6|KZ>N-`)S)+5g$r<KyH1)zkme(ErlU|INz(%g6u9$N$O3|HZ=A*4EV2)c?Z2
z|H8iiySM+hv;VfT|FyBo%F6$;t^cvD|E{V3r=tI*p#P$s|Dl}!p_~7on*W%R|CW&d
zl#c(CjsK8}|Bs0Og?|5oeE))bqobq$e0BeObfKZ4|9Nr$cW?i6Z2xX%|7Ty2kdXgk
zS^r*D|6Ei5TT%a5PXAX;|58YTf`W5%b8>QWLqkJQ0@@J(005y$L_t(|+U?Xu62f2%
z1>gsi;>8_W+}+*1K)L^ESoH=>{ss9~$?8oqlYlYCel3~;naaH}E}2bk0XjFhb+Zo4
zLFWo(4XM`5BHo@+2J79Ej9yE<NE?J{Ctjwp&-gr%9qFpAPk4{gs1L>YkhOyaRLavL
zl2!Yl6N5HXCw~4ZjFGXe&JZH8H6TX){dd6zgmAn*A&B5A<b!<MjERRYva=69SJ*xA
P00000NkvXXu0mjfZfG64

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-call.png b/tests/ref/page-marginal-style-text-call.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c8f155f4357aa295ae7f20076b15bf1cbefc3a5
GIT binary patch
literal 473
zcmV;~0Ve*5P)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0002<P)t-s|NsC0
z{rvy@{QUg<|N8p>_xJzy_4xSs|Mm3u_xJzv^8fDb|Lp7k>*@dM>Hp^C|K;QC?Ck67
z>;K~6|KZ>N-`)S)+5g$r<KyH1)zkme(ErlU|INz(%g6u9$N$O3|HZ=A*4EV2)c?Z2
z|H8iiySM+hv;VfT|FyBo%F6$;t^cvD|E{V3r=tI*p#P$s|Dl}!p_~7on*W%R|CW&d
zl#c(CjsK8}|Bs0Og?|5oeE))bqobq$e0BeObfKZ4|9Nr$cW?i6Z2xX%|7Ty2kdXgk
zS^r*D|6Ei5TT%a5PXAX;|58YTf`W5%b8>QWLqkJQ0@@J(005y$L_t(|+U?Xu62f2%
z1>gsi;>8_W+}+*1K)L^ESoH=>{ss9~$?8oqlYlYCel3~;naaH}E}2bk0XjFhb+Zo4
zLFWo(4XM`5BHo@+2J79Ej9yE<NE?J{Ctjwp&-gr%9qFpAPk4{gs1L>YkhOyaRLavL
zl2!Yl6N5HXCw~4ZjFGXe&JZH8H6TX){dd6zgmAn*A&B5A<b!<MjERRYva=69SJ*xA
P00000NkvXXu0mjfZfG64

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-set-first.png b/tests/ref/page-marginal-style-text-set-first.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ede81de7815f08855434ea1b9cf3d0074d6c166
GIT binary patch
literal 457
zcmV;)0XF`LP)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0002wP)t-s|NsC0
z`uhLj-~aCI|Lf`h&C36-ssFXH|F^UMTT%bAt^cg2|GKvSxwZe-)&G`||CW#ca%%tZ
z@Bi`e|KQ&L-`)TD`2YI(|Dl}!cW?iEb^n->|Dl`zqMiR|U;kWF|6W!9S55!(^8b{M
z|H8ii#lruCeE-wX|H8ljkc$7ixBvY7|58Z*Vp;#o$N#ad|H{Yz$;SWo_5ae(|AKq}
z?Cbw-X8+aG|F*LK_xJywn*XJs|J&LB=H>sBjsJ9P|Al`4<>UY2;s1|_|EHq=+1CGi
zbpLsA|5#4{_4NPh>Hq!w)ev~W0001>Nkl<Zc-rmM#S+3$3<c0z+=~^8Q`~8byW8vk
z{|~GF0h6~NXO*lnxibkEW9-+oF35z!k!H(n+8xlTp<%f7<qSG?h$58Wbb`nIMmgB1
zRBh-1bF4gZrQLWwL&5L!dS0Ya4@X!m6}1fUdE3^>0hK|&ht+zs-R)tO%;SN73S(rP
zSQJu-coK3X)V~`nDeAnQN<)U6md)^OGbSItNU#o2R^`5&00000NkvXXu0mjf91I#C

literal 0
HcmV?d00001

diff --git a/tests/ref/page-marginal-style-text-set.png b/tests/ref/page-marginal-style-text-set.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ede81de7815f08855434ea1b9cf3d0074d6c166
GIT binary patch
literal 457
zcmV;)0XF`LP)<h;3K|Lk000e1NJLTq004LZ001Qj0{{R3zN+2H0002wP)t-s|NsC0
z`uhLj-~aCI|Lf`h&C36-ssFXH|F^UMTT%bAt^cg2|GKvSxwZe-)&G`||CW#ca%%tZ
z@Bi`e|KQ&L-`)TD`2YI(|Dl}!cW?iEb^n->|Dl`zqMiR|U;kWF|6W!9S55!(^8b{M
z|H8ii#lruCeE-wX|H8ljkc$7ixBvY7|58Z*Vp;#o$N#ad|H{Yz$;SWo_5ae(|AKq}
z?Cbw-X8+aG|F*LK_xJywn*XJs|J&LB=H>sBjsJ9P|Al`4<>UY2;s1|_|EHq=+1CGi
zbpLsA|5#4{_4NPh>Hq!w)ev~W0001>Nkl<Zc-rmM#S+3$3<c0z+=~^8Q`~8byW8vk
z{|~GF0h6~NXO*lnxibkEW9-+oF35z!k!H(n+8xlTp<%f7<qSG?h$58Wbb`nIMmgB1
zRBh-1bF4gZrQLWwL&5L!dS0Ya4@X!m6}1fUdE3^>0hK|&ht+zs-R)tO%;SN73S(rP
zSQJu-coK3X)V~`nDeAnQN<)U6md)^OGbSItNU#o2R^`5&00000NkvXXu0mjf91I#C

literal 0
HcmV?d00001

diff --git a/tests/suite/introspection/counter.typ b/tests/suite/introspection/counter.typ
index 0d2be6e2e..8cae32a4d 100644
--- a/tests/suite/introspection/counter.typ
+++ b/tests/suite/introspection/counter.typ
@@ -62,6 +62,46 @@ At Beta, it was #context {
 #counter(page).update(1)
 #lorem(20)
 
+--- counter-page-footer-before-set-page ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+A
+#pagebreak()
+#counter(page).update(5)
+#set page(fill: aqua)
+B
+
+--- counter-page-header-before-set-page ---
+#set page(numbering: "1", number-align: top + center, margin: (top: 20pt))
+A
+#counter(page).update(4)
+#set page(fill: aqua)
+B
+
+--- counter-page-between-pages ---
+// The update happens conceptually between the pages.
+#set page(numbering: "1", margin: (bottom: 20pt))
+A
+#pagebreak()
+#counter(page).update(5)
+#set page(number-align: top + center, margin: (top: 20pt, bottom: 10pt))
+B
+
+--- counter-page-header-only-update ---
+// Header should not be affected by default.
+// To affect it, put the counter update before the `set page`.
+#set page(
+  numbering: "1",
+  number-align: top + center,
+  margin: (top: 20pt),
+)
+
+#counter(page).update(5)
+
+--- counter-page-footer-only-update ---
+// Footer should be affected by default.
+#set page(numbering: "1 / 1", margin: (bottom: 20pt))
+#counter(page).update(5)
+
 --- counter-figure ---
 // Count figures.
 #figure(numbering: "A", caption: [Four 'A's], kind: image, supplement: "Figure")[_AAAA!_]
diff --git a/tests/suite/introspection/locate.typ b/tests/suite/introspection/locate.typ
index b3a77fdef..18611dded 100644
--- a/tests/suite/introspection/locate.typ
+++ b/tests/suite/introspection/locate.typ
@@ -37,3 +37,93 @@
 
 // Error: 10-25 selector matches multiple elements
 #context locate(heading)
+
+--- locate-between-pages ---
+// Test locating tags that are before or between pages.
+#set page(height: 30pt)
+#context [
+  // Before the first page.
+  // (= at the very start of the first page, before the header)
+  #test(locate(<a>).position(), (page: 1, x: 0pt, y: 0pt))
+
+  // On the first page.
+  #test(locate(<b>).position(), (page: 1, x: 10pt, y: 10pt))
+
+  // Between the two pages.
+  // (= at the very start of the first page, before the header)
+  #test(locate(<c>).position(), (page: 2, x: 0pt, y: 0pt))
+
+  // After the last page.
+  // (= at the very end of the last page, after the footer)
+  #test(locate(<d>).position(), (page: 2, x: 0pt, y: 30pt))
+  #test(locate(<e>).position(), (page: 2, x: 0pt, y: 30pt))
+]
+
+#metadata(none) <a>
+#pagebreak(weak: true)
+#metadata(none) <b>
+A
+#pagebreak()
+#metadata(none) <c>
+#pagebreak(weak: true)
+B
+#pagebreak(weak: true)
+#metadata(none) <d>
+#pagebreak(weak: true)
+#metadata(none) <e>
+
+--- issue-4029-locate-after-spacing ---
+#set page(margin: 10pt)
+#show heading: it => v(40pt) + it
+
+= Introduction
+#context test(
+  locate(heading).position(),
+  (page: 1, x: 10pt, y: 50pt),
+)
+
+
+--- issue-4029-locate-after-pagebreak ---
+#set page(margin: 10pt)
+#show heading: it => pagebreak() + it
+
+= Introduction
+#context test(
+  locate(heading).position(),
+  (page: 2, x: 10pt, y: 10pt),
+)
+
+--- issue-4029-locate-after-par-and-pagebreak ---
+// Ensure that the heading's tag isn't stuck at the end of the paragraph.
+#set page(margin: 10pt)
+Par
+#show heading: it => pagebreak() + it
+= Introduction
+#context test(locate(heading).page(), 2)
+
+--- issue-1886-locate-after-metadata ---
+#show heading: it => {
+  metadata(it.label)
+  pagebreak(weak: true, to: "odd")
+  it
+}
+
+Hi
+= Hello <hello>
+= World <world>
+
+// The metadata's position does not migrate to the next page, but the heading's
+// does.
+#context {
+  test(locate(metadata.where(value: <hello>)).page(), 1)
+  test(locate(<hello>).page(), 3)
+  test(locate(metadata.where(value: <world>)).page(), 3)
+  test(locate(<world>).page(), 5)
+}
+
+--- issue-1833-locate-place ---
+#set page(height: 60pt)
+#context {
+  place(right + bottom, rect())
+  test(here().position(), (page: 1, x: 10pt, y: 10pt))
+}
diff --git a/tests/suite/layout/page.typ b/tests/suite/layout/page.typ
index 0e1f77295..a4abaec79 100644
--- a/tests/suite/layout/page.typ
+++ b/tests/suite/layout/page.typ
@@ -245,6 +245,98 @@ Look, ma, no page numbers!
 #set page(header: auto, footer: auto)
 Default page numbers now.
 
+--- page-marginal-style-text-set ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+#set text(red)
+Red
+
+--- page-marginal-style-text-set-first ---
+#set text(red)
+#set page(numbering: "1", margin: (bottom: 20pt))
+Red
+
+--- page-marginal-style-text-call ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+#text(red)[Red]
+
+--- page-marginal-style-text-call-code ---
+#{
+  set page(numbering: "1", margin: (bottom: 20pt))
+  text(red)[Red]
+}
+
+--- page-marginal-style-text-call-around-page-call ---
+#text(red, page(numbering: "1", margin: (bottom: 20pt))[Hello])
+
+--- page-marginal-style-text-call-around-set-page ---
+#text(red, {
+  set page(numbering: "1", margin: (bottom: 20pt))
+  text(style: "italic")[Hello]
+})
+
+--- page-marginal-style-text-call-around-pagebreak ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+A
+#text(red)[
+  #pagebreak(weak: true)
+  B
+]
+
+--- page-marginal-style-show-rule ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+= Introduction
+
+--- page-marginal-style-show-rule-with-set-page ---
+#show heading: it => {
+  set page(numbering: "1", margin: (bottom: 20pt))
+  it
+}
+
+= Introduction
+
+--- page-marginal-style-show-rule-with-page-call ---
+#show heading: page.with(fill: aqua)
+
+A
+= Introduction
+B
+
+--- page-marginal-style-show-rule-with-pagebreak ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+#show heading: it => {
+  pagebreak(weak: true)
+  it
+}
+
+= Introduction
+
+--- page-marginal-style-context ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+#show: it => context {
+  set text(red)
+  it
+}
+Hi
+
+--- page-marginal-style-shared-initial-interaction ---
+#set page(numbering: "1", margin: (bottom: 20pt))
+A
+#{
+  set text(fill: red)
+  pagebreak()
+}
+#text(fill: blue)[B]
+
+--- page-marginal-style-empty ---
+#set text(red)
+#set page(numbering: "1", margin: (bottom: 20pt))
+
+--- page-marginal-style-page-call ---
+#page(numbering: "1", margin: (bottom: 20pt))[
+  #set text(red)
+  A
+]
+
 --- issue-2631-page-header-ordering ---
 #set text(6pt)
 #show heading: set text(6pt, weight: "regular")
@@ -272,3 +364,22 @@ Hi
 #set page(fill: gray)
 text
 #pagebreak()
+
+--- issue-2326-context-set-page ---
+#context [
+  #set page(fill: aqua)
+  On page #here().page()
+]
+
+--- issue-3671-get-from-page-call ---
+#set page(margin: 5pt)
+#context test(page.margin, 5pt)
+#page(margin: 10pt, context test(page.margin, 10pt))
+
+--- issue-4363-set-page-after-tag ---
+#set page(fill: aqua)
+1
+#pagebreak()
+#metadata(none)
+#set page(fill: red)
+2
diff --git a/tests/suite/layout/pagebreak.typ b/tests/suite/layout/pagebreak.typ
index a17345968..3ca48b69f 100644
--- a/tests/suite/layout/pagebreak.typ
+++ b/tests/suite/layout/pagebreak.typ
@@ -141,3 +141,12 @@ Some text on page 2
 
 #set page(fill: orange) // This sets the color of the page starting from page 4
 Some text on page 4
+
+--- issue-2591-single-weak-pagebreak ---
+#pagebreak(weak: true)
+
+--- issue-2841-pagebreak-to-weak ---
+First
+#pagebreak(to: "odd")
+#pagebreak(weak: true)
+Odd
diff --git a/tests/suite/model/list.typ b/tests/suite/model/list.typ
index f92755174..46f4621f5 100644
--- a/tests/suite/model/list.typ
+++ b/tests/suite/model/list.typ
@@ -142,6 +142,16 @@ Hello
 #list(tight: false)[A][B]
 World
 
+--- list-items-context ---
+#context [+ A]
+#context [+ B]
+#context [+ C]
+
+--- list-item-styling ---
+- Hello
+#text(red)[- World]
+#text(green)[- What up?]
+
 --- issue-2530-list-item-panic ---
 // List item (pre-emptive)
 #list.item[Hello]