New block spacing model

33 files changed, 538 insertions, 261 deletions

diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index bb9eb2fb..5542de89 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -101,9 +101,9 @@ impl Eval for MarkupNode {
         Ok(match self {
             Self::Space => Content::Space,
             Self::Parbreak => Content::Parbreak,
-            Self::Linebreak(justified) => Content::Linebreak(*justified),
+            &Self::Linebreak { justified } => Content::Linebreak { justified },
             Self::Text(text) => Content::Text(text.clone()),
-            Self::Quote(double) => Content::Quote(*double),
+            &Self::Quote { double } => Content::Quote { double },
             Self::Strong(strong) => strong.eval(ctx, scp)?,
             Self::Emph(emph) => emph.eval(ctx, scp)?,
             Self::Raw(raw) => raw.eval(ctx, scp)?,
diff --git a/src/eval/ops.rs b/src/eval/ops.rs
index 832bd354..56bfdf2e 100644
--- a/src/eval/ops.rs
+++ b/src/eval/ops.rs
@@ -316,9 +316,10 @@ pub fn compare(lhs: &Value, rhs: &Value) -> Option<Ordering> {
         (Bool(a), Bool(b)) => a.partial_cmp(b),
         (Int(a), Int(b)) => a.partial_cmp(b),
         (Float(a), Float(b)) => a.partial_cmp(b),
-        (Angle(a), Angle(b)) => a.partial_cmp(b),
         (Length(a), Length(b)) => a.partial_cmp(b),
+        (Angle(a), Angle(b)) => a.partial_cmp(b),
         (Ratio(a), Ratio(b)) => a.partial_cmp(b),
+        (Relative(a), Relative(b)) => a.partial_cmp(b),
         (Fraction(a), Fraction(b)) => a.partial_cmp(b),
         (Str(a), Str(b)) => a.partial_cmp(b),
 
diff --git a/src/eval/raw.rs b/src/eval/raw.rs
index 2d82fca8..6545ea5a 100644
--- a/src/eval/raw.rs
+++ b/src/eval/raw.rs
@@ -213,6 +213,8 @@ impl PartialOrd for RawLength {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         if self.em.is_zero() && other.em.is_zero() {
             self.length.partial_cmp(&other.length)
+        } else if self.length.is_zero() && other.length.is_zero() {
+            self.em.partial_cmp(&other.em)
         } else {
             None
         }
diff --git a/src/eval/value.rs b/src/eval/value.rs
index 31287fa8..6ce815a4 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -408,12 +408,25 @@ macro_rules! dynamic {
 
 /// Make a type castable from a value.
 macro_rules! castable {
+    ($type:ty: $inner:ty) => {
+        impl $crate::eval::Cast<$crate::eval::Value> for $type {
+            fn is(value: &$crate::eval::Value) -> bool {
+                <$inner>::is(value)
+            }
+
+            fn cast(value: $crate::eval::Value) -> $crate::diag::StrResult<Self> {
+                <$inner>::cast(value).map(Self)
+            }
+        }
+    };
+
     (
         $type:ty,
         Expected: $expected:expr,
         $($pattern:pat => $out:expr,)*
         $(@$dyn_in:ident: $dyn_type:ty => $dyn_out:expr,)*
     ) => {
+        #[allow(unreachable_patterns)]
         impl $crate::eval::Cast<$crate::eval::Value> for $type {
             fn is(value: &$crate::eval::Value) -> bool {
                 #[allow(unused_variables)]
@@ -602,10 +615,14 @@ castable! {
 castable! {
     NonZeroUsize,
     Expected: "positive integer",
-    Value::Int(int) => Value::Int(int)
-        .cast::<usize>()?
+    Value::Int(int) => int
         .try_into()
-        .map_err(|_| "must be positive")?,
+        .and_then(|int: usize| int.try_into())
+        .map_err(|_| if int <= 0 {
+            "must be positive"
+        } else {
+            "number too large"
+        })?,
 }
 
 castable! {
diff --git a/src/geom/relative.rs b/src/geom/relative.rs
index fc77fb9f..f213ae52 100644
--- a/src/geom/relative.rs
+++ b/src/geom/relative.rs
@@ -68,6 +68,18 @@ impl<T: Numeric> From<Ratio> for Relative<T> {
     }
 }
 
+impl<T: Numeric + PartialOrd> PartialOrd for Relative<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        if self.rel.is_zero() && other.rel.is_zero() {
+            self.abs.partial_cmp(&other.abs)
+        } else if self.abs.is_zero() && other.abs.is_zero() {
+            self.rel.partial_cmp(&other.rel)
+        } else {
+            None
+        }
+    }
+}
+
 impl<T: Numeric> Neg for Relative<T> {
     type Output = Self;
 
diff --git a/src/library/graphics/shape.rs b/src/library/graphics/shape.rs
index e4c832f0..49c74c2f 100644
--- a/src/library/graphics/shape.rs
+++ b/src/library/graphics/shape.rs
@@ -26,7 +26,6 @@ impl<const S: ShapeKind> ShapeNode<S> {
     /// How to stroke the shape.
     #[property(resolve, fold)]
     pub const STROKE: Smart<Option<RawStroke>> = Smart::Auto;
-
     /// How much to pad the shape's content.
     pub const PADDING: Relative<RawLength> = Relative::zero();
 
diff --git a/src/library/graphics/transform.rs b/src/library/graphics/transform.rs
index ea021cc1..a4aa20db 100644
--- a/src/library/graphics/transform.rs
+++ b/src/library/graphics/transform.rs
@@ -13,8 +13,8 @@ pub struct MoveNode {
 #[node]
 impl MoveNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
-        let dx = args.named("x")?.unwrap_or_default();
-        let dy = args.named("y")?.unwrap_or_default();
+        let dx = args.named("dx")?.unwrap_or_default();
+        let dy = args.named("dy")?.unwrap_or_default();
         Ok(Content::inline(Self {
             delta: Spec::new(dx, dy),
             child: args.expect("body")?,
diff --git a/src/library/layout/align.rs b/src/library/layout/align.rs
index 2a4d039e..c050d2a4 100644
--- a/src/library/layout/align.rs
+++ b/src/library/layout/align.rs
@@ -13,9 +13,15 @@ pub struct AlignNode {
 #[node]
 impl AlignNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
-        let aligns: Spec<_> = args.find()?.unwrap_or_default();
-        let body: LayoutNode = args.expect("body")?;
-        Ok(Content::block(body.aligned(aligns)))
+        let aligns: Spec<Option<RawAlign>> = args.find()?.unwrap_or_default();
+        let body: Content = args.expect("body")?;
+        Ok(match (body, aligns) {
+            (Content::Block(node), _) => Content::Block(node.aligned(aligns)),
+            (other, Spec { x: Some(x), y: None }) => {
+                other.styled(ParNode::ALIGN, HorizontalAlign(x))
+            }
+            (other, _) => Content::Block(other.pack().aligned(aligns)),
+        })
     }
 }
 
diff --git a/src/library/layout/columns.rs b/src/library/layout/columns.rs
index 4963043e..8e523694 100644
--- a/src/library/layout/columns.rs
+++ b/src/library/layout/columns.rs
@@ -106,7 +106,8 @@ pub struct ColbreakNode;
 
 #[node]
 impl ColbreakNode {
-    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Content> {
-        Ok(Content::Colbreak)
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
+        let weak = args.named("weak")?.unwrap_or(false);
+        Ok(Content::Colbreak { weak })
     }
 }
diff --git a/src/library/layout/flow.rs b/src/library/layout/flow.rs
index 6b43c8b7..6193a68f 100644
--- a/src/library/layout/flow.rs
+++ b/src/library/layout/flow.rs
@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use super::{AlignNode, PlaceNode, Spacing};
 use crate::library::prelude::*;
 use crate::library::text::ParNode;
@@ -10,18 +12,14 @@ use crate::library::text::ParNode;
 pub struct FlowNode(pub StyleVec<FlowChild>);
 
 /// A child of a flow node.
-#[derive(Hash)]
+#[derive(Hash, PartialEq)]
 pub enum FlowChild {
-    /// Leading between other children.
-    Leading,
-    /// A paragraph / block break.
-    Parbreak,
-    /// A column / region break.
-    Colbreak,
     /// Vertical spacing between other children.
     Spacing(Spacing),
     /// An arbitrary block-level node.
     Node(LayoutNode),
+    /// A column / region break.
+    Colbreak,
 }
 
 impl Layout for FlowNode {
@@ -36,25 +34,15 @@ impl Layout for FlowNode {
         for (child, map) in self.0.iter() {
             let styles = map.chain(&styles);
             match child {
-                FlowChild::Leading => {
-                    let amount = styles.get(ParNode::LEADING);
-                    layouter.layout_spacing(amount.into(), styles);
-                }
-                FlowChild::Parbreak => {
-                    let leading = styles.get(ParNode::LEADING);
-                    let spacing = styles.get(ParNode::SPACING);
-                    let amount = leading + spacing;
-                    layouter.layout_spacing(amount.into(), styles);
-                }
-                FlowChild::Colbreak => {
-                    layouter.finish_region();
-                }
                 FlowChild::Spacing(kind) => {
                     layouter.layout_spacing(*kind, styles);
                 }
                 FlowChild::Node(ref node) => {
                     layouter.layout_node(ctx, node, styles)?;
                 }
+                FlowChild::Colbreak => {
+                    layouter.finish_region();
+                }
             }
         }
 
@@ -72,11 +60,18 @@ impl Debug for FlowNode {
 impl Debug for FlowChild {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
-            Self::Leading => f.pad("Leading"),
-            Self::Parbreak => f.pad("Parbreak"),
-            Self::Colbreak => f.pad("Colbreak"),
             Self::Spacing(kind) => write!(f, "{:?}", kind),
             Self::Node(node) => node.fmt(f),
+            Self::Colbreak => f.pad("Colbreak"),
+        }
+    }
+}
+
+impl PartialOrd for FlowChild {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Self::Spacing(a), Self::Spacing(b)) => a.partial_cmp(b),
+            _ => None,
         }
     }
 }
diff --git a/src/library/layout/pad.rs b/src/library/layout/pad.rs
index e688e423..2be21bcb 100644
--- a/src/library/layout/pad.rs
+++ b/src/library/layout/pad.rs
@@ -13,12 +13,12 @@ pub struct PadNode {
 impl PadNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         let all = args.find()?;
-        let hor = args.named("horizontal")?;
-        let ver = args.named("vertical")?;
-        let left = args.named("left")?.or(hor).or(all).unwrap_or_default();
-        let top = args.named("top")?.or(ver).or(all).unwrap_or_default();
-        let right = args.named("right")?.or(hor).or(all).unwrap_or_default();
-        let bottom = args.named("bottom")?.or(ver).or(all).unwrap_or_default();
+        let x = args.named("x")?;
+        let y = args.named("y")?;
+        let left = args.named("left")?.or(x).or(all).unwrap_or_default();
+        let top = args.named("top")?.or(y).or(all).unwrap_or_default();
+        let right = args.named("right")?.or(x).or(all).unwrap_or_default();
+        let bottom = args.named("bottom")?.or(y).or(all).unwrap_or_default();
         let body: LayoutNode = args.expect("body")?;
         let padding = Sides::new(left, top, right, bottom);
         Ok(Content::block(body.padded(padding)))
diff --git a/src/library/layout/page.rs b/src/library/layout/page.rs
index 8e5801ea..4307d2f9 100644
--- a/src/library/layout/page.rs
+++ b/src/library/layout/page.rs
@@ -165,8 +165,8 @@ pub struct PagebreakNode;
 #[node]
 impl PagebreakNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
-        let soft = args.named("soft")?.unwrap_or(false);
-        Ok(Content::Pagebreak(soft))
+        let weak = args.named("weak")?.unwrap_or(false);
+        Ok(Content::Pagebreak { weak })
     }
 }
 
diff --git a/src/library/layout/spacing.rs b/src/library/layout/spacing.rs
index 3468af5e..8a96e378 100644
--- a/src/library/layout/spacing.rs
+++ b/src/library/layout/spacing.rs
@@ -1,4 +1,7 @@
+use std::cmp::Ordering;
+
 use crate::library::prelude::*;
+use crate::library::text::ParNode;
 
 /// Horizontal spacing.
 pub struct HNode;
@@ -6,7 +9,9 @@ pub struct HNode;
 #[node]
 impl HNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
-        Ok(Content::Horizontal(args.expect("spacing")?))
+        let amount = args.expect("spacing")?;
+        let weak = args.named("weak")?.unwrap_or(false);
+        Ok(Content::Horizontal { amount, weak })
     }
 }
 
@@ -16,7 +21,9 @@ pub struct VNode;
 #[node]
 impl VNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
-        Ok(Content::Vertical(args.expect("spacing")?))
+        let amount = args.expect("spacing")?;
+        let weak = args.named("weak")?.unwrap_or(false);
+        Ok(Content::Vertical { amount, weak, generated: false })
     }
 }
 
@@ -25,7 +32,8 @@ impl VNode {
 pub enum Spacing {
     /// Spacing specified in absolute terms and relative to the parent's size.
     Relative(Relative<RawLength>),
-    /// Spacing specified as a fraction of the remaining free space in the parent.
+    /// Spacing specified as a fraction of the remaining free space in the
+    /// parent.
     Fractional(Fraction),
 }
 
@@ -42,6 +50,16 @@ impl From<Length> for Spacing {
     }
 }
 
+impl PartialOrd for Spacing {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Self::Relative(a), Self::Relative(b)) => a.partial_cmp(b),
+            (Self::Fractional(a), Self::Fractional(b)) => a.partial_cmp(b),
+            _ => None,
+        }
+    }
+}
+
 castable! {
     Spacing,
     Expected: "relative length or fraction",
@@ -50,3 +68,24 @@ castable! {
     Value::Relative(v) => Self::Relative(v),
     Value::Fraction(v) => Self::Fractional(v),
 }
+
+/// Spacing around and between block-level nodes, relative to paragraph spacing.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct BlockSpacing(Relative<RawLength>);
+
+castable!(BlockSpacing: Relative<RawLength>);
+
+impl Resolve for BlockSpacing {
+    type Output = Length;
+
+    fn resolve(self, styles: StyleChain) -> Self::Output {
+        let whole = styles.get(ParNode::SPACING);
+        self.0.resolve(styles).relative_to(whole)
+    }
+}
+
+impl From<Ratio> for BlockSpacing {
+    fn from(ratio: Ratio) -> Self {
+        Self(ratio.into())
+    }
+}
diff --git a/src/library/layout/stack.rs b/src/library/layout/stack.rs
index f915c215..bbfeeab0 100644
--- a/src/library/layout/stack.rs
+++ b/src/library/layout/stack.rs
@@ -1,5 +1,6 @@
 use super::{AlignNode, Spacing};
 use crate::library::prelude::*;
+use crate::library::text::ParNode;
 
 /// Arrange nodes and spacing along an axis.
 #[derive(Debug, Hash)]
@@ -180,7 +181,16 @@ impl<'a> StackLayouter<'a> {
             .downcast::<AlignNode>()
             .and_then(|node| node.aligns.get(self.axis))
             .map(|align| align.resolve(styles))
-            .unwrap_or(self.dir.start().into());
+            .unwrap_or_else(|| {
+                if let Some(Content::Styled(styled)) = node.downcast::<Content>() {
+                    let map = &styled.1;
+                    if map.contains(ParNode::ALIGN) {
+                        return StyleChain::with_root(&styled.1).get(ParNode::ALIGN);
+                    }
+                }
+
+                self.dir.start().into()
+            });
 
         let frames = node.layout(ctx, &self.regions, styles)?;
         let len = frames.len();
diff --git a/src/library/math/mod.rs b/src/library/math/mod.rs
index 345bb3f6..7b4998ca 100644
--- a/src/library/math/mod.rs
+++ b/src/library/math/mod.rs
@@ -1,5 +1,6 @@
 //! Mathematical formulas.
 
+use crate::library::layout::BlockSpacing;
 use crate::library::prelude::*;
 use crate::library::text::FontFamily;
 
@@ -19,6 +20,13 @@ impl MathNode {
     pub const FAMILY: Smart<FontFamily> =
         Smart::Custom(FontFamily::new("Latin Modern Math"));
 
+    /// The spacing above display math.
+    #[property(resolve, shorthand(around))]
+    pub const ABOVE: Option<BlockSpacing> = Some(Ratio::one().into());
+    /// The spacing below display math.
+    #[property(resolve, shorthand(around))]
+    pub const BELOW: Option<BlockSpacing> = Some(Ratio::one().into());
+
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         Ok(Content::show(Self {
             formula: args.expect("formula")?,
@@ -36,7 +44,11 @@ impl Show for MathNode {
     }
 
     fn realize(&self, _: &mut Context, _: StyleChain) -> TypResult<Content> {
-        Ok(Content::Text(self.formula.trim().into()))
+        let mut realized = Content::Text(self.formula.trim().into());
+        if self.display {
+            realized = Content::block(realized);
+        }
+        Ok(realized)
     }
 
     fn finalize(
@@ -50,12 +62,10 @@ impl Show for MathNode {
             map.set_family(family.clone(), styles);
         }
 
-        realized = realized.styled_with_map(map);
-
         if self.display {
-            realized = Content::block(realized);
+            realized = realized.spaced(styles.get(Self::ABOVE), styles.get(Self::BELOW));
         }
 
-        Ok(realized)
+        Ok(realized.styled_with_map(map))
     }
 }
diff --git a/src/library/mod.rs b/src/library/mod.rs
index c68915c8..e90e5cc4 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -88,7 +88,7 @@ pub fn new() -> Scope {
     std.def_fn("letter", utility::letter);
     std.def_fn("roman", utility::roman);
     std.def_fn("symbol", utility::symbol);
-    std.def_fn("lipsum", utility::lipsum);
+    std.def_fn("lorem", utility::lorem);
 
     // Predefined colors.
     std.def_const("black", Color::BLACK);
diff --git a/src/library/structure/heading.rs b/src/library/structure/heading.rs
index a6c87912..4f6c54f3 100644
--- a/src/library/structure/heading.rs
+++ b/src/library/structure/heading.rs
@@ -1,3 +1,4 @@
+use crate::library::layout::BlockSpacing;
 use crate::library::prelude::*;
 use crate::library::text::{FontFamily, TextNode, TextSize, Toggle};
 
@@ -6,7 +7,7 @@ use crate::library::text::{FontFamily, TextNode, TextSize, Toggle};
 pub struct HeadingNode {
     /// The logical nesting depth of the section, starting from one. In the
     /// default style, this controls the text size of the heading.
-    pub level: usize,
+    pub level: NonZeroUsize,
     /// The heading's contents.
     pub body: Content,
 }
@@ -22,8 +23,12 @@ impl HeadingNode {
     /// The size of text in the heading.
     #[property(referenced)]
     pub const SIZE: Leveled<TextSize> = Leveled::Mapping(|level| {
-        let upscale = (1.6 - 0.1 * level as f64).max(0.75);
-        TextSize(Em::new(upscale).into())
+        let size = match level.get() {
+            1 => 1.4,
+            2 => 1.2,
+            _ => 1.0,
+        };
+        TextSize(Em::new(size).into())
     });
 
     /// Whether text in the heading is strengthend.
@@ -36,21 +41,24 @@ impl HeadingNode {
     #[property(referenced)]
     pub const UNDERLINE: Leveled<bool> = Leveled::Value(false);
 
-    /// The extra padding above the heading.
-    #[property(referenced)]
-    pub const ABOVE: Leveled<RawLength> = Leveled::Value(Length::zero().into());
-    /// The extra padding below the heading.
-    #[property(referenced)]
-    pub const BELOW: Leveled<RawLength> = Leveled::Value(Length::zero().into());
-
-    /// Whether the heading is block-level.
-    #[property(referenced)]
-    pub const BLOCK: Leveled<bool> = Leveled::Value(true);
+    /// The spacing above the heading.
+    #[property(referenced, shorthand(around))]
+    pub const ABOVE: Leveled<Option<BlockSpacing>> = Leveled::Mapping(|level| {
+        let ratio = match level.get() {
+            1 => 1.5,
+            _ => 1.2,
+        };
+        Some(Ratio::new(ratio).into())
+    });
+    /// The spacing below the heading.
+    #[property(referenced, shorthand(around))]
+    pub const BELOW: Leveled<Option<BlockSpacing>> =
+        Leveled::Value(Some(Ratio::new(0.55).into()));
 
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         Ok(Content::show(Self {
             body: args.expect("body")?,
-            level: args.named("level")?.unwrap_or(1),
+            level: args.named("level")?.unwrap_or(NonZeroUsize::new(1).unwrap()),
         }))
     }
 }
@@ -58,13 +66,13 @@ impl HeadingNode {
 impl Show for HeadingNode {
     fn encode(&self) -> Dict {
         dict! {
-            "level" => Value::Int(self.level as i64),
+            "level" => Value::Int(self.level.get() as i64),
             "body" => Value::Content(self.body.clone()),
         }
     }
 
     fn realize(&self, _: &mut Context, _: StyleChain) -> TypResult<Content> {
-        Ok(self.body.clone())
+        Ok(Content::block(self.body.clone()))
     }
 
     fn finalize(
@@ -103,11 +111,6 @@ impl Show for HeadingNode {
         }
 
         realized = realized.styled_with_map(map);
-
-        if resolve!(Self::BLOCK) {
-            realized = Content::block(realized);
-        }
-
         realized = realized.spaced(
             resolve!(Self::ABOVE).resolve(styles),
             resolve!(Self::BELOW).resolve(styles),
@@ -123,19 +126,19 @@ pub enum Leveled<T> {
     /// A bare value.
     Value(T),
     /// A simple mapping from a heading level to a value.
-    Mapping(fn(usize) -> T),
+    Mapping(fn(NonZeroUsize) -> T),
     /// A closure mapping from a heading level to a value.
     Func(Func, Span),
 }
 
 impl<T: Cast + Clone> Leveled<T> {
     /// Resolve the value based on the level.
-    pub fn resolve(&self, ctx: &mut Context, level: usize) -> TypResult<T> {
+    pub fn resolve(&self, ctx: &mut Context, level: NonZeroUsize) -> TypResult<T> {
         Ok(match self {
             Self::Value(value) => value.clone(),
             Self::Mapping(mapping) => mapping(level),
             Self::Func(func, span) => {
-                let args = Args::from_values(*span, [Value::Int(level as i64)]);
+                let args = Args::from_values(*span, [Value::Int(level.get() as i64)]);
                 func.call(ctx, args)?.cast().at(*span)?
             }
         })
diff --git a/src/library/structure/list.rs b/src/library/structure/list.rs
index ac705156..4356ffb4 100644
--- a/src/library/structure/list.rs
+++ b/src/library/structure/list.rs
@@ -2,7 +2,7 @@ use std::fmt::Write;
 
 use unscanny::Scanner;
 
-use crate::library::layout::{GridNode, TrackSizing};
+use crate::library::layout::{BlockSpacing, GridNode, TrackSizing};
 use crate::library::prelude::*;
 use crate::library::text::ParNode;
 use crate::library::utility::Numbering;
@@ -12,9 +12,10 @@ use crate::library::utility::Numbering;
 pub struct ListNode<const L: ListKind = UNORDERED> {
     /// Where the list starts.
     pub start: usize,
-    /// If false, there is paragraph spacing between the items, if true
-    /// there is list spacing between the items.
+    /// If true, the items are separated by leading instead of list spacing.
     pub tight: bool,
+    /// If true, the spacing above the list is leading instead of above spacing.
+    pub attached: bool,
     /// The individual bulleted or numbered items.
     pub items: StyleVec<ListItem>,
 }
@@ -38,10 +39,6 @@ impl<const L: ListKind> ListNode<L> {
     /// How the list is labelled.
     #[property(referenced)]
     pub const LABEL: Label = Label::Default;
-
-    /// The spacing between the list items of a non-wide list.
-    #[property(resolve)]
-    pub const SPACING: RawLength = RawLength::zero();
     /// The indentation of each item's label.
     #[property(resolve)]
     pub const INDENT: RawLength = RawLength::zero();
@@ -49,17 +46,21 @@ impl<const L: ListKind> ListNode<L> {
     #[property(resolve)]
     pub const BODY_INDENT: RawLength = Em::new(0.5).into();
 
-    /// The extra padding above the list.
-    #[property(resolve)]
-    pub const ABOVE: RawLength = RawLength::zero();
-    /// The extra padding below the list.
+    /// The spacing above the list.
+    #[property(resolve, shorthand(around))]
+    pub const ABOVE: Option<BlockSpacing> = Some(Ratio::one().into());
+    /// The spacing below the list.
+    #[property(resolve, shorthand(around))]
+    pub const BELOW: Option<BlockSpacing> = Some(Ratio::one().into());
+    /// The spacing between the items of a wide (non-tight) list.
     #[property(resolve)]
-    pub const BELOW: RawLength = RawLength::zero();
+    pub const SPACING: BlockSpacing = Ratio::one().into();
 
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         Ok(Content::show(Self {
             start: args.named("start")?.unwrap_or(1),
             tight: args.named("tight")?.unwrap_or(true),
+            attached: args.named("attached")?.unwrap_or(false),
             items: args
                 .all()?
                 .into_iter()
@@ -78,6 +79,7 @@ impl<const L: ListKind> Show for ListNode<L> {
         dict! {
             "start" => Value::Int(self.start as i64),
             "tight" => Value::Bool(self.tight),
+            "attached" => Value::Bool(self.attached),
             "items" => Value::Array(
                 self.items
                     .items()
@@ -103,14 +105,12 @@ impl<const L: ListKind> Show for ListNode<L> {
             number += 1;
         }
 
-        let leading = styles.get(ParNode::LEADING);
-        let spacing = if self.tight {
-            styles.get(Self::SPACING)
+        let gutter = if self.tight {
+            styles.get(ParNode::LEADING)
         } else {
-            styles.get(ParNode::SPACING)
+            styles.get(Self::SPACING)
         };
 
-        let gutter = leading + spacing;
         let indent = styles.get(Self::INDENT);
         let body_indent = styles.get(Self::BODY_INDENT);
 
@@ -132,7 +132,19 @@ impl<const L: ListKind> Show for ListNode<L> {
         styles: StyleChain,
         realized: Content,
     ) -> TypResult<Content> {
-        Ok(realized.spaced(styles.get(Self::ABOVE), styles.get(Self::BELOW)))
+        let mut above = styles.get(Self::ABOVE);
+        let mut below = styles.get(Self::BELOW);
+
+        if self.attached {
+            if above.is_some() {
+                above = Some(styles.get(ParNode::LEADING));
+            }
+            if below.is_some() {
+                below = Some(styles.get(ParNode::SPACING));
+            }
+        }
+
+        Ok(realized.spaced(above, below))
     }
 }
 
diff --git a/src/library/structure/table.rs b/src/library/structure/table.rs
index 191d3dd3..7b3f2ac5 100644
--- a/src/library/structure/table.rs
+++ b/src/library/structure/table.rs
@@ -1,4 +1,4 @@
-use crate::library::layout::{GridNode, TrackSizing};
+use crate::library::layout::{BlockSpacing, GridNode, TrackSizing};
 use crate::library::prelude::*;
 
 /// A table of items.
@@ -15,16 +15,24 @@ pub struct TableNode {
 #[node(showable)]
 impl TableNode {
     /// The primary cell fill color.
+    #[property(shorthand(fill))]
     pub const PRIMARY: Option<Paint> = None;
     /// The secondary cell fill color.
+    #[property(shorthand(fill))]
     pub const SECONDARY: Option<Paint> = None;
     /// How to stroke the cells.
     #[property(resolve, fold)]
     pub const STROKE: Option<RawStroke> = Some(RawStroke::default());
-
     /// How much to pad the cells's content.
     pub const PADDING: Relative<RawLength> = Length::pt(5.0).into();
 
+    /// The spacing above the table.
+    #[property(resolve, shorthand(around))]
+    pub const ABOVE: Option<BlockSpacing> = Some(Ratio::one().into());
+    /// The spacing below the table.
+    #[property(resolve, shorthand(around))]
+    pub const BELOW: Option<BlockSpacing> = Some(Ratio::one().into());
+
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         let columns = args.named("columns")?.unwrap_or_default();
         let rows = args.named("rows")?.unwrap_or_default();
@@ -40,16 +48,6 @@ impl TableNode {
             cells: args.all()?,
         }))
     }
-
-    fn set(args: &mut Args) -> TypResult<StyleMap> {
-        let mut styles = StyleMap::new();
-        let fill = args.named("fill")?;
-        styles.set_opt(Self::PRIMARY, args.named("primary")?.or(fill));
-        styles.set_opt(Self::SECONDARY, args.named("secondary")?.or(fill));
-        styles.set_opt(Self::STROKE, args.named("stroke")?);
-        styles.set_opt(Self::PADDING, args.named("padding")?);
-        Ok(styles)
-    }
 }
 
 impl Show for TableNode {
@@ -99,4 +97,13 @@ impl Show for TableNode {
             cells,
         }))
     }
+
+    fn finalize(
+        &self,
+        _: &mut Context,
+        styles: StyleChain,
+        realized: Content,
+    ) -> TypResult<Content> {
+        Ok(realized.spaced(styles.get(Self::ABOVE), styles.get(Self::BELOW)))
+    }
 }
diff --git a/src/library/text/deco.rs b/src/library/text/deco.rs
index 52f8ea80..70040f9c 100644
--- a/src/library/text/deco.rs
+++ b/src/library/text/deco.rs
@@ -24,7 +24,6 @@ impl<const L: DecoLine> DecoNode<L> {
     /// tables if `auto`.
     #[property(shorthand, resolve, fold)]
     pub const STROKE: Smart<RawStroke> = Smart::Auto;
-
     /// Position of the line relative to the baseline, read from the font tables
     /// if `auto`.
     #[property(resolve)]
@@ -32,7 +31,6 @@ impl<const L: DecoLine> DecoNode<L> {
     /// Amount that the line will be longer or shorter than its associated text.
     #[property(resolve)]
     pub const EXTENT: RawLength = RawLength::zero();
-
     /// Whether the line skips sections in which it would collide
     /// with the glyphs. Does not apply to strikethrough.
     pub const EVADE: bool = true;
diff --git a/src/library/text/mod.rs b/src/library/text/mod.rs
index 3cfbc55d..ecc0c546 100644
--- a/src/library/text/mod.rs
+++ b/src/library/text/mod.rs
@@ -223,11 +223,7 @@ impl Fold for TextSize {
     }
 }
 
-castable! {
-    TextSize,
-    Expected: "length",
-    Value::Length(v) => Self(v),
-}
+castable!(TextSize: RawLength);
 
 /// Specifies the bottom or top edge of text.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
@@ -290,11 +286,7 @@ impl Resolve for Smart<HorizontalDir> {
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Hyphenate(pub bool);
 
-castable! {
-    Hyphenate,
-    Expected: "boolean",
-    Value::Bool(v) => Self(v),
-}
+castable!(Hyphenate: bool);
 
 impl Resolve for Smart<Hyphenate> {
     type Output = bool;
diff --git a/src/library/text/par.rs b/src/library/text/par.rs
index 4694993e..669d07ba 100644
--- a/src/library/text/par.rs
+++ b/src/library/text/par.rs
@@ -1,3 +1,4 @@
+use std::cmp::Ordering;
 use std::sync::Arc;
 
 use unicode_bidi::{BidiInfo, Level};
@@ -15,12 +16,12 @@ use crate::util::{EcoString, MaybeShared};
 pub struct ParNode(pub StyleVec<ParChild>);
 
 /// A uniformly styled atomic piece of a paragraph.
-#[derive(Hash)]
+#[derive(Hash, PartialEq)]
 pub enum ParChild {
     /// A chunk of text.
     Text(EcoString),
-    /// A smart quote, may be single (`false`) or double (`true`).
-    Quote(bool),
+    /// A single or double smart quote.
+    Quote { double: bool },
     /// Horizontal spacing between other children.
     Spacing(Spacing),
     /// An arbitrary inline-level node.
@@ -34,10 +35,12 @@ impl ParNode {
     pub const LEADING: RawLength = Em::new(0.65).into();
     /// The extra spacing between paragraphs.
     #[property(resolve)]
-    pub const SPACING: RawLength = Em::new(0.55).into();
+    pub const SPACING: RawLength = Em::new(1.2).into();
     /// The indent the first line of a consecutive paragraph should have.
     #[property(resolve)]
     pub const INDENT: RawLength = RawLength::zero();
+    /// Whether to allow paragraph spacing when there is paragraph indent.
+    pub const SPACING_AND_INDENT: bool = false;
 
     /// How to align text and inline objects in their line.
     #[property(resolve)]
@@ -50,10 +53,13 @@ impl ParNode {
 
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         // The paragraph constructor is special: It doesn't create a paragraph
-        // since that happens automatically through markup. Instead, it just
-        // lifts the passed body to the block level so that it won't merge with
-        // adjacent stuff and it styles the contained paragraphs.
-        Ok(Content::Block(args.expect("body")?))
+        // node. Instead, it just ensures that the passed content lives is in a
+        // separate paragraph and styles it.
+        Ok(Content::sequence(vec![
+            Content::Parbreak,
+            args.expect("body")?,
+            Content::Parbreak,
+        ]))
     }
 }
 
@@ -91,13 +97,22 @@ impl Debug for ParChild {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             Self::Text(text) => write!(f, "Text({:?})", text),
-            Self::Quote(double) => write!(f, "Quote({})", double),
+            Self::Quote { double } => write!(f, "Quote({double})"),
             Self::Spacing(kind) => write!(f, "{:?}", kind),
             Self::Node(node) => node.fmt(f),
         }
     }
 }
 
+impl PartialOrd for ParChild {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Self::Spacing(a), Self::Spacing(b)) => a.partial_cmp(b),
+            _ => None,
+        }
+    }
+}
+
 /// A horizontal alignment.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct HorizontalAlign(pub RawAlign);
@@ -169,7 +184,7 @@ pub struct LinebreakNode;
 impl LinebreakNode {
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         let justified = args.named("justified")?.unwrap_or(false);
-        Ok(Content::Linebreak(justified))
+        Ok(Content::Linebreak { justified })
     }
 }
 
@@ -432,7 +447,7 @@ fn collect<'a>(
                 }
                 Segment::Text(full.len() - prev)
             }
-            ParChild::Quote(double) => {
+            ParChild::Quote { double } => {
                 let prev = full.len();
                 if styles.get(TextNode::SMART_QUOTES) {
                     let lang = styles.get(TextNode::LANG);
@@ -440,7 +455,7 @@ fn collect<'a>(
                     let quotes = Quotes::from_lang(lang, region);
                     let peeked = iter.peek().and_then(|(child, _)| match child {
                         ParChild::Text(text) => text.chars().next(),
-                        ParChild::Quote(_) => Some('"'),
+                        ParChild::Quote { .. } => Some('"'),
                         ParChild::Spacing(_) => Some(SPACING_REPLACE),
                         ParChild::Node(_) => Some(NODE_REPLACE),
                     });
diff --git a/src/library/text/raw.rs b/src/library/text/raw.rs
index 13daa1b9..ee6c6356 100644
--- a/src/library/text/raw.rs
+++ b/src/library/text/raw.rs
@@ -4,6 +4,7 @@ use syntect::highlighting::{FontStyle, Highlighter, Style, Theme, ThemeSet};
 use syntect::parsing::SyntaxSet;
 
 use super::{FontFamily, Hyphenate, TextNode, Toggle};
+use crate::library::layout::BlockSpacing;
 use crate::library::prelude::*;
 use crate::source::SourceId;
 use crate::syntax::{self, RedNode};
@@ -26,13 +27,20 @@ pub struct RawNode {
 
 #[node(showable)]
 impl RawNode {
+    /// The language to syntax-highlight in.
+    #[property(referenced)]
+    pub const LANG: Option<EcoString> = None;
+
     /// The raw text's font family. Just the normal text family if `none`.
     #[property(referenced)]
     pub const FAMILY: Smart<FontFamily> = Smart::Custom(FontFamily::new("IBM Plex Mono"));
 
-    /// The language to syntax-highlight in.
-    #[property(referenced)]
-    pub const LANG: Option<EcoString> = None;
+    /// The spacing above block-level raw.
+    #[property(resolve, shorthand(around))]
+    pub const ABOVE: Option<BlockSpacing> = Some(Ratio::one().into());
+    /// The spacing below block-level raw.
+    #[property(resolve, shorthand(around))]
+    pub const BELOW: Option<BlockSpacing> = Some(Ratio::one().into());
 
     fn construct(_: &mut Context, args: &mut Args) -> TypResult<Content> {
         Ok(Content::show(Self {
@@ -59,7 +67,7 @@ impl Show for RawNode {
             .unwrap_or(Color::BLACK)
             .into();
 
-        if matches!(
+        let mut realized = if matches!(
             lang.map(|s| s.to_lowercase()).as_deref(),
             Some("typ" | "typst")
         ) {
@@ -72,7 +80,7 @@ impl Show for RawNode {
                 seq.push(styled(&self.text[range], foreground, style));
             });
 
-            Ok(Content::sequence(seq))
+            Content::sequence(seq)
         } else if let Some(syntax) =
             lang.and_then(|token| SYNTAXES.find_syntax_by_token(&token))
         {
@@ -80,7 +88,7 @@ impl Show for RawNode {
             let mut highlighter = HighlightLines::new(syntax, &THEME);
             for (i, line) in self.text.lines().enumerate() {
                 if i != 0 {
-                    seq.push(Content::Linebreak(false));
+                    seq.push(Content::Linebreak { justified: false });
                 }
 
                 for (style, piece) in highlighter.highlight(line, &SYNTAXES) {
@@ -88,10 +96,16 @@ impl Show for RawNode {
                 }
             }
 
-            Ok(Content::sequence(seq))
+            Content::sequence(seq)
         } else {
-            Ok(Content::Text(self.text.clone()))
+            Content::Text(self.text.clone())
+        };
+
+        if self.block {
+            realized = Content::block(realized);
         }
+
+        Ok(realized)
     }
 
     fn finalize(
@@ -109,13 +123,11 @@ impl Show for RawNode {
             map.set_family(family.clone(), styles);
         }
 
-        realized = realized.styled_with_map(map);
-
         if self.block {
-            realized = Content::block(realized);
+            realized = realized.spaced(styles.get(Self::ABOVE), styles.get(Self::BELOW));
         }
 
-        Ok(realized)
+        Ok(realized.styled_with_map(map))
     }
 }
 
diff --git a/src/library/utility/blind.rs b/src/library/utility/blind.rs
index a4cfec90..0075ab91 100644
--- a/src/library/utility/blind.rs
+++ b/src/library/utility/blind.rs
@@ -3,7 +3,7 @@ use lipsum::lipsum_from_seed;
 use crate::library::prelude::*;
 
 /// Create blind text.
-pub fn lipsum(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+pub fn lorem(_: &mut Context, args: &mut Args) -> TypResult<Value> {
     let words: usize = args.expect("number of words")?;
     Ok(Value::Str(lipsum_from_seed(words, 97).into()))
 }
diff --git a/src/model/collapse.rs b/src/model/collapse.rs
index 17933fe8..258f577e 100644
--- a/src/model/collapse.rs
+++ b/src/model/collapse.rs
@@ -35,26 +35,37 @@ impl<'a, T> CollapsingBuilder<'a, T> {
     }
 
     /// Can only exist when there is at least one supportive item to its left
-    /// and to its right, with no destructive items or weak items in between to
-    /// its left and no destructive items in between to its right. There may be
+    /// and to its right, with no destructive items in between. There may be
     /// ignorant items in between in both directions.
-    pub fn weak(&mut self, item: T, strength: u8, styles: StyleChain<'a>) {
-        if self.last != Last::Destructive {
-            if self.last == Last::Weak {
-                if let Some(i) = self
-                    .staged
-                    .iter()
-                    .position(|(.., prev)| prev.map_or(false, |p| p < strength))
-                {
-                    self.staged.remove(i);
-                } else {
-                    return;
-                }
-            }
+    ///
+    /// Between weak items, there may be at least one per layer and among the
+    /// candidates the strongest one (smallest `weakness`) wins. When tied,
+    /// the one that compares larger through `PartialOrd` wins.
+    pub fn weak(&mut self, item: T, styles: StyleChain<'a>, weakness: u8)
+    where
+        T: PartialOrd,
+    {
+        if self.last == Last::Destructive {
+            return;
+        }
 
-            self.staged.push((item, styles, Some(strength)));
-            self.last = Last::Weak;
+        if self.last == Last::Weak {
+            if let Some(i) =
+                self.staged.iter().position(|(prev_item, _, prev_weakness)| {
+                    prev_weakness.map_or(false, |prev_weakness| {
+                        weakness < prev_weakness
+                            || (weakness == prev_weakness && item > *prev_item)
+                    })
+                })
+            {
+                self.staged.remove(i);
+            } else {
+                return;
+            }
         }
+
+        self.staged.push((item, styles, Some(weakness)));
+        self.last = Last::Weak;
     }
 
     /// Forces nearby weak items to collapse.
@@ -90,8 +101,8 @@ impl<'a, T> CollapsingBuilder<'a, T> {
     /// Push the staged items, filtering out weak items if `supportive` is
     /// false.
     fn flush(&mut self, supportive: bool) {
-        for (item, styles, strength) in self.staged.drain(..) {
-            if supportive || strength.is_none() {
+        for (item, styles, meta) in self.staged.drain(..) {
+            if supportive || meta.is_none() {
                 self.builder.push(item, styles);
             }
         }
@@ -103,3 +114,64 @@ impl<'a, T> Default for CollapsingBuilder<'a, T> {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::library::layout::FlowChild;
+    use crate::library::prelude::*;
+
+    #[track_caller]
+    fn test<T>(builder: CollapsingBuilder<T>, expected: &[T])
+    where
+        T: Debug + PartialEq,
+    {
+        let result = builder.finish().0;
+        let items: Vec<_> = result.items().collect();
+        let expected: Vec<_> = expected.iter().collect();
+        assert_eq!(items, expected);
+    }
+
+    fn node() -> FlowChild {
+        FlowChild::Node(Content::Text("Hi".into()).pack())
+    }
+
+    fn abs(pt: f64) -> FlowChild {
+        FlowChild::Spacing(Length::pt(pt).into())
+    }
+
+    #[test]
+    fn test_collapsing_weak() {
+        let mut builder = CollapsingBuilder::new();
+        let styles = StyleChain::default();
+        builder.weak(FlowChild::Colbreak, styles, 0);
+        builder.supportive(node(), styles);
+        builder.weak(abs(10.0), styles, 0);
+        builder.ignorant(FlowChild::Colbreak, styles);
+        builder.weak(abs(20.0), styles, 0);
+        builder.supportive(node(), styles);
+        builder.weak(abs(10.0), styles, 0);
+        builder.weak(abs(20.0), styles, 1);
+        builder.supportive(node(), styles);
+        test(builder, &[
+            node(),
+            FlowChild::Colbreak,
+            abs(20.0),
+            node(),
+            abs(10.0),
+            node(),
+        ]);
+    }
+
+    #[test]
+    fn test_collapsing_destructive() {
+        let mut builder = CollapsingBuilder::new();
+        let styles = StyleChain::default();
+        builder.supportive(node(), styles);
+        builder.weak(abs(10.0), styles, 0);
+        builder.destructive(FlowChild::Colbreak, styles);
+        builder.weak(abs(20.0), styles, 0);
+        builder.supportive(node(), styles);
+        test(builder, &[node(), FlowChild::Colbreak, node()]);
+    }
+}
diff --git a/src/model/content.rs b/src/model/content.rs
index 6e1e2f1c..31255a29 100644
--- a/src/model/content.rs
+++ b/src/model/content.rs
@@ -40,29 +40,32 @@ use crate::util::EcoString;
 pub enum Content {
     /// A word space.
     Space,
-    /// A forced line break. If `true`, the preceding line can still be
-    /// justified, if `false` not.
-    Linebreak(bool),
+    /// A forced line break.
+    Linebreak { justified: bool },
     /// Horizontal spacing.
-    Horizontal(Spacing),
+    Horizontal { amount: Spacing, weak: bool },
     /// Plain text.
     Text(EcoString),
-    /// A smart quote, may be single (`false`) or double (`true`).
-    Quote(bool),
+    /// A smart quote.
+    Quote { double: bool },
     /// An inline-level node.
     Inline(LayoutNode),
     /// A paragraph break.
     Parbreak,
     /// A column break.
-    Colbreak,
+    Colbreak { weak: bool },
     /// Vertical spacing.
-    Vertical(Spacing),
+    Vertical {
+        amount: Spacing,
+        weak: bool,
+        generated: bool,
+    },
     /// A block-level node.
     Block(LayoutNode),
     /// A list / enum item.
     Item(ListItem),
     /// A page break.
-    Pagebreak(bool),
+    Pagebreak { weak: bool },
     /// A page node.
     Page(PageNode),
     /// A node that can be realized with styles.
@@ -153,21 +156,28 @@ impl Content {
         Self::show(DecoNode::<UNDERLINE>(self))
     }
 
-    /// Add vertical spacing above and below the node.
-    pub fn spaced(self, above: Length, below: Length) -> Self {
-        if above.is_zero() && below.is_zero() {
+    /// Add weak vertical spacing above and below the node.
+    pub fn spaced(self, above: Option<Length>, below: Option<Length>) -> Self {
+        if above.is_none() && below.is_none() {
             return self;
         }
 
         let mut seq = vec![];
-        if !above.is_zero() {
-            seq.push(Content::Vertical(above.into()));
+        if let Some(above) = above {
+            seq.push(Content::Vertical {
+                amount: above.into(),
+                weak: true,
+                generated: true,
+            });
         }
 
         seq.push(self);
-
-        if !below.is_zero() {
-            seq.push(Content::Vertical(below.into()));
+        if let Some(below) = below {
+            seq.push(Content::Vertical {
+                amount: below.into(),
+                weak: true,
+                generated: true,
+            });
         }
 
         Self::sequence(seq)
@@ -219,17 +229,21 @@ impl Debug for Content {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             Self::Space => f.pad("Space"),
-            Self::Linebreak(justified) => write!(f, "Linebreak({justified})"),
-            Self::Horizontal(kind) => write!(f, "Horizontal({kind:?})"),
+            Self::Linebreak { justified } => write!(f, "Linebreak({justified})"),
+            Self::Horizontal { amount, weak } => {
+                write!(f, "Horizontal({amount:?}, {weak})")
+            }
             Self::Text(text) => write!(f, "Text({text:?})"),
-            Self::Quote(double) => write!(f, "Quote({double})"),
+            Self::Quote { double } => write!(f, "Quote({double})"),
             Self::Inline(node) => node.fmt(f),
             Self::Parbreak => f.pad("Parbreak"),
-            Self::Colbreak => f.pad("Colbreak"),
-            Self::Vertical(kind) => write!(f, "Vertical({kind:?})"),
+            Self::Colbreak { weak } => write!(f, "Colbreak({weak})"),
+            Self::Vertical { amount, weak, generated } => {
+                write!(f, "Vertical({amount:?}, {weak}, {generated})")
+            }
             Self::Block(node) => node.fmt(f),
             Self::Item(item) => item.fmt(f),
-            Self::Pagebreak(soft) => write!(f, "Pagebreak({soft})"),
+            Self::Pagebreak { weak } => write!(f, "Pagebreak({weak})"),
             Self::Page(page) => page.fmt(f),
             Self::Show(node) => node.fmt(f),
             Self::Styled(styled) => {
@@ -360,7 +374,7 @@ impl<'a, 'ctx> Builder<'a, 'ctx> {
             return Ok(());
         }
 
-        let keep = matches!(content, Content::Pagebreak(false));
+        let keep = matches!(content, Content::Pagebreak { weak: false });
         self.interrupt(Interruption::Page, styles, keep)?;
 
         if let Some(doc) = &mut self.doc {
@@ -419,10 +433,8 @@ impl<'a, 'ctx> Builder<'a, 'ctx> {
 
         if intr >= Interruption::Par {
             if !self.par.is_empty() {
-                self.flow.0.weak(FlowChild::Leading, 0, styles);
                 mem::take(&mut self.par).finish(self);
             }
-            self.flow.0.weak(FlowChild::Leading, 0, styles);
         }
 
         if intr >= Interruption::Page {
@@ -456,8 +468,8 @@ struct DocBuilder<'a> {
 impl<'a> DocBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) {
         match content {
-            Content::Pagebreak(soft) => {
-                self.keep_next = !soft;
+            Content::Pagebreak { weak } => {
+                self.keep_next = !weak;
             }
             Content::Page(page) => {
                 self.pages.push(page.clone(), styles);
@@ -483,16 +495,31 @@ struct FlowBuilder<'a>(CollapsingBuilder<'a, FlowChild>);
 
 impl<'a> FlowBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
+        // Weak flow elements:
+        // Weakness | Element
+        //    0     | weak colbreak
+        //    1     | weak fractional spacing
+        //    2     | weak spacing
+        //    3     | generated weak spacing
+        //    4     | generated weak fractional spacing
+        //    5     | par spacing
+
         match content {
-            Content::Parbreak => {
-                self.0.weak(FlowChild::Parbreak, 1, styles);
-            }
-            Content::Colbreak => {
-                self.0.destructive(FlowChild::Colbreak, styles);
+            Content::Parbreak => {}
+            Content::Colbreak { weak } => {
+                if *weak {
+                    self.0.weak(FlowChild::Colbreak, styles, 0);
+                } else {
+                    self.0.destructive(FlowChild::Colbreak, styles);
+                }
             }
-            Content::Vertical(kind) => {
-                let child = FlowChild::Spacing(*kind);
-                if kind.is_fractional() {
+            &Content::Vertical { amount, weak, generated } => {
+                let child = FlowChild::Spacing(amount);
+                let frac = amount.is_fractional();
+                if weak {
+                    let weakness = 1 + u8::from(frac) + 2 * u8::from(generated);
+                    self.0.weak(child, styles, weakness);
+                } else if frac {
                     self.0.destructive(child, styles);
                 } else {
                     self.0.ignorant(child, styles);
@@ -512,6 +539,18 @@ impl<'a> FlowBuilder<'a> {
         true
     }
 
+    fn par(&mut self, par: ParNode, styles: StyleChain<'a>, indent: bool) {
+        let amount = if indent && !styles.get(ParNode::SPACING_AND_INDENT) {
+            styles.get(ParNode::LEADING).into()
+        } else {
+            styles.get(ParNode::SPACING).into()
+        };
+
+        self.0.weak(FlowChild::Spacing(amount), styles, 5);
+        self.0.supportive(FlowChild::Node(par.pack()), styles);
+        self.0.weak(FlowChild::Spacing(amount), styles, 5);
+    }
+
     fn finish(self, doc: &mut DocBuilder<'a>, styles: StyleChain<'a>) {
         let (flow, shared) = self.0.finish();
         let styles = if flow.is_empty() { styles } else { shared };
@@ -530,24 +569,34 @@ struct ParBuilder<'a>(CollapsingBuilder<'a, ParChild>);
 
 impl<'a> ParBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
+        // Weak par elements:
+        // Weakness | Element
+        //    0     | weak fractional spacing
+        //    1     | weak spacing
+        //    2     | space
+
         match content {
             Content::Space => {
-                self.0.weak(ParChild::Text(' '.into()), 0, styles);
+                self.0.weak(ParChild::Text(' '.into()), styles, 2);
             }
-            Content::Linebreak(justified) => {
-                let c = if *justified { '\u{2028}' } else { '\n' };
+            &Content::Linebreak { justified } => {
+                let c = if justified { '\u{2028}' } else { '\n' };
                 self.0.destructive(ParChild::Text(c.into()), styles);
             }
-            Content::Horizontal(kind) => {
-                let child = ParChild::Spacing(*kind);
-                if kind.is_fractional() {
+            &Content::Horizontal { amount, weak } => {
+                let child = ParChild::Spacing(amount);
+                let frac = amount.is_fractional();
+                if weak {
+                    let weakness = u8::from(!frac);
+                    self.0.weak(child, styles, weakness);
+                } else if frac {
                     self.0.destructive(child, styles);
                 } else {
                     self.0.ignorant(child, styles);
                 }
             }
-            Content::Quote(double) => {
-                self.0.supportive(ParChild::Quote(*double), styles);
+            &Content::Quote { double } => {
+                self.0.supportive(ParChild::Quote { double }, styles);
             }
             Content::Text(text) => {
                 self.0.supportive(ParChild::Text(text.clone()), styles);
@@ -575,7 +624,7 @@ impl<'a> ParBuilder<'a> {
                 .items()
                 .find_map(|child| match child {
                     ParChild::Spacing(_) => None,
-                    ParChild::Text(_) | ParChild::Quote(_) => Some(true),
+                    ParChild::Text(_) | ParChild::Quote { .. } => Some(true),
                     ParChild::Node(_) => Some(false),
                 })
                 .unwrap_or_default()
@@ -585,10 +634,8 @@ impl<'a> ParBuilder<'a> {
                 .items()
                 .rev()
                 .find_map(|child| match child {
-                    FlowChild::Leading => None,
-                    FlowChild::Parbreak => None,
+                    FlowChild::Spacing(_) => None,
                     FlowChild::Node(node) => Some(node.is::<ParNode>()),
-                    FlowChild::Spacing(_) => Some(false),
                     FlowChild::Colbreak => Some(false),
                 })
                 .unwrap_or_default()
@@ -596,8 +643,7 @@ impl<'a> ParBuilder<'a> {
             children.push_front(ParChild::Spacing(indent.into()));
         }
 
-        let node = ParNode(children).pack();
-        parent.flow.0.supportive(FlowChild::Node(node), shared);
+        parent.flow.par(ParNode(children), shared, !indent.is_zero());
     }
 
     fn is_empty(&self) -> bool {
@@ -611,19 +657,24 @@ struct ListBuilder<'a> {
     items: StyleVecBuilder<'a, ListItem>,
     /// Whether the list contains no paragraph breaks.
     tight: bool,
+    /// Whether the list can be attached.
+    attachable: bool,
     /// Trailing content for which it is unclear whether it is part of the list.
     staged: Vec<(&'a Content, StyleChain<'a>)>,
 }
 
 impl<'a> ListBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
-        match content {
-            Content::Space if !self.items.is_empty() => {
-                self.staged.push((content, styles));
-            }
-            Content::Parbreak if !self.items.is_empty() => {
-                self.staged.push((content, styles));
+        if self.items.is_empty() {
+            match content {
+                Content::Space => {}
+                Content::Item(_) => {}
+                Content::Parbreak => self.attachable = false,
+                _ => self.attachable = true,
             }
+        }
+
+        match content {
             Content::Item(item)
                 if self
                     .items
@@ -634,6 +685,9 @@ impl<'a> ListBuilder<'a> {
                 self.items.push(item.clone(), styles);
                 self.tight &= self.staged.drain(..).all(|(t, _)| *t != Content::Parbreak);
             }
+            Content::Space | Content::Parbreak if !self.items.is_empty() => {
+                self.staged.push((content, styles));
+            }
             _ => return false,
         }
 
@@ -647,10 +701,17 @@ impl<'a> ListBuilder<'a> {
             None => return Ok(()),
         };
 
+        let start = 1;
         let tight = self.tight;
+        let attached = tight && self.attachable;
+
         let content = match kind {
-            UNORDERED => Content::show(ListNode::<UNORDERED> { start: 1, tight, items }),
-            ORDERED | _ => Content::show(ListNode::<ORDERED> { start: 1, tight, items }),
+            UNORDERED => {
+                Content::show(ListNode::<UNORDERED> { start, tight, attached, items })
+            }
+            ORDERED | _ => {
+                Content::show(ListNode::<ORDERED> { start, tight, attached, items })
+            }
         };
 
         let stored = parent.scratch.templates.alloc(content);
@@ -660,6 +721,8 @@ impl<'a> ListBuilder<'a> {
             parent.accept(content, styles)?;
         }
 
+        parent.list.attachable = true;
+
         Ok(())
     }
 
@@ -673,6 +736,7 @@ impl Default for ListBuilder<'_> {
         Self {
             items: StyleVecBuilder::default(),
             tight: true,
+            attachable: true,
             staged: vec![],
         }
     }
diff --git a/src/model/layout.rs b/src/model/layout.rs
index 78bfedc7..51154286 100644
--- a/src/model/layout.rs
+++ b/src/model/layout.rs
@@ -1,7 +1,7 @@
 //! Layouting infrastructure.
 
 use std::any::Any;
-use std::fmt::{self, Debug, Formatter};
+use std::fmt::{self, Debug, Formatter, Write};
 use std::hash::Hash;
 use std::sync::Arc;
 
@@ -239,7 +239,9 @@ impl Default for LayoutNode {
 
 impl Debug for LayoutNode {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.0.fmt(f)
+        f.write_str("Layout(")?;
+        self.0.fmt(f)?;
+        f.write_char(')')
     }
 }
 
diff --git a/src/model/show.rs b/src/model/show.rs
index d1365eb2..16374deb 100644
--- a/src/model/show.rs
+++ b/src/model/show.rs
@@ -1,4 +1,4 @@
-use std::fmt::{self, Debug, Formatter};
+use std::fmt::{self, Debug, Formatter, Write};
 use std::hash::Hash;
 use std::sync::Arc;
 
@@ -87,7 +87,9 @@ impl Show for ShowNode {
 
 impl Debug for ShowNode {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.0.fmt(f)
+        f.write_str("Show(")?;
+        self.0.fmt(f)?;
+        f.write_char(')')
     }
 }
 
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 145f86d6..32d61885 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -214,8 +214,8 @@ fn markup_node(p: &mut Parser, at_start: &mut bool) {
         | NodeKind::EnDash
         | NodeKind::EmDash
         | NodeKind::Ellipsis
-        | NodeKind::Quote(_)
-        | NodeKind::Linebreak(_)
+        | NodeKind::Quote { .. }
+        | NodeKind::Linebreak { .. }
         | NodeKind::Raw(_)
         | NodeKind::Math(_)
         | NodeKind::Escape(_) => {
diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index 4772be7f..f095bd09 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -141,8 +141,8 @@ impl<'s> Tokens<'s> {
             '~' => NodeKind::NonBreakingSpace,
             '-' => self.hyph(),
             '.' if self.s.eat_if("..") => NodeKind::Ellipsis,
-            '\'' => NodeKind::Quote(false),
-            '"' => NodeKind::Quote(true),
+            '\'' => NodeKind::Quote { double: false },
+            '"' => NodeKind::Quote { double: true },
             '*' if !self.in_word() => NodeKind::Star,
             '_' if !self.in_word() => NodeKind::Underscore,
             '`' => self.raw(),
@@ -266,7 +266,7 @@ impl<'s> Tokens<'s> {
     fn backslash(&mut self) -> NodeKind {
         let c = match self.s.peek() {
             Some(c) => c,
-            None => return NodeKind::Linebreak(false),
+            None => return NodeKind::Linebreak { justified: false },
         };
 
         match c {
@@ -300,10 +300,10 @@ impl<'s> Tokens<'s> {
             }
 
             // Linebreaks.
-            c if c.is_whitespace() => NodeKind::Linebreak(false),
+            c if c.is_whitespace() => NodeKind::Linebreak { justified: false },
             '+' => {
                 self.s.expect(c);
-                NodeKind::Linebreak(true)
+                NodeKind::Linebreak { justified: true }
             }
 
             // Just the backslash.
@@ -839,7 +839,7 @@ mod tests {
         t!(Markup[" /"]: "hello-world" => Text("hello-world"));
 
         // Test code symbols in text.
-        t!(Markup[" /"]: "a():\"b" => Text("a():"), Quote(true), Text("b"));
+        t!(Markup[" /"]: "a():\"b" => Text("a():"), Quote { double: true }, Text("b"));
         t!(Markup[" /"]: ";:,|/+"  => Text(";:,|"), Text("/+"));
         t!(Markup[" /"]: "=-a"     => Eq, Minus, Text("a"));
         t!(Markup[" "]: "#123"     => Text("#"), Text("123"));
@@ -893,8 +893,8 @@ mod tests {
         t!(Markup: "_"          => Underscore);
         t!(Markup[""]: "==="    => Eq, Eq, Eq);
         t!(Markup["a1/"]: "= "  => Eq, Space(0));
-        t!(Markup[" "]: r"\"    => Linebreak(false));
-        t!(Markup[" "]: r"\+"   => Linebreak(true));
+        t!(Markup[" "]: r"\"    => Linebreak { justified: false });
+        t!(Markup[" "]: r"\+"   => Linebreak { justified: true });
         t!(Markup: "~"          => NonBreakingSpace);
         t!(Markup["a1/"]: "-?"  => Shy);
         t!(Markup["a "]: r"a--" => Text("a"), EnDash);
diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
index 5232b1f1..42a4235d 100644
--- a/src/syntax/ast.rs
+++ b/src/syntax/ast.rs
@@ -2,6 +2,7 @@
 //!
 //! The AST is rooted in the [`Markup`] node.
 
+use std::num::NonZeroUsize;
 use std::ops::Deref;
 
 use super::{Green, GreenData, NodeKind, RedNode, RedRef, Span};
@@ -62,7 +63,9 @@ impl Markup {
         self.0.children().filter_map(|node| match node.kind() {
             NodeKind::Space(2 ..) => Some(MarkupNode::Parbreak),
             NodeKind::Space(_) => Some(MarkupNode::Space),
-            NodeKind::Linebreak(j) => Some(MarkupNode::Linebreak(*j)),
+            &NodeKind::Linebreak { justified } => {
+                Some(MarkupNode::Linebreak { justified })
+            }
             NodeKind::Text(s) => Some(MarkupNode::Text(s.clone())),
             NodeKind::Escape(c) => Some(MarkupNode::Text((*c).into())),
             NodeKind::NonBreakingSpace => Some(MarkupNode::Text('\u{00A0}'.into())),
@@ -70,7 +73,7 @@ impl Markup {
             NodeKind::EnDash => Some(MarkupNode::Text('\u{2013}'.into())),
             NodeKind::EmDash => Some(MarkupNode::Text('\u{2014}'.into())),
             NodeKind::Ellipsis => Some(MarkupNode::Text('\u{2026}'.into())),
-            NodeKind::Quote(d) => Some(MarkupNode::Quote(*d)),
+            &NodeKind::Quote { double } => Some(MarkupNode::Quote { double }),
             NodeKind::Strong => node.cast().map(MarkupNode::Strong),
             NodeKind::Emph => node.cast().map(MarkupNode::Emph),
             NodeKind::Raw(raw) => Some(MarkupNode::Raw(raw.as_ref().clone())),
@@ -88,15 +91,14 @@ impl Markup {
 pub enum MarkupNode {
     /// Whitespace containing less than two newlines.
     Space,
-    /// A forced line break. If `true` (`\`), the preceding line can still be
-    /// justified, if `false` (`\+`) not.
-    Linebreak(bool),
+    /// A forced line break: `\` or `\+` if justified.
+    Linebreak { justified: bool },
     /// A paragraph break: Two or more newlines.
     Parbreak,
     /// Plain text.
     Text(EcoString),
-    /// A smart quote: `'` (`false`) or `"` (true).
-    Quote(bool),
+    /// A smart quote: `'` or `"`.
+    Quote { double: bool },
     /// Strong content: `*Strong*`.
     Strong(StrongNode),
     /// Emphasized content: `_Emphasized_`.
@@ -176,8 +178,13 @@ impl HeadingNode {
     }
 
     /// The section depth (numer of equals signs).
-    pub fn level(&self) -> usize {
-        self.0.children().filter(|n| n.kind() == &NodeKind::Eq).count()
+    pub fn level(&self) -> NonZeroUsize {
+        self.0
+            .children()
+            .filter(|n| n.kind() == &NodeKind::Eq)
+            .count()
+            .try_into()
+            .expect("heading is missing equals sign")
     }
 }
 
diff --git a/src/syntax/highlight.rs b/src/syntax/highlight.rs
index 9bee73ae..8e62424f 100644
--- a/src/syntax/highlight.rs
+++ b/src/syntax/highlight.rs
@@ -126,7 +126,7 @@ impl Category {
                 _ => Some(Category::Operator),
             },
             NodeKind::EnumNumbering(_) => Some(Category::List),
-            NodeKind::Linebreak(_) => Some(Category::Shortcut),
+            NodeKind::Linebreak { .. } => Some(Category::Shortcut),
             NodeKind::NonBreakingSpace => Some(Category::Shortcut),
             NodeKind::Shy => Some(Category::Shortcut),
             NodeKind::EnDash => Some(Category::Shortcut),
@@ -206,7 +206,7 @@ impl Category {
             NodeKind::Markup(_) => None,
             NodeKind::Space(_) => None,
             NodeKind::Text(_) => None,
-            NodeKind::Quote(_) => None,
+            NodeKind::Quote { .. } => None,
             NodeKind::List => None,
             NodeKind::Enum => None,
             NodeKind::CodeBlock => None,
diff --git a/src/syntax/mod.rs b/src/syntax/mod.rs
index 2272b3e0..d21597ff 100644
--- a/src/syntax/mod.rs
+++ b/src/syntax/mod.rs
@@ -588,9 +588,8 @@ pub enum NodeKind {
     Space(usize),
     /// A consecutive non-markup string.
     Text(EcoString),
-    /// A forced line break. If `true` (`\`), the preceding line can still be
-    /// justified, if `false` (`\+`) not.
-    Linebreak(bool),
+    /// A forced line break: `\` or `\+` if justified.
+    Linebreak { justified: bool },
     /// A non-breaking space: `~`.
     NonBreakingSpace,
     /// A soft hyphen: `-?`.
@@ -601,8 +600,8 @@ pub enum NodeKind {
     EmDash,
     /// An ellipsis: `...`.
     Ellipsis,
-    /// A smart quote: `'` (`false`) or `"` (true).
-    Quote(bool),
+    /// A smart quote: `'` or `"`.
+    Quote { double: bool },
     /// A slash and the letter "u" followed by a hexadecimal unicode entity
     /// enclosed in curly braces: `\u{1F5FA}`.
     Escape(char),
@@ -773,13 +772,13 @@ impl NodeKind {
     pub fn only_in_mode(&self) -> Option<TokenMode> {
         match self {
             Self::Markup(_)
-            | Self::Linebreak(_)
+            | Self::Linebreak { .. }
             | Self::Text(_)
             | Self::NonBreakingSpace
             | Self::EnDash
             | Self::EmDash
             | Self::Ellipsis
-            | Self::Quote(_)
+            | Self::Quote { .. }
             | Self::Escape(_)
             | Self::Strong
             | Self::Emph
@@ -867,16 +866,16 @@ impl NodeKind {
             Self::Markup(_) => "markup",
             Self::Space(2 ..) => "paragraph break",
             Self::Space(_) => "space",
-            Self::Linebreak(false) => "linebreak",
-            Self::Linebreak(true) => "justified linebreak",
+            Self::Linebreak { justified: false } => "linebreak",
+            Self::Linebreak { justified: true } => "justified linebreak",
             Self::Text(_) => "text",
             Self::NonBreakingSpace => "non-breaking space",
             Self::Shy => "soft hyphen",
             Self::EnDash => "en dash",
             Self::EmDash => "em dash",
             Self::Ellipsis => "ellipsis",
-            Self::Quote(false) => "single quote",
-            Self::Quote(true) => "double quote",
+            Self::Quote { double: false } => "single quote",
+            Self::Quote { double: true } => "double quote",
             Self::Escape(_) => "escape sequence",
             Self::Strong => "strong content",
             Self::Emph => "emphasized content",
@@ -993,14 +992,14 @@ impl Hash for NodeKind {
             Self::From => {}
             Self::Markup(c) => c.hash(state),
             Self::Space(n) => n.hash(state),
-            Self::Linebreak(s) => s.hash(state),
+            Self::Linebreak { justified } => justified.hash(state),
             Self::Text(s) => s.hash(state),
             Self::NonBreakingSpace => {}
             Self::Shy => {}
             Self::EnDash => {}
             Self::EmDash => {}
             Self::Ellipsis => {}
-            Self::Quote(d) => d.hash(state),
+            Self::Quote { double } => double.hash(state),
             Self::Escape(c) => c.hash(state),
             Self::Strong => {}
             Self::Emph => {}