From a9fdff244aef859449a76e5f762ee7c343a8ddcc Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 10 Mar 2023 20:47:23 +0100
Subject: [PATCH] Expose content representation more

---
 library/src/compute/foundations.rs   |  21 +-
 library/src/layout/align.rs          |   2 +-
 library/src/layout/flow.rs           |  10 +-
 library/src/layout/hide.rs           |   2 +-
 library/src/layout/mod.rs            |  26 +-
 library/src/layout/par.rs            |   8 +-
 library/src/layout/stack.rs          |   2 +-
 library/src/lib.rs                   |  92 +++---
 library/src/math/mod.rs              |  69 +++--
 library/src/meta/document.rs         |   6 +-
 library/src/meta/heading.rs          |  23 +-
 library/src/meta/link.rs             |   2 +-
 library/src/meta/outline.rs          |  19 +-
 library/src/meta/reference.rs        |   2 +-
 library/src/text/deco.rs             |   6 +-
 library/src/text/misc.rs             |   4 +-
 library/src/text/raw.rs              |  15 +-
 library/src/text/shift.rs            |  14 +-
 macros/src/node.rs                   |  26 +-
 src/eval/args.rs                     |  16 +-
 src/eval/array.rs                    |  49 ++--
 src/eval/dict.rs                     |  45 ++-
 src/eval/func.rs                     |  56 ++--
 src/eval/methods.rs                  |  12 +-
 src/eval/mod.rs                      |  16 +-
 src/eval/ops.rs                      |   1 +
 src/eval/value.rs                    |   7 +-
 src/ide/tooltip.rs                   |  40 +--
 src/model/content.rs                 | 404 +++++++++++++--------------
 src/model/realize.rs                 |  20 +-
 src/model/styles.rs                  |  71 +++--
 src/util/mod.rs                      |  76 +++--
 tests/ref/compiler/content-field.png | Bin 0 -> 2444 bytes
 tests/ref/compiler/repr.png          | Bin 28225 -> 28367 bytes
 tests/typ/compiler/content-field.typ |  41 +++
 tests/typ/compiler/field.typ         |   2 +-
 tests/typ/compiler/label.typ         |   2 +-
 tests/typ/compiler/ops.typ           |  10 +-
 tests/typ/compiler/repr.typ          |   7 +-
 tests/typ/compiler/show-node.typ     |   2 +-
 40 files changed, 632 insertions(+), 594 deletions(-)
 create mode 100644 tests/ref/compiler/content-field.png
 create mode 100644 tests/typ/compiler/content-field.typ

diff --git a/library/src/compute/foundations.rs b/library/src/compute/foundations.rs
index 41a6bc359..8b148c856 100644
--- a/library/src/compute/foundations.rs
+++ b/library/src/compute/foundations.rs
@@ -53,7 +53,7 @@ pub fn repr(
 /// Fail with an error.
 ///
 /// ## Example
-/// The code below produces the error `panicked at: "this is wrong"`.
+/// The code below produces the error `panicked with: "this is wrong"`.
 /// ```typ
 /// #panic("this is wrong")
 /// ```
@@ -63,14 +63,21 @@ pub fn repr(
 /// Returns:
 #[func]
 pub fn panic(
-    /// The value (or message) to panic with.
-    #[default]
-    payload: Option<Value>,
+    /// The values to panic with.
+    #[variadic]
+    values: Vec<Value>,
 ) -> Value {
-    match payload {
-        Some(v) => bail!(args.span, "panicked with: {}", v.repr()),
-        None => bail!(args.span, "panicked"),
+    let mut msg = EcoString::from("panicked");
+    if !values.is_empty() {
+        msg.push_str(" with: ");
+        for (i, value) in values.iter().enumerate() {
+            if i > 0 {
+                msg.push_str(", ");
+            }
+            msg.push_str(&value.repr());
+        }
     }
+    bail!(args.span, msg);
 }
 
 /// Ensure that a condition is fulfilled.
diff --git a/library/src/layout/align.rs b/library/src/layout/align.rs
index cf6d08f27..2a3998bfc 100644
--- a/library/src/layout/align.rs
+++ b/library/src/layout/align.rs
@@ -58,7 +58,7 @@ pub struct AlignNode {
 }
 
 impl Show for AlignNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         Ok(self
             .body()
             .styled(Self::set_alignment(self.alignment(styles).map(Some))))
diff --git a/library/src/layout/flow.rs b/library/src/layout/flow.rs
index 7a063bcea..2671b9831 100644
--- a/library/src/layout/flow.rs
+++ b/library/src/layout/flow.rs
@@ -32,7 +32,7 @@ impl Layout for FlowNode {
             let outer = styles;
             let mut styles = outer;
             if let Some(node) = child.to::<StyledNode>() {
-                map = node.map();
+                map = node.styles();
                 styles = outer.chain(&map);
                 child = node.body();
             }
@@ -48,15 +48,15 @@ impl Layout for FlowNode {
                 || child.is::<ImageNode>()
             {
                 layouter.layout_single(vt, &child, styles)?;
-            } else if child.has::<dyn Layout>() {
+            } else if child.can::<dyn Layout>() {
                 layouter.layout_multiple(vt, &child, styles)?;
             } else if child.is::<ColbreakNode>() {
                 if !layouter.regions.backlog.is_empty() || layouter.regions.last.is_some()
                 {
                     layouter.finish_region();
                 }
-            } else if let Some(span) = child.span() {
-                bail!(span, "unexpected flow child");
+            } else {
+                bail!(child.span(), "unexpected flow child");
             }
         }
 
@@ -207,7 +207,7 @@ impl<'a> FlowLayouter<'a> {
         let aligns = if let Some(align) = block.to::<AlignNode>() {
             align.alignment(styles)
         } else if let Some(styled) = block.to::<StyledNode>() {
-            AlignNode::alignment_in(styles.chain(&styled.map()))
+            AlignNode::alignment_in(styles.chain(&styled.styles()))
         } else {
             AlignNode::alignment_in(styles)
         }
diff --git a/library/src/layout/hide.rs b/library/src/layout/hide.rs
index 626284459..e939e6c35 100644
--- a/library/src/layout/hide.rs
+++ b/library/src/layout/hide.rs
@@ -23,7 +23,7 @@ pub struct HideNode {
 }
 
 impl Show for HideNode {
-    fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(MetaNode::set_data(vec![Meta::Hidden])))
     }
 }
diff --git a/library/src/layout/mod.rs b/library/src/layout/mod.rs
index e846f6f06..dc373ff5e 100644
--- a/library/src/layout/mod.rs
+++ b/library/src/layout/mod.rs
@@ -148,7 +148,7 @@ fn realize_root<'a>(
     content: &'a Content,
     styles: StyleChain<'a>,
 ) -> SourceResult<(Content, StyleChain<'a>)> {
-    if content.has::<dyn LayoutRoot>() && !applicable(content, styles) {
+    if content.can::<dyn LayoutRoot>() && !applicable(content, styles) {
         return Ok((content.clone(), styles));
     }
 
@@ -166,7 +166,7 @@ fn realize_block<'a>(
     content: &'a Content,
     styles: StyleChain<'a>,
 ) -> SourceResult<(Content, StyleChain<'a>)> {
-    if content.has::<dyn Layout>()
+    if content.can::<dyn Layout>()
         && !content.is::<RectNode>()
         && !content.is::<SquareNode>()
         && !content.is::<EllipseNode>()
@@ -227,16 +227,20 @@ impl<'a, 'v, 't> Builder<'a, 'v, 't> {
         mut content: &'a Content,
         styles: StyleChain<'a>,
     ) -> SourceResult<()> {
-        if content.has::<dyn LayoutMath>() && !content.is::<FormulaNode>() {
+        if content.can::<dyn LayoutMath>() && !content.is::<FormulaNode>() {
             content =
                 self.scratch.content.alloc(FormulaNode::new(content.clone()).pack());
         }
 
         // Prepare only if this is the first application for this node.
-        if let Some(node) = content.with::<dyn Prepare>() {
+        if content.can::<dyn Prepare>() {
             if !content.is_prepared() {
-                let prepared =
-                    node.prepare(self.vt, content.clone().prepared(), styles)?;
+                let prepared = content
+                    .clone()
+                    .prepared()
+                    .with::<dyn Prepare>()
+                    .unwrap()
+                    .prepare(self.vt, styles)?;
                 let stored = self.scratch.content.alloc(prepared);
                 return self.accept(stored, styles);
             }
@@ -291,11 +295,7 @@ impl<'a, 'v, 't> Builder<'a, 'v, 't> {
             }
         }
 
-        if let Some(span) = content.span() {
-            bail!(span, "not allowed here");
-        }
-
-        Ok(())
+        bail!(content.span(), "not allowed here");
     }
 
     fn styled(
@@ -303,7 +303,7 @@ impl<'a, 'v, 't> Builder<'a, 'v, 't> {
         styled: &'a StyledNode,
         styles: StyleChain<'a>,
     ) -> SourceResult<()> {
-        let map = self.scratch.maps.alloc(styled.map());
+        let map = self.scratch.maps.alloc(styled.styles());
         let stored = self.scratch.styles.alloc(styles);
         let content = self.scratch.content.alloc(styled.body());
         let styles = stored.chain(map);
@@ -436,7 +436,7 @@ impl<'a> FlowBuilder<'a> {
             return true;
         }
 
-        if content.has::<dyn Layout>() || content.is::<ParNode>() {
+        if content.can::<dyn Layout>() || content.is::<ParNode>() {
             let is_tight_list = if let Some(node) = content.to::<ListNode>() {
                 node.tight(styles)
             } else if let Some(node) = content.to::<EnumNode>() {
diff --git a/library/src/layout/par.rs b/library/src/layout/par.rs
index e5644a2e9..8dd81d29b 100644
--- a/library/src/layout/par.rs
+++ b/library/src/layout/par.rs
@@ -519,7 +519,7 @@ fn collect<'a>(
         let mut styles = *styles;
         if let Some(node) = child.to::<StyledNode>() {
             child = Box::leak(Box::new(node.body()));
-            styles = outer.chain(Box::leak(Box::new(node.map())));
+            styles = outer.chain(Box::leak(Box::new(node.styles())));
         }
 
         let segment = if child.is::<SpaceNode>() {
@@ -570,10 +570,8 @@ fn collect<'a>(
             let frac = node.width(styles).is_fractional();
             full.push(if frac { SPACING_REPLACE } else { NODE_REPLACE });
             Segment::Box(node, frac)
-        } else if let Some(span) = child.span() {
-            bail!(span, "unexpected document child");
         } else {
-            continue;
+            bail!(child.span(), "unexpected paragraph child");
         };
 
         if let Some(last) = full.chars().last() {
@@ -730,7 +728,7 @@ fn shared_get<'a, T: PartialEq>(
     children
         .iter()
         .filter_map(|child| child.to::<StyledNode>())
-        .all(|node| getter(styles.chain(&node.map())) == value)
+        .all(|node| getter(styles.chain(&node.styles())) == value)
         .then(|| value)
 }
 
diff --git a/library/src/layout/stack.rs b/library/src/layout/stack.rs
index c21fa884b..1dd81a606 100644
--- a/library/src/layout/stack.rs
+++ b/library/src/layout/stack.rs
@@ -201,7 +201,7 @@ impl<'a> StackLayouter<'a> {
         let aligns = if let Some(align) = block.to::<AlignNode>() {
             align.alignment(styles)
         } else if let Some(styled) = block.to::<StyledNode>() {
-            AlignNode::alignment_in(styles.chain(&styled.map()))
+            AlignNode::alignment_in(styles.chain(&styled.styles()))
         } else {
             AlignNode::alignment_in(styles)
         }
diff --git a/library/src/lib.rs b/library/src/lib.rs
index ad8a2ac4c..94b3e0c44 100644
--- a/library/src/lib.rs
+++ b/library/src/lib.rs
@@ -29,65 +29,65 @@ fn global(math: Module, calc: Module) -> Module {
     let mut global = Scope::deduplicating();
 
     // Text.
-    global.define("text", text::TextNode::func());
-    global.define("linebreak", text::LinebreakNode::func());
-    global.define("smartquote", text::SmartQuoteNode::func());
-    global.define("strong", text::StrongNode::func());
-    global.define("emph", text::EmphNode::func());
+    global.define("text", text::TextNode::id());
+    global.define("linebreak", text::LinebreakNode::id());
+    global.define("smartquote", text::SmartQuoteNode::id());
+    global.define("strong", text::StrongNode::id());
+    global.define("emph", text::EmphNode::id());
     global.define("lower", text::lower);
     global.define("upper", text::upper);
     global.define("smallcaps", text::smallcaps);
-    global.define("sub", text::SubNode::func());
-    global.define("super", text::SuperNode::func());
-    global.define("underline", text::UnderlineNode::func());
-    global.define("strike", text::StrikeNode::func());
-    global.define("overline", text::OverlineNode::func());
-    global.define("raw", text::RawNode::func());
+    global.define("sub", text::SubNode::id());
+    global.define("super", text::SuperNode::id());
+    global.define("underline", text::UnderlineNode::id());
+    global.define("strike", text::StrikeNode::id());
+    global.define("overline", text::OverlineNode::id());
+    global.define("raw", text::RawNode::id());
     global.define("lorem", text::lorem);
 
     // Math.
     global.define("math", math);
 
     // Layout.
-    global.define("page", layout::PageNode::func());
-    global.define("pagebreak", layout::PagebreakNode::func());
-    global.define("v", layout::VNode::func());
-    global.define("par", layout::ParNode::func());
-    global.define("parbreak", layout::ParbreakNode::func());
-    global.define("h", layout::HNode::func());
-    global.define("box", layout::BoxNode::func());
-    global.define("block", layout::BlockNode::func());
-    global.define("list", layout::ListNode::func());
-    global.define("enum", layout::EnumNode::func());
-    global.define("terms", layout::TermsNode::func());
-    global.define("table", layout::TableNode::func());
-    global.define("stack", layout::StackNode::func());
-    global.define("grid", layout::GridNode::func());
-    global.define("columns", layout::ColumnsNode::func());
-    global.define("colbreak", layout::ColbreakNode::func());
-    global.define("place", layout::PlaceNode::func());
-    global.define("align", layout::AlignNode::func());
-    global.define("pad", layout::PadNode::func());
-    global.define("repeat", layout::RepeatNode::func());
-    global.define("move", layout::MoveNode::func());
-    global.define("scale", layout::ScaleNode::func());
-    global.define("rotate", layout::RotateNode::func());
-    global.define("hide", layout::HideNode::func());
+    global.define("page", layout::PageNode::id());
+    global.define("pagebreak", layout::PagebreakNode::id());
+    global.define("v", layout::VNode::id());
+    global.define("par", layout::ParNode::id());
+    global.define("parbreak", layout::ParbreakNode::id());
+    global.define("h", layout::HNode::id());
+    global.define("box", layout::BoxNode::id());
+    global.define("block", layout::BlockNode::id());
+    global.define("list", layout::ListNode::id());
+    global.define("enum", layout::EnumNode::id());
+    global.define("terms", layout::TermsNode::id());
+    global.define("table", layout::TableNode::id());
+    global.define("stack", layout::StackNode::id());
+    global.define("grid", layout::GridNode::id());
+    global.define("columns", layout::ColumnsNode::id());
+    global.define("colbreak", layout::ColbreakNode::id());
+    global.define("place", layout::PlaceNode::id());
+    global.define("align", layout::AlignNode::id());
+    global.define("pad", layout::PadNode::id());
+    global.define("repeat", layout::RepeatNode::id());
+    global.define("move", layout::MoveNode::id());
+    global.define("scale", layout::ScaleNode::id());
+    global.define("rotate", layout::RotateNode::id());
+    global.define("hide", layout::HideNode::id());
 
     // Visualize.
-    global.define("image", visualize::ImageNode::func());
-    global.define("line", visualize::LineNode::func());
-    global.define("rect", visualize::RectNode::func());
-    global.define("square", visualize::SquareNode::func());
-    global.define("ellipse", visualize::EllipseNode::func());
-    global.define("circle", visualize::CircleNode::func());
+    global.define("image", visualize::ImageNode::id());
+    global.define("line", visualize::LineNode::id());
+    global.define("rect", visualize::RectNode::id());
+    global.define("square", visualize::SquareNode::id());
+    global.define("ellipse", visualize::EllipseNode::id());
+    global.define("circle", visualize::CircleNode::id());
 
     // Meta.
-    global.define("document", meta::DocumentNode::func());
-    global.define("ref", meta::RefNode::func());
-    global.define("link", meta::LinkNode::func());
-    global.define("outline", meta::OutlineNode::func());
-    global.define("heading", meta::HeadingNode::func());
+    global.define("document", meta::DocumentNode::id());
+    global.define("ref", meta::RefNode::id());
+    global.define("link", meta::LinkNode::id());
+    global.define("outline", meta::OutlineNode::id());
+    global.define("heading", meta::HeadingNode::id());
     global.define("numbering", meta::numbering);
 
     // Symbols.
diff --git a/library/src/math/mod.rs b/library/src/math/mod.rs
index 8f89e0285..c11bea792 100644
--- a/library/src/math/mod.rs
+++ b/library/src/math/mod.rs
@@ -47,52 +47,52 @@ use crate::text::{
 /// Create a module with all math definitions.
 pub fn module() -> Module {
     let mut math = Scope::deduplicating();
-    math.define("formula", FormulaNode::func());
-    math.define("text", TextNode::func());
+    math.define("formula", FormulaNode::id());
+    math.define("text", TextNode::id());
 
     // Grouping.
-    math.define("lr", LrNode::func());
+    math.define("lr", LrNode::id());
     math.define("abs", abs);
     math.define("norm", norm);
     math.define("floor", floor);
     math.define("ceil", ceil);
 
     // Attachments and accents.
-    math.define("attach", AttachNode::func());
-    math.define("scripts", ScriptsNode::func());
-    math.define("limits", LimitsNode::func());
-    math.define("accent", AccentNode::func());
-    math.define("underline", UnderlineNode::func());
-    math.define("overline", OverlineNode::func());
-    math.define("underbrace", UnderbraceNode::func());
-    math.define("overbrace", OverbraceNode::func());
-    math.define("underbracket", UnderbracketNode::func());
-    math.define("overbracket", OverbracketNode::func());
+    math.define("attach", AttachNode::id());
+    math.define("scripts", ScriptsNode::id());
+    math.define("limits", LimitsNode::id());
+    math.define("accent", AccentNode::id());
+    math.define("underline", UnderlineNode::id());
+    math.define("overline", OverlineNode::id());
+    math.define("underbrace", UnderbraceNode::id());
+    math.define("overbrace", OverbraceNode::id());
+    math.define("underbracket", UnderbracketNode::id());
+    math.define("overbracket", OverbracketNode::id());
 
     // Fractions and matrix-likes.
-    math.define("frac", FracNode::func());
-    math.define("binom", BinomNode::func());
-    math.define("vec", VecNode::func());
-    math.define("mat", MatNode::func());
-    math.define("cases", CasesNode::func());
+    math.define("frac", FracNode::id());
+    math.define("binom", BinomNode::id());
+    math.define("vec", VecNode::id());
+    math.define("mat", MatNode::id());
+    math.define("cases", CasesNode::id());
 
     // Roots.
-    math.define("sqrt", SqrtNode::func());
-    math.define("root", RootNode::func());
+    math.define("sqrt", SqrtNode::id());
+    math.define("root", RootNode::id());
 
     // Styles.
-    math.define("upright", UprightNode::func());
-    math.define("bold", BoldNode::func());
-    math.define("italic", ItalicNode::func());
-    math.define("serif", SerifNode::func());
-    math.define("sans", SansNode::func());
-    math.define("cal", CalNode::func());
-    math.define("frak", FrakNode::func());
-    math.define("mono", MonoNode::func());
-    math.define("bb", BbNode::func());
+    math.define("upright", UprightNode::id());
+    math.define("bold", BoldNode::id());
+    math.define("italic", ItalicNode::id());
+    math.define("serif", SerifNode::id());
+    math.define("sans", SansNode::id());
+    math.define("cal", CalNode::id());
+    math.define("frak", FrakNode::id());
+    math.define("mono", MonoNode::id());
+    math.define("bb", BbNode::id());
 
     // Text operators.
-    math.define("op", OpNode::func());
+    math.define("op", OpNode::id());
     op::define(&mut math);
 
     // Spacings.
@@ -144,7 +144,7 @@ pub struct FormulaNode {
 }
 
 impl Show for FormulaNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.clone().pack().guarded(Guard::Base(NodeId::of::<Self>()));
         if self.block(styles) {
             realized = realized.aligned(Axes::with_x(Some(Align::Center.into())))
@@ -183,10 +183,7 @@ impl Layout for FormulaNode {
                 Some(font)
             })
         else {
-            if let Some(span) = self.span() {
-                bail!(span, "current font does not support math");
-            }
-            return Ok(Fragment::frame(Frame::new(Size::zero())))
+            bail!(self.span(), "current font does not support math");
         };
 
         let mut ctx = MathContext::new(vt, styles, regions, &font, block);
@@ -228,7 +225,7 @@ impl LayoutMath for Content {
         }
 
         if let Some(styled) = self.to::<StyledNode>() {
-            let map = styled.map();
+            let map = styled.styles();
             if TextNode::font_in(ctx.styles().chain(&map))
                 != TextNode::font_in(ctx.styles())
             {
diff --git a/library/src/meta/document.rs b/library/src/meta/document.rs
index 8da3c731a..ae29e7a8b 100644
--- a/library/src/meta/document.rs
+++ b/library/src/meta/document.rs
@@ -39,7 +39,7 @@ impl LayoutRoot for DocumentNode {
             let outer = styles;
             let mut styles = outer;
             if let Some(node) = child.to::<StyledNode>() {
-                map = node.map();
+                map = node.styles();
                 styles = outer.chain(&map);
                 child = node.body();
             }
@@ -48,8 +48,8 @@ impl LayoutRoot for DocumentNode {
                 let number = 1 + pages.len();
                 let fragment = page.layout(vt, number, styles)?;
                 pages.extend(fragment);
-            } else if let Some(span) = child.span() {
-                bail!(span, "unexpected document child");
+            } else {
+                bail!(child.span(), "unexpected document child");
             }
         }
 
diff --git a/library/src/meta/heading.rs b/library/src/meta/heading.rs
index 3a8d811c4..8677aa55a 100644
--- a/library/src/meta/heading.rs
+++ b/library/src/meta/heading.rs
@@ -79,13 +79,8 @@ pub struct HeadingNode {
 }
 
 impl Prepare for HeadingNode {
-    fn prepare(
-        &self,
-        vt: &mut Vt,
-        mut this: Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content> {
-        let my_id = vt.identify(&this);
+    fn prepare(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+        let my_id = vt.identify(self);
 
         let mut counter = HeadingCounter::new();
         for (node_id, node) in vt.locate(Selector::node::<HeadingNode>()) {
@@ -105,18 +100,18 @@ impl Prepare for HeadingNode {
             numbers = numbering.apply(vt.world(), counter.advance(self))?;
         }
 
-        this.push_field("outlined", Value::Bool(self.outlined(styles)));
-        this.push_field("numbers", numbers);
-
-        let meta = Meta::Node(my_id, this.clone());
-        Ok(this.styled(MetaNode::set_data(vec![meta])))
+        let mut node = self.clone().pack();
+        node.push_field("outlined", Value::Bool(self.outlined(styles)));
+        node.push_field("numbers", numbers);
+        let meta = Meta::Node(my_id, node.clone());
+        Ok(node.styled(MetaNode::set_data(vec![meta])))
     }
 }
 
 impl Show for HeadingNode {
-    fn show(&self, _: &mut Vt, this: &Content, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body();
-        let numbers = this.field("numbers").unwrap();
+        let numbers = self.0.field("numbers").unwrap();
         if *numbers != Value::None {
             realized = numbers.clone().display()
                 + HNode::new(Em::new(0.3).into()).with_weak(true).pack()
diff --git a/library/src/meta/link.rs b/library/src/meta/link.rs
index 572c55b43..4aba36974 100644
--- a/library/src/meta/link.rs
+++ b/library/src/meta/link.rs
@@ -78,7 +78,7 @@ impl LinkNode {
 }
 
 impl Show for LinkNode {
-    fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         Ok(self.body())
     }
 }
diff --git a/library/src/meta/outline.rs b/library/src/meta/outline.rs
index 9e5614aaa..d66a573d4 100644
--- a/library/src/meta/outline.rs
+++ b/library/src/meta/outline.rs
@@ -70,12 +70,7 @@ pub struct OutlineNode {
 }
 
 impl Prepare for OutlineNode {
-    fn prepare(
-        &self,
-        vt: &mut Vt,
-        mut this: Content,
-        _: StyleChain,
-    ) -> SourceResult<Content> {
+    fn prepare(&self, vt: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         let headings = vt
             .locate(Selector::node::<HeadingNode>())
             .into_iter()
@@ -84,18 +79,14 @@ impl Prepare for OutlineNode {
             .map(|node| Value::Content(node.clone()))
             .collect();
 
-        this.push_field("headings", Value::Array(Array::from_vec(headings)));
-        Ok(this)
+        let mut node = self.clone().pack();
+        node.push_field("headings", Value::Array(Array::from_vec(headings)));
+        Ok(node)
     }
 }
 
 impl Show for OutlineNode {
-    fn show(
-        &self,
-        vt: &mut Vt,
-        _: &Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content> {
+    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         let mut seq = vec![ParbreakNode::new().pack()];
         if let Some(title) = self.title(styles) {
             let title = title.clone().unwrap_or_else(|| {
diff --git a/library/src/meta/reference.rs b/library/src/meta/reference.rs
index 20354556a..bfc317854 100644
--- a/library/src/meta/reference.rs
+++ b/library/src/meta/reference.rs
@@ -25,7 +25,7 @@ pub struct RefNode {
 }
 
 impl Show for RefNode {
-    fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         Ok(TextNode::packed(eco_format!("@{}", self.target())))
     }
 }
diff --git a/library/src/text/deco.rs b/library/src/text/deco.rs
index 4dadf45a8..27d302863 100644
--- a/library/src/text/deco.rs
+++ b/library/src/text/deco.rs
@@ -66,7 +66,7 @@ pub struct UnderlineNode {
 }
 
 impl Show for UnderlineNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(TextNode::set_deco(Decoration {
             line: DecoLine::Underline,
             stroke: self.stroke(styles).unwrap_or_default(),
@@ -145,7 +145,7 @@ pub struct OverlineNode {
 }
 
 impl Show for OverlineNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(TextNode::set_deco(Decoration {
             line: DecoLine::Overline,
             stroke: self.stroke(styles).unwrap_or_default(),
@@ -209,7 +209,7 @@ pub struct StrikeNode {
 }
 
 impl Show for StrikeNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(TextNode::set_deco(Decoration {
             line: DecoLine::Strikethrough,
             stroke: self.stroke(styles).unwrap_or_default(),
diff --git a/library/src/text/misc.rs b/library/src/text/misc.rs
index 60521f12c..029e15f4c 100644
--- a/library/src/text/misc.rs
+++ b/library/src/text/misc.rs
@@ -99,7 +99,7 @@ pub struct StrongNode {
 }
 
 impl Show for StrongNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(TextNode::set_delta(Delta(self.delta(styles)))))
     }
 }
@@ -159,7 +159,7 @@ pub struct EmphNode {
 }
 
 impl Show for EmphNode {
-    fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, _: StyleChain) -> SourceResult<Content> {
         Ok(self.body().styled(TextNode::set_emph(Toggle)))
     }
 }
diff --git a/library/src/text/raw.rs b/library/src/text/raw.rs
index 3768e65ed..72dd1782c 100644
--- a/library/src/text/raw.rs
+++ b/library/src/text/raw.rs
@@ -104,19 +104,15 @@ pub struct RawNode {
 }
 
 impl Prepare for RawNode {
-    fn prepare(
-        &self,
-        _: &mut Vt,
-        mut this: Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content> {
-        this.push_field("lang", self.lang(styles).clone());
-        Ok(this)
+    fn prepare(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
+        let mut node = self.clone().pack();
+        node.push_field("lang", self.lang(styles).clone());
+        Ok(node)
     }
 }
 
 impl Show for RawNode {
-    fn show(&self, _: &mut Vt, _: &Content, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         let text = self.text();
         let lang = self.lang(styles).as_ref().map(|s| s.to_lowercase());
         let foreground = THEME
@@ -279,7 +275,6 @@ pub static THEME: Lazy<synt::Theme> = Lazy::new(|| synt::Theme {
         item("support.macro", Some("#16718d"), None),
         item("meta.annotation", Some("#301414"), None),
         item("entity.other, meta.interpolation", Some("#8b41b1"), None),
-        item("invalid", Some("#ff0000"), None),
     ],
 });
 
diff --git a/library/src/text/shift.rs b/library/src/text/shift.rs
index acd46d4e1..20cfaa499 100644
--- a/library/src/text/shift.rs
+++ b/library/src/text/shift.rs
@@ -47,12 +47,7 @@ pub struct SubNode {
 }
 
 impl Show for SubNode {
-    fn show(
-        &self,
-        vt: &mut Vt,
-        _: &Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content> {
+    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body();
         let mut transformed = None;
         if self.typographic(styles) {
@@ -114,12 +109,7 @@ pub struct SuperNode {
 }
 
 impl Show for SuperNode {
-    fn show(
-        &self,
-        vt: &mut Vt,
-        _: &Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content> {
+    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body();
         let mut transformed = None;
         if self.typographic(styles) {
diff --git a/macros/src/node.rs b/macros/src/node.rs
index 92faf7ddc..f89ee8df8 100644
--- a/macros/src/node.rs
+++ b/macros/src/node.rs
@@ -186,7 +186,7 @@ fn create(node: &Node) -> TokenStream {
             #(#field_style_methods)*
 
             /// The node's span.
-            pub fn span(&self) -> Option<::typst::syntax::Span> {
+            pub fn span(&self) -> ::typst::syntax::Span {
                 self.0.span()
             }
         }
@@ -228,7 +228,7 @@ fn create_field_method(field: &Field) -> TokenStream {
         quote! {
             #[doc = #docs]
             #vis fn #ident(&self) -> #output {
-                self.0.cast_required_field(#name)
+                self.0.field(#name).unwrap().clone().cast().unwrap()
             }
         }
     } else {
@@ -319,19 +319,8 @@ fn create_node_impl(node: &Node) -> TokenStream {
                 static META: ::typst::model::NodeMeta = ::typst::model::NodeMeta {
                     name: #name,
                     vtable: #vtable_func,
-                };
-                ::typst::model::NodeId::from_meta(&META)
-            }
-
-            fn pack(self) -> ::typst::model::Content {
-                self.0
-            }
-
-            fn func() -> ::typst::eval::NodeFunc {
-                ::typst::eval::NodeFunc {
-                    id: Self::id(),
-                    construct: <Self as ::typst::model::Construct>::construct,
-                    set: <Self as ::typst::model::Set>::set,
+                    construct: <#ident as ::typst::model::Construct>::construct,
+                    set: <#ident as ::typst::model::Set>::set,
                     info: ::typst::eval::Lazy::new(|| typst::eval::FuncInfo {
                         name: #name,
                         display: #display,
@@ -340,7 +329,12 @@ fn create_node_impl(node: &Node) -> TokenStream {
                         returns: ::std::vec!["content"],
                         category: #category,
                     }),
-                }
+                };
+                ::typst::model::NodeId(&META)
+            }
+
+            fn pack(self) -> ::typst::model::Content {
+                self.0
             }
         }
     }
diff --git a/src/eval/args.rs b/src/eval/args.rs
index 159e9a776..17bd9cb40 100644
--- a/src/eval/args.rs
+++ b/src/eval/args.rs
@@ -1,10 +1,11 @@
-use std::fmt::{self, Debug, Formatter, Write};
+use std::fmt::{self, Debug, Formatter};
 
-use ecow::EcoVec;
+use ecow::{eco_format, EcoVec};
 
 use super::{Array, Cast, Dict, Str, Value};
 use crate::diag::{bail, At, SourceResult};
 use crate::syntax::{Span, Spanned};
+use crate::util::pretty_array;
 
 /// Evaluated arguments to a function.
 #[derive(Clone, PartialEq, Hash)]
@@ -171,14 +172,9 @@ impl Args {
 
 impl Debug for Args {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_char('(')?;
-        for (i, arg) in self.items.iter().enumerate() {
-            arg.fmt(f)?;
-            if i + 1 < self.items.len() {
-                f.write_str(", ")?;
-            }
-        }
-        f.write_char(')')
+        let pieces: Vec<_> =
+            self.items.iter().map(|arg| eco_format!("{arg:?}")).collect();
+        f.write_str(&pretty_array(&pieces, false))
     }
 }
 
diff --git a/src/eval/array.rs b/src/eval/array.rs
index 53bae06fb..8da9b3d26 100644
--- a/src/eval/array.rs
+++ b/src/eval/array.rs
@@ -1,11 +1,12 @@
 use std::cmp::Ordering;
-use std::fmt::{self, Debug, Formatter, Write};
+use std::fmt::{self, Debug, Formatter};
 use std::ops::{Add, AddAssign};
 
 use ecow::{eco_format, EcoString, EcoVec};
 
 use super::{ops, Args, Func, Value, Vm};
 use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::util::pretty_array;
 
 /// Create a new [`Array`] from values.
 #[macro_export]
@@ -147,7 +148,6 @@ impl Array {
                 return Ok(Some(item.clone()));
             }
         }
-
         Ok(None)
     }
 
@@ -262,6 +262,14 @@ impl Array {
         self.0.iter().cloned().rev().collect()
     }
 
+    /// Split all values in the array.
+    pub fn split(&self, at: Value) -> Array {
+        self.as_slice()
+            .split(|value| *value == at)
+            .map(|subslice| Value::Array(subslice.iter().cloned().collect()))
+            .collect()
+    }
+
     /// Join all values in the array, optionally with separator and last
     /// separator (between the final two items).
     pub fn join(&self, sep: Option<Value>, mut last: Option<Value>) -> StrResult<Value> {
@@ -332,31 +340,10 @@ impl Array {
     }
 }
 
-/// The out of bounds access error message.
-#[cold]
-fn out_of_bounds(index: i64, len: i64) -> EcoString {
-    eco_format!("array index out of bounds (index: {}, len: {})", index, len)
-}
-
-/// The error message when the array is empty.
-#[cold]
-fn array_is_empty() -> EcoString {
-    "array is empty".into()
-}
-
 impl Debug for Array {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_char('(')?;
-        for (i, value) in self.iter().enumerate() {
-            value.fmt(f)?;
-            if i + 1 < self.0.len() {
-                f.write_str(", ")?;
-            }
-        }
-        if self.len() == 1 {
-            f.write_char(',')?;
-        }
-        f.write_char(')')
+        let pieces: Vec<_> = self.iter().map(|value| eco_format!("{value:?}")).collect();
+        f.write_str(&pretty_array(&pieces, self.len() == 1))
     }
 }
 
@@ -404,3 +391,15 @@ impl<'a> IntoIterator for &'a Array {
         self.iter()
     }
 }
+
+/// The error message when the array is empty.
+#[cold]
+fn array_is_empty() -> EcoString {
+    "array is empty".into()
+}
+
+/// The out of bounds access error message.
+#[cold]
+fn out_of_bounds(index: i64, len: i64) -> EcoString {
+    eco_format!("array index out of bounds (index: {}, len: {})", index, len)
+}
diff --git a/src/eval/dict.rs b/src/eval/dict.rs
index 6c1934c9c..ececce071 100644
--- a/src/eval/dict.rs
+++ b/src/eval/dict.rs
@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::fmt::{self, Debug, Formatter, Write};
+use std::fmt::{self, Debug, Formatter};
 use std::ops::{Add, AddAssign};
 use std::sync::Arc;
 
@@ -8,7 +8,7 @@ use ecow::{eco_format, EcoString};
 use super::{array, Array, Str, Value};
 use crate::diag::StrResult;
 use crate::syntax::is_ident;
-use crate::util::ArcExt;
+use crate::util::{pretty_array, ArcExt};
 
 /// Create a new [`Dict`] from key-value pairs.
 #[macro_export]
@@ -132,31 +132,24 @@ impl Dict {
     }
 }
 
-/// The missing key access error message.
-#[cold]
-fn missing_key(key: &str) -> EcoString {
-    eco_format!("dictionary does not contain key {:?}", Str::from(key))
-}
-
 impl Debug for Dict {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_char('(')?;
         if self.is_empty() {
-            f.write_char(':')?;
+            return f.write_str("(:)");
         }
-        for (i, (key, value)) in self.iter().enumerate() {
-            if is_ident(key) {
-                f.write_str(key)?;
-            } else {
-                write!(f, "{key:?}")?;
-            }
-            f.write_str(": ")?;
-            value.fmt(f)?;
-            if i + 1 < self.0.len() {
-                f.write_str(", ")?;
-            }
-        }
-        f.write_char(')')
+
+        let pieces: Vec<_> = self
+            .iter()
+            .map(|(key, value)| {
+                if is_ident(key) {
+                    eco_format!("{key}: {value:?}")
+                } else {
+                    eco_format!("{key:?}: {value:?}")
+                }
+            })
+            .collect();
+
+        f.write_str(&pretty_array(&pieces, false))
     }
 }
 
@@ -207,3 +200,9 @@ impl<'a> IntoIterator for &'a Dict {
         self.iter()
     }
 }
+
+/// The missing key access error message.
+#[cold]
+fn missing_key(key: &str) -> EcoString {
+    eco_format!("dictionary does not contain key {:?}", Str::from(key))
+}
diff --git a/src/eval/func.rs b/src/eval/func.rs
index 79ae142cb..8da5c6bc1 100644
--- a/src/eval/func.rs
+++ b/src/eval/func.rs
@@ -13,7 +13,7 @@ use super::{
     Vm,
 };
 use crate::diag::{bail, SourceResult, StrResult};
-use crate::model::{Content, NodeId, Selector, StyleMap};
+use crate::model::{NodeId, Selector, StyleMap};
 use crate::syntax::ast::{self, AstNode, Expr};
 use crate::syntax::{SourceId, Span, SyntaxNode};
 use crate::util::hash128;
@@ -29,7 +29,7 @@ enum Repr {
     /// A native Rust function.
     Native(NativeFunc),
     /// A function for a node.
-    Node(NodeFunc),
+    Node(NodeId),
     /// A user-defined closure.
     Closure(Closure),
     /// A nested function with pre-applied arguments.
@@ -156,13 +156,13 @@ impl Func {
 
     /// Create a selector for this function's node type.
     pub fn select(&self, fields: Option<Dict>) -> StrResult<Selector> {
-        match &**self.0 {
-            Repr::Node(node) => {
-                if node.id == item!(text_id) {
+        match **self.0 {
+            Repr::Node(id) => {
+                if id == item!(text_id) {
                     Err("to select text, please use a string or regex instead")?;
                 }
 
-                Ok(Selector::Node(node.id, fields))
+                Ok(Selector::Node(id, fields))
             }
             _ => Err("this function is not selectable")?,
         }
@@ -172,8 +172,8 @@ impl Func {
 impl Debug for Func {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self.name() {
-            Some(name) => write!(f, "<function {name}>"),
-            None => f.write_str("<function>"),
+            Some(name) => write!(f, "{name}"),
+            None => f.write_str("(..) => .."),
         }
     }
 }
@@ -190,6 +190,16 @@ impl From<Repr> for Func {
     }
 }
 
+impl From<NodeId> for Func {
+    fn from(id: NodeId) -> Self {
+        Repr::Node(id).into()
+    }
+}
+
+cast_to_value! {
+    v: NodeId => Value::Func(v.into())
+}
+
 /// A native Rust function.
 pub struct NativeFunc {
     /// The function's implementation.
@@ -223,36 +233,6 @@ where
     }
 }
 
-/// A function defined by a native Rust node.
-pub struct NodeFunc {
-    /// The node's id.
-    pub id: NodeId,
-    /// The node's constructor.
-    pub construct: fn(&Vm, &mut Args) -> SourceResult<Content>,
-    /// The node's set rule.
-    pub set: fn(&mut Args) -> SourceResult<StyleMap>,
-    /// Details about the function.
-    pub info: Lazy<FuncInfo>,
-}
-
-impl Hash for NodeFunc {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-        (self.construct as usize).hash(state);
-        (self.set as usize).hash(state);
-    }
-}
-
-impl From<NodeFunc> for Func {
-    fn from(node: NodeFunc) -> Self {
-        Repr::Node(node).into()
-    }
-}
-
-cast_to_value! {
-    v: NodeFunc => Value::Func(v.into())
-}
-
 /// Details about a function.
 #[derive(Debug, Clone)]
 pub struct FuncInfo {
diff --git a/src/eval/methods.rs b/src/eval/methods.rs
index dcb1ca313..197a2f653 100644
--- a/src/eval/methods.rs
+++ b/src/eval/methods.rs
@@ -69,6 +69,13 @@ pub fn call(
             _ => return missing(),
         },
 
+        Value::Content(content) => match method {
+            "func" => Value::Func(content.id().into()),
+            "has" => Value::Bool(content.has(&args.expect::<EcoString>("field")?)),
+            "at" => content.at(&args.expect::<EcoString>("field")?).at(span)?.clone(),
+            _ => return missing(),
+        },
+
         Value::Array(array) => match method {
             "len" => Value::Int(array.len()),
             "first" => array.first().at(span)?.clone(),
@@ -96,6 +103,7 @@ pub fn call(
             "all" => Value::Bool(array.all(vm, args.expect("function")?)?),
             "flatten" => Value::Array(array.flatten()),
             "rev" => Value::Array(array.rev()),
+            "split" => Value::Array(array.split(args.expect("separator")?)),
             "join" => {
                 let sep = args.eat()?;
                 let last = args.named("last")?;
@@ -107,7 +115,7 @@ pub fn call(
 
         Value::Dict(dict) => match method {
             "len" => Value::Int(dict.len()),
-            "at" => dict.at(&args.expect::<Str>("key")?).cloned().at(span)?,
+            "at" => dict.at(&args.expect::<Str>("key")?).at(span)?.clone(),
             "keys" => Value::Array(dict.keys()),
             "values" => Value::Array(dict.values()),
             "pairs" => Value::Array(dict.pairs()),
@@ -237,6 +245,7 @@ pub fn methods_on(type_name: &str) -> &[(&'static str, bool)] {
             ("starts-with", true),
             ("trim", true),
         ],
+        "content" => &[("func", false), ("has", true), ("at", true)],
         "array" => &[
             ("all", true),
             ("any", true),
@@ -248,6 +257,7 @@ pub fn methods_on(type_name: &str) -> &[(&'static str, bool)] {
             ("flatten", false),
             ("fold", true),
             ("insert", true),
+            ("split", true),
             ("join", true),
             ("last", false),
             ("len", false),
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index fcfda2634..145f961ae 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -47,6 +47,7 @@ use unicode_segmentation::UnicodeSegmentation;
 use crate::diag::{
     bail, error, At, SourceError, SourceResult, StrResult, Trace, Tracepoint,
 };
+use crate::model::Unlabellable;
 use crate::model::{Content, Label, Recipe, Selector, StyleMap, Transform};
 use crate::syntax::ast::AstNode;
 use crate::syntax::{
@@ -357,12 +358,12 @@ fn eval_markup(
                 }
 
                 let tail = eval_markup(vm, exprs)?;
-                seq.push(tail.apply_recipe(vm.world, recipe)?)
+                seq.push(tail.styled_with_recipe(vm.world, recipe)?)
             }
             expr => match expr.eval(vm)? {
                 Value::Label(label) => {
                     if let Some(node) =
-                        seq.iter_mut().rev().find(|node| node.labellable())
+                        seq.iter_mut().rev().find(|node| !node.can::<dyn Unlabellable>())
                     {
                         *node = mem::take(node).labelled(label);
                     }
@@ -786,7 +787,7 @@ fn eval_code(
                 }
 
                 let tail = eval_code(vm, exprs)?.display();
-                Value::Content(tail.apply_recipe(vm.world, recipe)?)
+                Value::Content(tail.styled_with_recipe(vm.world, recipe)?)
             }
             _ => expr.eval(vm)?,
         };
@@ -979,6 +980,10 @@ impl Eval for ast::FuncCall {
 
     fn eval(&self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let span = self.span();
+        if vm.depth >= MAX_CALL_DEPTH {
+            bail!(span, "maximum function call depth exceeded");
+        }
+
         let callee = self.callee();
         let in_math = in_math(&callee);
         let callee_span = callee.span();
@@ -1042,11 +1047,6 @@ impl Eval for ast::FuncCall {
             ));
         }
 
-        // Finally, just a normal function call!
-        if vm.depth >= MAX_CALL_DEPTH {
-            bail!(span, "maximum function call depth exceeded");
-        }
-
         let callee = callee.cast::<Func>().at(callee_span)?;
         let point = || Tracepoint::Call(callee.name().map(Into::into));
         callee.call(vm, args).trace(vm.world, point, span)
diff --git a/src/eval/ops.rs b/src/eval/ops.rs
index 52b9b06a3..5efb68c37 100644
--- a/src/eval/ops.rs
+++ b/src/eval/ops.rs
@@ -340,6 +340,7 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
         (Symbol(a), Symbol(b)) => a == b,
         (Str(a), Str(b)) => a == b,
         (Label(a), Label(b)) => a == b,
+        (Content(a), Content(b)) => a == b,
         (Array(a), Array(b)) => a == b,
         (Dict(a), Dict(b)) => a == b,
         (Func(a), Func(b)) => a == b,
diff --git a/src/eval/value.rs b/src/eval/value.rs
index 9b9bc3149..61af36f5a 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -120,10 +120,7 @@ impl Value {
         match self {
             Self::Symbol(symbol) => symbol.clone().modified(&field).map(Self::Symbol),
             Self::Dict(dict) => dict.at(&field).cloned(),
-            Self::Content(content) => content
-                .field(&field)
-                .cloned()
-                .ok_or_else(|| eco_format!("unknown field `{field}`")),
+            Self::Content(content) => content.at(&field).cloned(),
             Self::Module(module) => module.get(&field).cloned(),
             v => Err(eco_format!("cannot access fields on type {}", v.type_name())),
         }
@@ -190,7 +187,7 @@ impl Debug for Value {
             Self::Symbol(v) => Debug::fmt(v, f),
             Self::Str(v) => Debug::fmt(v, f),
             Self::Label(v) => Debug::fmt(v, f),
-            Self::Content(_) => f.pad("[...]"),
+            Self::Content(v) => Debug::fmt(v, f),
             Self::Array(v) => Debug::fmt(v, f),
             Self::Dict(v) => Debug::fmt(v, f),
             Self::Func(v) => Debug::fmt(v, f),
diff --git a/src/ide/tooltip.rs b/src/ide/tooltip.rs
index ac0cb60b3..4f2810504 100644
--- a/src/ide/tooltip.rs
+++ b/src/ide/tooltip.rs
@@ -1,11 +1,15 @@
+use std::fmt::Write;
+
+use ecow::EcoString;
+
 use if_chain::if_chain;
-use unicode_segmentation::UnicodeSegmentation;
 
 use super::{analyze_expr, plain_docs_sentence, summarize_font_family};
 use crate::eval::{CastInfo, Tracer, Value};
 use crate::geom::{round_2, Length, Numeric};
 use crate::syntax::ast;
 use crate::syntax::{LinkedNode, Source, SyntaxKind};
+use crate::util::pretty_comma_list;
 use crate::World;
 
 /// Describe the item under the cursor.
@@ -60,31 +64,27 @@ fn expr_tooltip(world: &(dyn World + 'static), leaf: &LinkedNode) -> Option<Tool
         return None;
     }
 
-    let mut tooltip = String::new();
-    let mut iter = values.into_iter().enumerate();
-    for (i, value) in (&mut iter).take(Tracer::MAX - 1) {
-        if i > 0 && !tooltip.is_empty() {
-            tooltip.push_str(", ");
-        }
-        let repr = value.repr();
-        let repr = repr.as_str();
-        let len = repr.len();
-        if len <= 40 {
-            tooltip.push_str(repr);
-        } else {
-            let mut graphemes = repr.graphemes(true);
-            let r = graphemes.next_back().map_or(0, str::len);
-            let l = graphemes.take(40).map(str::len).sum();
-            tooltip.push_str(&repr[..l]);
-            tooltip.push_str("...");
-            tooltip.push_str(&repr[len - r..]);
+    let mut last = None;
+    let mut pieces: Vec<EcoString> = vec![];
+    let mut iter = values.iter();
+    for value in (&mut iter).take(Tracer::MAX - 1) {
+        if let Some((prev, count)) = &mut last {
+            if *prev == value {
+                *count += 1;
+                continue;
+            } else if *count > 1 {
+                write!(pieces.last_mut().unwrap(), " (x{count})").unwrap();
+            }
         }
+        pieces.push(value.repr().into());
+        last = Some((value, 1));
     }
 
     if iter.next().is_some() {
-        tooltip.push_str(", ...");
+        pieces.push("...".into());
     }
 
+    let tooltip = pretty_comma_list(&pieces, false);
     (!tooltip.is_empty()).then(|| Tooltip::Code(tooltip))
 }
 
diff --git a/src/model/content.rs b/src/model/content.rs
index d845ce1e7..b895553c5 100644
--- a/src/model/content.rs
+++ b/src/model/content.rs
@@ -2,22 +2,24 @@ use std::any::TypeId;
 use std::fmt::{self, Debug, Formatter, Write};
 use std::hash::{Hash, Hasher};
 use std::iter::{self, Sum};
-use std::ops::{Add, AddAssign};
+use std::ops::{Add, AddAssign, Deref};
 
 use comemo::Tracked;
-use ecow::{EcoString, EcoVec};
+use ecow::{eco_format, EcoString, EcoVec};
+use once_cell::sync::Lazy;
 
 use super::{node, Guard, Recipe, Style, StyleMap};
 use crate::diag::{SourceResult, StrResult};
-use crate::eval::{cast_from_value, Args, Cast, NodeFunc, Value, Vm};
+use crate::eval::{cast_from_value, Args, FuncInfo, Str, Value, Vm};
 use crate::syntax::Span;
+use crate::util::pretty_array;
 use crate::World;
 
 /// Composable representation of styled content.
 #[derive(Clone, Hash)]
 pub struct Content {
     id: NodeId,
-    span: Option<Span>,
+    span: Span,
     fields: EcoVec<(EcoString, Value)>,
     modifiers: EcoVec<Modifier>,
 }
@@ -33,7 +35,7 @@ impl Content {
     pub fn new<T: Node>() -> Self {
         Self {
             id: T::id(),
-            span: None,
+            span: Span::detached(),
             fields: EcoVec::new(),
             modifiers: EcoVec::new(),
         }
@@ -52,82 +54,67 @@ impl Content {
         }
     }
 
-    /// Attach a span to the content.
-    pub fn spanned(mut self, span: Span) -> Self {
-        if let Some(styled) = self.to::<StyledNode>() {
-            self = StyledNode::new(styled.map(), styled.body().spanned(span)).pack();
-        }
-        self.span = Some(span);
-        self
-    }
-
-    /// Attach a label to the content.
-    pub fn labelled(self, label: Label) -> Self {
-        self.with_field("label", label)
-    }
-
-    /// Style this content with a style entry.
-    pub fn styled(self, style: impl Into<Style>) -> Self {
-        self.styled_with_map(style.into().into())
-    }
-
-    /// Style this content with a full style map.
-    pub fn styled_with_map(self, styles: StyleMap) -> Self {
-        if styles.is_empty() {
-            self
-        } else if let Some(styled) = self.to::<StyledNode>() {
-            let mut map = styled.map();
-            map.apply(styles);
-            StyledNode::new(map, styled.body()).pack()
-        } else {
-            StyledNode::new(styles, self).pack()
-        }
-    }
-
-    /// Style this content with a recipe, eagerly applying it if possible.
-    pub fn apply_recipe(
-        self,
-        world: Tracked<dyn World>,
-        recipe: Recipe,
-    ) -> SourceResult<Self> {
-        if recipe.selector.is_none() {
-            recipe.apply(world, self)
-        } else {
-            Ok(self.styled(Style::Recipe(recipe)))
-        }
-    }
-
-    /// Repeat this content `n` times.
-    pub fn repeat(&self, n: i64) -> StrResult<Self> {
-        let count = usize::try_from(n)
-            .map_err(|_| format!("cannot repeat this content {} times", n))?;
-
-        Ok(Self::sequence(vec![self.clone(); count]))
-    }
-}
-
-impl Content {
     /// The id of the contained node.
     pub fn id(&self) -> NodeId {
         self.id
     }
 
-    /// The node's human-readable name.
-    pub fn name(&self) -> &'static str {
-        self.id.name()
+    /// Whether the contained node is of type `T`.
+    pub fn is<T>(&self) -> bool
+    where
+        T: Node + 'static,
+    {
+        self.id == NodeId::of::<T>()
+    }
+
+    /// Cast to `T` if the contained node is of type `T`.
+    pub fn to<T>(&self) -> Option<&T>
+    where
+        T: Node + 'static,
+    {
+        self.is::<T>().then(|| unsafe { std::mem::transmute(self) })
+    }
+
+    /// Whether this content has the given capability.
+    pub fn can<C>(&self) -> bool
+    where
+        C: ?Sized + 'static,
+    {
+        (self.id.0.vtable)(TypeId::of::<C>()).is_some()
+    }
+
+    /// Cast to a trait object if this content has the given capability.
+    pub fn with<C>(&self) -> Option<&C>
+    where
+        C: ?Sized + 'static,
+    {
+        let vtable = (self.id.0.vtable)(TypeId::of::<C>())?;
+        let data = self as *const Self as *const ();
+        Some(unsafe { &*crate::util::fat::from_raw_parts(data, vtable) })
     }
 
     /// The node's span.
-    pub fn span(&self) -> Option<Span> {
+    pub fn span(&self) -> Span {
         self.span
     }
 
-    /// The content's label.
-    pub fn label(&self) -> Option<&Label> {
-        match self.field("label")? {
-            Value::Label(label) => Some(label),
-            _ => None,
-        }
+    /// Attach a span to the content.
+    pub fn spanned(mut self, span: Span) -> Self {
+        self.span = span;
+        self
+    }
+
+    /// Access a field on the content.
+    pub fn field(&self, name: &str) -> Option<&Value> {
+        self.fields
+            .iter()
+            .find(|(field, _)| field == name)
+            .map(|(_, value)| value)
+    }
+
+    /// List all fields on the content.
+    pub fn fields(&self) -> &[(EcoString, Value)] {
+        &self.fields
     }
 
     /// Attach a field to the content.
@@ -150,88 +137,88 @@ impl Content {
         }
     }
 
-    /// Access a field on the content.
-    pub fn field(&self, name: &str) -> Option<&Value> {
-        static NONE: Value = Value::None;
-        self.fields
-            .iter()
-            .find(|(field, _)| field == name)
-            .map(|(_, value)| value)
-            .or_else(|| (name == "label").then(|| &NONE))
+    /// Whether the content has the specified field.
+    pub fn has(&self, field: &str) -> bool {
+        self.field(field).is_some()
     }
 
-    #[track_caller]
-    pub fn cast_required_field<T: Cast>(&self, name: &str) -> T {
-        match self.field(name) {
-            Some(value) => value.clone().cast().unwrap(),
-            None => field_is_missing(name),
+    /// Borrow the value of the given field.
+    pub fn at(&self, field: &str) -> StrResult<&Value> {
+        self.field(field).ok_or_else(|| missing_field(field))
+    }
+
+    /// The content's label.
+    pub fn label(&self) -> Option<&Label> {
+        match self.field("label")? {
+            Value::Label(label) => Some(label),
+            _ => None,
         }
     }
 
-    /// List all fields on the content.
-    pub fn fields(&self) -> &[(EcoString, Value)] {
-        &self.fields
+    /// Attach a label to the content.
+    pub fn labelled(self, label: Label) -> Self {
+        self.with_field("label", label)
     }
 
-    /// Whether the contained node is of type `T`.
-    pub fn is<T>(&self) -> bool
-    where
-        T: Node + 'static,
-    {
-        self.id == NodeId::of::<T>()
+    /// Style this content with a style entry.
+    pub fn styled(self, style: impl Into<Style>) -> Self {
+        self.styled_with_map(style.into().into())
     }
 
-    /// Cast to `T` if the contained node is of type `T`.
-    pub fn to<T>(&self) -> Option<&T>
-    where
-        T: Node + 'static,
-    {
-        self.is::<T>().then(|| unsafe { std::mem::transmute(self) })
+    /// Style this content with a full style map.
+    pub fn styled_with_map(self, styles: StyleMap) -> Self {
+        if styles.is_empty() {
+            self
+        } else if let Some(styled) = self.to::<StyledNode>() {
+            let mut map = styled.styles();
+            map.apply(styles);
+            StyledNode::new(map, styled.body()).pack()
+        } else {
+            StyledNode::new(styles, self).pack()
+        }
     }
 
-    /// Whether this content has the given capability.
-    pub fn has<C>(&self) -> bool
-    where
-        C: ?Sized + 'static,
-    {
-        (self.id.0.vtable)(TypeId::of::<C>()).is_some()
+    /// Style this content with a recipe, eagerly applying it if possible.
+    pub fn styled_with_recipe(
+        self,
+        world: Tracked<dyn World>,
+        recipe: Recipe,
+    ) -> SourceResult<Self> {
+        if recipe.selector.is_none() {
+            recipe.apply(world, self)
+        } else {
+            Ok(self.styled(Style::Recipe(recipe)))
+        }
     }
 
-    /// Cast to a trait object if this content has the given capability.
-    pub fn with<C>(&self) -> Option<&C>
-    where
-        C: ?Sized + 'static,
-    {
-        let vtable = (self.id.0.vtable)(TypeId::of::<C>())?;
-        let data = self as *const Self as *const ();
-        Some(unsafe { &*crate::util::fat::from_raw_parts(data, vtable) })
-    }
+    /// Repeat this content `n` times.
+    pub fn repeat(&self, n: i64) -> StrResult<Self> {
+        let count = usize::try_from(n)
+            .map_err(|_| format!("cannot repeat this content {} times", n))?;
 
+        Ok(Self::sequence(vec![self.clone(); count]))
+    }
+}
+
+#[doc(hidden)]
+impl Content {
     /// Disable a show rule recipe.
-    #[doc(hidden)]
     pub fn guarded(mut self, id: Guard) -> Self {
         self.modifiers.push(Modifier::Guard(id));
         self
     }
 
     /// Mark this content as prepared.
-    #[doc(hidden)]
     pub fn prepared(mut self) -> Self {
         self.modifiers.push(Modifier::Prepared);
         self
     }
 
     /// Whether this node was prepared.
-    #[doc(hidden)]
     pub fn is_prepared(&self) -> bool {
         self.modifiers.contains(&Modifier::Prepared)
     }
 
-    /// Whether a label can be attached to the content.
-    pub(crate) fn labellable(&self) -> bool {
-        !self.has::<dyn Unlabellable>()
-    }
-
     /// Whether no show rule was executed for this node so far.
     pub(super) fn is_pristine(&self) -> bool {
         !self
@@ -257,32 +244,24 @@ impl Content {
 
 impl Debug for Content {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        struct Pad<'a>(&'a str);
-        impl Debug for Pad<'_> {
-            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-                f.pad(self.0)
-            }
+        let name = self.id.name;
+        if let Some(text) = item!(text_str)(self) {
+            f.write_char('[')?;
+            f.write_str(&text)?;
+            f.write_char(']')?;
+            return Ok(());
+        } else if name == "space" {
+            return f.write_str("[ ]");
         }
 
-        if let Some(styled) = self.to::<StyledNode>() {
-            styled.map().fmt(f)?;
-            styled.body().fmt(f)
-        } else if let Some(seq) = self.to::<SequenceNode>() {
-            f.debug_list().entries(&seq.children()).finish()
-        } else if self.id.name() == "space" {
-            ' '.fmt(f)
-        } else if self.id.name() == "text" {
-            self.field("text").unwrap().fmt(f)
-        } else {
-            f.write_str(self.name())?;
-            if self.fields.is_empty() {
-                return Ok(());
-            }
-            f.write_char(' ')?;
-            f.debug_map()
-                .entries(self.fields.iter().map(|(name, value)| (Pad(name), value)))
-                .finish()
-        }
+        let pieces: Vec<_> = self
+            .fields
+            .iter()
+            .map(|(name, value)| eco_format!("{name}: {value:?}"))
+            .collect();
+
+        f.write_str(name)?;
+        f.write_str(&pretty_array(&pieces, false))
     }
 }
 
@@ -292,6 +271,17 @@ impl Default for Content {
     }
 }
 
+impl PartialEq for Content {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+            && self.fields.len() == other.fields.len()
+            && self
+                .fields
+                .iter()
+                .all(|(name, value)| other.field(name) == Some(value))
+    }
+}
+
 impl Add for Content {
     type Output = Self;
 
@@ -323,48 +313,6 @@ impl Sum for Content {
     }
 }
 
-/// A node with applied styles.
-///
-/// Display: Styled
-/// Category: special
-#[node]
-pub struct StyledNode {
-    /// The styles.
-    #[required]
-    pub map: StyleMap,
-
-    /// The styled content.
-    #[required]
-    pub body: Content,
-}
-
-cast_from_value! {
-    StyleMap: "style map",
-}
-
-/// A sequence of nodes.
-///
-/// Combines other arbitrary content. So, when you write `[Hi] + [you]` in
-/// Typst, the two text nodes are combined into a single sequence node.
-///
-/// Display: Sequence
-/// Category: special
-#[node]
-pub struct SequenceNode {
-    #[variadic]
-    pub children: Vec<Content>,
-}
-
-/// A label for a node.
-#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub struct Label(pub EcoString);
-
-impl Debug for Label {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "<{}>", self.0)
-    }
-}
-
 /// A constructable, stylable content node.
 pub trait Node: Construct + Set + Sized + 'static {
     /// The node's ID.
@@ -372,33 +320,22 @@ pub trait Node: Construct + Set + Sized + 'static {
 
     /// Pack a node into type-erased content.
     fn pack(self) -> Content;
-
-    /// The node's function.
-    fn func() -> NodeFunc;
 }
 
 /// A unique identifier for a node.
 #[derive(Copy, Clone)]
-pub struct NodeId(&'static NodeMeta);
+pub struct NodeId(pub &'static NodeMeta);
 
 impl NodeId {
+    /// Get the id of a node.
     pub fn of<T: Node>() -> Self {
         T::id()
     }
-
-    pub fn from_meta(meta: &'static NodeMeta) -> Self {
-        Self(meta)
-    }
-
-    /// The name of the identified node.
-    pub fn name(self) -> &'static str {
-        self.0.name
-    }
 }
 
 impl Debug for NodeId {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.pad(self.name())
+        f.pad(self.name)
     }
 }
 
@@ -416,10 +353,26 @@ impl PartialEq for NodeId {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+impl Deref for NodeId {
+    type Target = NodeMeta;
+
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+/// Static node for a node.
 pub struct NodeMeta {
+    /// The node's name.
     pub name: &'static str,
+    /// The node's vtable for caspability dispatch.
     pub vtable: fn(of: TypeId) -> Option<*const ()>,
+    /// The node's constructor.
+    pub construct: fn(&Vm, &mut Args) -> SourceResult<Content>,
+    /// The node's set rule.
+    pub set: fn(&mut Args) -> SourceResult<StyleMap>,
+    /// Details about the function.
+    pub info: Lazy<FuncInfo>,
 }
 
 /// A node's constructor function.
@@ -440,8 +393,51 @@ pub trait Set {
 /// Indicates that a node cannot be labelled.
 pub trait Unlabellable {}
 
+/// A label for a node.
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct Label(pub EcoString);
+
+impl Debug for Label {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "<{}>", self.0)
+    }
+}
+
+/// A sequence of nodes.
+///
+/// Combines other arbitrary content. So, when you write `[Hi] + [you]` in
+/// Typst, the two text nodes are combined into a single sequence node.
+///
+/// Display: Sequence
+/// Category: special
+#[node]
+pub struct SequenceNode {
+    #[variadic]
+    pub children: Vec<Content>,
+}
+
+/// A node with applied styles.
+///
+/// Display: Styled
+/// Category: special
+#[node]
+pub struct StyledNode {
+    /// The styles.
+    #[required]
+    pub styles: StyleMap,
+
+    /// The styled content.
+    #[required]
+    pub body: Content,
+}
+
+cast_from_value! {
+    StyleMap: "style map",
+}
+
+/// The missing key access error message.
 #[cold]
 #[track_caller]
-fn field_is_missing(name: &str) -> ! {
-    panic!("required field `{name}` is missing")
+fn missing_field(key: &str) -> EcoString {
+    eco_format!("content does not contain field {:?}", Str::from(key))
 }
diff --git a/src/model/realize.rs b/src/model/realize.rs
index 502774bba..c4c67a4f1 100644
--- a/src/model/realize.rs
+++ b/src/model/realize.rs
@@ -3,11 +3,11 @@ use crate::diag::SourceResult;
 
 /// Whether the target is affected by show rules in the given style chain.
 pub fn applicable(target: &Content, styles: StyleChain) -> bool {
-    if target.has::<dyn Prepare>() && !target.is_prepared() {
+    if target.can::<dyn Prepare>() && !target.is_prepared() {
         return true;
     }
 
-    if target.has::<dyn Show>() && target.is_pristine() {
+    if target.can::<dyn Show>() && target.is_pristine() {
         return true;
     }
 
@@ -51,7 +51,7 @@ pub fn realize(
     if let Some(showable) = target.with::<dyn Show>() {
         let guard = Guard::Base(target.id());
         if realized.is_none() && !target.is_guarded(guard) {
-            realized = Some(showable.show(vt, target, styles)?);
+            realized = Some(showable.show(vt, styles)?);
         }
     }
 
@@ -135,23 +135,13 @@ fn try_apply(
 /// Preparations before execution of any show rule.
 pub trait Prepare {
     /// Prepare the node for show rule application.
-    fn prepare(
-        &self,
-        vt: &mut Vt,
-        this: Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content>;
+    fn prepare(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content>;
 }
 
 /// The base recipe for a node.
 pub trait Show {
     /// Execute the base recipe for this node.
-    fn show(
-        &self,
-        vt: &mut Vt,
-        this: &Content,
-        styles: StyleChain,
-    ) -> SourceResult<Content>;
+    fn show(&self, vt: &mut Vt, styles: StyleChain) -> SourceResult<Content>;
 }
 
 /// Post-process a node after it was realized.
diff --git a/src/model/styles.rs b/src/model/styles.rs
index 3239bb177..b803bc34c 100644
--- a/src/model/styles.rs
+++ b/src/model/styles.rs
@@ -1,13 +1,14 @@
-use std::fmt::{self, Debug, Formatter};
+use std::fmt::{self, Debug, Formatter, Write};
 use std::iter;
 
 use comemo::Tracked;
-use ecow::EcoString;
+use ecow::{eco_format, EcoString};
 
 use super::{Content, Label, Node, NodeId};
 use crate::diag::{SourceResult, Trace, Tracepoint};
 use crate::eval::{cast_from_value, Args, Cast, Dict, Func, Regex, Value};
 use crate::syntax::Span;
+use crate::util::pretty_array;
 use crate::World;
 
 /// A map of style properties.
@@ -79,10 +80,13 @@ impl PartialEq for StyleMap {
 
 impl Debug for StyleMap {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        for entry in self.0.iter() {
-            writeln!(f, "{:?}", entry)?;
+        if let [style] = self.0.as_slice() {
+            return style.fmt(f);
         }
-        Ok(())
+
+        let pieces: Vec<_> =
+            self.0.iter().map(|value| eco_format!("{value:?}")).collect();
+        f.write_str(&pretty_array(&pieces, false))
     }
 }
 
@@ -160,7 +164,7 @@ impl Property {
 
 impl Debug for Property {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "#set {}({}: {:?})", self.node.name(), self.name, self.value)?;
+        write!(f, "set {}({}: {:?})", self.node.name, self.name, self.value)?;
         Ok(())
     }
 }
@@ -203,12 +207,10 @@ impl Recipe {
             Transform::Func(func) => {
                 let args = Args::new(self.span, [Value::Content(content.clone())]);
                 let mut result = func.call_detached(world, args);
-                if let Some(span) = content.span() {
-                    // For selector-less show rules, a tracepoint makes no sense.
-                    if self.selector.is_some() {
-                        let point = || Tracepoint::Show(content.name().into());
-                        result = result.trace(world, point, span);
-                    }
+                // For selector-less show rules, a tracepoint makes no sense.
+                if self.selector.is_some() {
+                    let point = || Tracepoint::Show(content.id().name.into());
+                    result = result.trace(world, point, content.span());
                 }
                 Ok(result?.display())
             }
@@ -219,12 +221,18 @@ impl Recipe {
 
 impl Debug for Recipe {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "#show {:?}: {:?}", self.selector, self.transform)
+        f.write_str("show")?;
+        if let Some(selector) = &self.selector {
+            f.write_char(' ')?;
+            selector.fmt(f)?;
+        }
+        f.write_str(": ")?;
+        self.transform.fmt(f)
     }
 }
 
 /// A selector in a show rule.
-#[derive(Debug, Clone, PartialEq, Hash)]
+#[derive(Clone, PartialEq, Hash)]
 pub enum Selector {
     /// Matches a specific type of node.
     ///
@@ -267,6 +275,23 @@ impl Selector {
     }
 }
 
+impl Debug for Selector {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Node(node, dict) => {
+                f.write_str(node.name)?;
+                if let Some(dict) = dict {
+                    f.write_str(".where")?;
+                    dict.fmt(f)?;
+                }
+                Ok(())
+            }
+            Self::Label(label) => label.fmt(f),
+            Self::Regex(regex) => regex.fmt(f),
+        }
+    }
+}
+
 cast_from_value! {
     Selector: "selector",
     text: EcoString => Self::text(&text),
@@ -276,7 +301,7 @@ cast_from_value! {
 }
 
 /// A show rule transformation that can be applied to a match.
-#[derive(Debug, Clone, Hash)]
+#[derive(Clone, Hash)]
 pub enum Transform {
     /// Replacement content.
     Content(Content),
@@ -286,6 +311,16 @@ pub enum Transform {
     Style(StyleMap),
 }
 
+impl Debug for Transform {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Content(content) => content.fmt(f),
+            Self::Func(func) => func.fmt(f),
+            Self::Style(styles) => styles.fmt(f),
+        }
+    }
+}
+
 cast_from_value! {
     Transform,
     content: Content => Self::Content(content),
@@ -434,9 +469,9 @@ impl<'a> StyleChain<'a> {
                     .map(|property| property.value.clone()),
             )
             .map(move |value| {
-                value.cast().unwrap_or_else(|err| {
-                    panic!("{} (for {}.{})", err, node.name(), name)
-                })
+                value
+                    .cast()
+                    .unwrap_or_else(|err| panic!("{} (for {}.{})", err, node.name, name))
             })
     }
 
diff --git a/src/util/mod.rs b/src/util/mod.rs
index 54b9fe273..a3fad8cad 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -6,12 +6,12 @@ mod buffer;
 
 pub use buffer::Buffer;
 
-use std::any::TypeId;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::Hash;
 use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 
+use ecow::EcoString;
 use siphasher::sip128::{Hasher128, SipHasher};
 
 /// Turn a closure into a struct implementing [`Debug`].
@@ -133,35 +133,63 @@ impl PathExt for Path {
     }
 }
 
-/// An alternative type id that prints as something readable in debug mode.
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct ReadableTypeId {
-    id: TypeId,
-    #[cfg(debug_assertions)]
-    name: &'static str,
+/// Format something as a a comma-separated list that support horizontal
+/// formatting but falls back to vertical formatting if the pieces are too long.
+pub fn pretty_array(pieces: &[EcoString], trailing_comma: bool) -> String {
+    let list = pretty_comma_list(&pieces, trailing_comma);
+    let mut buf = String::new();
+    buf.push('(');
+    if list.contains('\n') {
+        buf.push('\n');
+        buf.push_str(&indent(&list, 2));
+        buf.push('\n');
+    } else {
+        buf.push_str(&list);
+    }
+    buf.push(')');
+    buf
 }
 
-impl ReadableTypeId {
-    /// The type id of the given type.
-    pub fn of<T: 'static>() -> Self {
-        Self {
-            id: TypeId::of::<T>(),
-            #[cfg(debug_assertions)]
-            name: std::any::type_name::<T>(),
+/// Format something as a a comma-separated list that support horizontal
+/// formatting but falls back to vertical formatting if the pieces are too long.
+pub fn pretty_comma_list(pieces: &[EcoString], trailing_comma: bool) -> String {
+    const MAX_WIDTH: usize = 50;
+
+    let mut buf = String::new();
+    let len = pieces.iter().map(|s| s.len()).sum::<usize>()
+        + 2 * pieces.len().saturating_sub(1);
+
+    if len <= MAX_WIDTH {
+        for (i, piece) in pieces.iter().enumerate() {
+            if i > 0 {
+                buf.push_str(", ");
+            }
+            buf.push_str(piece);
+        }
+        if trailing_comma {
+            buf.push(',');
+        }
+    } else {
+        for piece in pieces {
+            buf.push_str(piece.trim());
+            buf.push_str(",\n");
         }
     }
+
+    buf
 }
 
-impl Debug for ReadableTypeId {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        #[cfg(debug_assertions)]
-        if let Some(part) = self.name.split("::").last() {
-            f.pad(part)?;
+/// Indent a string by two spaces.
+pub fn indent(text: &str, amount: usize) -> String {
+    let mut buf = String::new();
+    for (i, line) in text.lines().enumerate() {
+        if i > 0 {
+            buf.push('\n');
         }
-
-        #[cfg(not(debug_assertions))]
-        f.pad("ReadableTypeId")?;
-
-        Ok(())
+        for _ in 0..amount {
+            buf.push(' ');
+        }
+        buf.push_str(line);
     }
+    buf
 }
diff --git a/tests/ref/compiler/content-field.png b/tests/ref/compiler/content-field.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ad5566afbf04a255d9b845569508ea317ff4633
GIT binary patch
literal 2444
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

literal 0
HcmV?d00001

diff --git a/tests/ref/compiler/repr.png b/tests/ref/compiler/repr.png
index fe0b0c559bd30e2ce54aac6f41d58200682bbe4b..e3bed1befaf5d734c419c9c84d99f7eab16e59e1 100644
GIT binary patch
delta 8288
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

delta 8303
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

diff --git a/tests/typ/compiler/content-field.typ b/tests/typ/compiler/content-field.typ
new file mode 100644
index 000000000..0eeee4584
--- /dev/null
+++ b/tests/typ/compiler/content-field.typ
@@ -0,0 +1,41 @@
+// Integrated test for content fields.
+
+#let compute(formula, ..vars) = {
+  let vars = vars.named()
+  let f(node) = {
+    let func = node.func()
+    if func == text {
+      let text = node.text
+      if regex("^\d+$") in text {
+        int(text)
+      } else if text in vars {
+        int(vars.at(text))
+      } else {
+        panic("unknown math variable: " + text)
+      }
+    } else if func == math.attach {
+      let value = f(node.base)
+      if node.has("top") {
+        value = calc.pow(value, f(node.top))
+      }
+      value
+    } else if node.has("children") {
+      node
+        .children
+        .filter(v => v != [ ])
+        .split[+]
+        .map(xs => xs.fold(1, (prod, v) => prod * f(v)))
+        .fold(0, (sum, v) => sum + v)
+    }
+  }
+  let result = f(formula.body)
+  [With ]
+  vars
+    .pairs()
+    .map(p => $#p.first() = #p.last()$)
+    .join(", ", last: " and ")
+  [ we have:]
+  $ formula = result $
+}
+
+#compute($x y + y^2$, x: 2, y: 3)
diff --git a/tests/typ/compiler/field.typ b/tests/typ/compiler/field.typ
index 27b31f7df..342ae75bb 100644
--- a/tests/typ/compiler/field.typ
+++ b/tests/typ/compiler/field.typ
@@ -31,7 +31,7 @@
 #false.ok
 
 ---
-// Error: 29-32 unknown field `fun`
+// Error: 29-32 content does not contain field "fun"
 #show heading: node => node.fun
 = A
 
diff --git a/tests/typ/compiler/label.typ b/tests/typ/compiler/label.typ
index d4ff15d70..58b0dee94 100644
--- a/tests/typ/compiler/label.typ
+++ b/tests/typ/compiler/label.typ
@@ -22,7 +22,7 @@ The end.
 ---
 // Test labelled text.
 #show "t": it => {
-  set text(blue) if it.label == <last>
+  set text(blue) if it.has("label") and it.label == <last>
   it
 }
 
diff --git a/tests/typ/compiler/ops.typ b/tests/typ/compiler/ops.typ
index baa2898a9..a29003edb 100644
--- a/tests/typ/compiler/ops.typ
+++ b/tests/typ/compiler/ops.typ
@@ -152,11 +152,13 @@
 #test(test == test, true)
 #test((() => {}) == (() => {}), false)
 
-// Content cannot be compared.
+// Content compares field by field.
 #let t = [a]
-#test(t == t, false)
-#test([] == [], false)
-#test([a] == [a], false)
+#test(t == t, true)
+#test([] == [], true)
+#test([a] == [a], true)
+#test(grid[a] == grid[a], true)
+#test(grid[a] == grid[b], false)
 
 ---
 // Test comparison operators.
diff --git a/tests/typ/compiler/repr.typ b/tests/typ/compiler/repr.typ
index ed6cd84af..cfe428eb3 100644
--- a/tests/typ/compiler/repr.typ
+++ b/tests/typ/compiler/repr.typ
@@ -30,16 +30,13 @@
 #rgb("f7a205") \
 #(2pt + rgb("f7a205"))
 
----
 // Strings and escaping.
-#raw(repr("hi"), lang: "typc") \
+#raw(repr("hi"), lang: "typc")
 #repr("a\n[]\"\u{1F680}string")
 
----
 // Content.
-#raw(repr[*{"H" + "i"} there*])
+#raw(lang: "typc", repr[*Hey*])
 
----
 // Functions are invisible.
 Nothing
 #let f(x) = x
diff --git a/tests/typ/compiler/show-node.typ b/tests/typ/compiler/show-node.typ
index f87b19712..0c1c1f526 100644
--- a/tests/typ/compiler/show-node.typ
+++ b/tests/typ/compiler/show-node.typ
@@ -78,7 +78,7 @@ Another text.
 = Heading
 
 ---
-// Error: 25-29 unknown field `page`
+// Error: 25-29 content does not contain field "page"
 #show heading: it => it.page
 = Heading