diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 41f17d137..c5c81537b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -40,7 +40,7 @@ jobs:
           sudo dpkg --add-architecture i386
           sudo apt update
           sudo apt install -y gcc-multilib libssl-dev:i386 pkg-config:i386
-      - uses: dtolnay/rust-toolchain@1.85.0
+      - uses: dtolnay/rust-toolchain@1.87.0
         with:
           targets: ${{ matrix.bits == 32 && 'i686-unknown-linux-gnu' || '' }}
       - uses: Swatinem/rust-cache@v2
@@ -73,7 +73,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.85.0
+      - uses: dtolnay/rust-toolchain@1.87.0
         with:
           components: clippy, rustfmt
       - uses: Swatinem/rust-cache@v2
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0d235aec5..ca317abd0 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -44,7 +44,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: dtolnay/rust-toolchain@1.85.0
+    - uses: dtolnay/rust-toolchain@1.87.0
       with:
         target: ${{ matrix.target }}
 
diff --git a/Cargo.lock b/Cargo.lock
index 06dd4ab80..b699d2450 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -217,6 +217,20 @@ name = "bytemuck"
 version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
+dependencies = [
+ "bytemuck_derive",
+]
+
+[[package]]
+name = "bytemuck_derive"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fa76293b4f7bb636ab88fd78228235b5248b4d05cc589aed610f954af5d7c7a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "byteorder"
@@ -494,9 +508,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -735,11 +749,12 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.0.35"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c936bfdafb507ebbf50b8074c54fa31c5be9a1e7e5f467dd659697041407d07c"
+checksum = "11faaf5a5236997af9848be0bef4db95824b1d534ebc64d0f0c6cf3e67bd38dc"
 dependencies = [
  "crc32fast",
+ "libz-rs-sys",
  "miniz_oxide",
 ]
 
@@ -749,6 +764,15 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
 
+[[package]]
+name = "float-cmp"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -761,6 +785,15 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
 
+[[package]]
+name = "font-types"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa6a5e5a77b5f3f7f9e32879f484aa5b3632ddfbe568a16266c904a6f32cdaf"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "fontconfig-parser"
 version = "0.5.7"
@@ -829,6 +862,15 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "getopts"
 version = "0.2.21"
@@ -871,6 +913,12 @@ dependencies = [
  "weezl",
 ]
 
+[[package]]
+name = "glidesort"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2e102e6eb644d3e0b186fc161e4460417880a0a0b87d235f2e5b8fb30f2e9e0"
+
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -966,7 +1014,7 @@ checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
 dependencies = [
  "displaydoc",
  "serde",
- "yoke",
+ "yoke 0.7.5",
  "zerofrom",
  "zerovec",
 ]
@@ -1064,7 +1112,7 @@ dependencies = [
  "stable_deref_trait",
  "tinystr",
  "writeable",
- "yoke",
+ "yoke 0.7.5",
  "zerofrom",
  "zerovec",
 ]
@@ -1167,6 +1215,7 @@ dependencies = [
  "byteorder-lite",
  "color_quant",
  "gif",
+ "image-webp",
  "num-traits",
  "png",
  "zune-core",
@@ -1211,6 +1260,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+
 [[package]]
 name = "inotify"
 version = "0.11.0"
@@ -1310,6 +1365,50 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "krilla"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69ee6128ebf52d7ce684613b6431ead2959f2be9ff8cf776eeaaad0427c953e9"
+dependencies = [
+ "base64",
+ "bumpalo",
+ "comemo",
+ "flate2",
+ "float-cmp 0.10.0",
+ "fxhash",
+ "gif",
+ "image-webp",
+ "imagesize",
+ "once_cell",
+ "pdf-writer",
+ "png",
+ "rayon",
+ "rustybuzz",
+ "siphasher",
+ "skrifa",
+ "subsetter",
+ "tiny-skia-path",
+ "xmp-writer",
+ "yoke 0.8.0",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "krilla-svg"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3462989578155cf620ef8035f8921533cc95c28e2a0c75de172f7219e6aba84e"
+dependencies = [
+ "flate2",
+ "fontdb",
+ "krilla",
+ "png",
+ "resvg",
+ "tiny-skia",
+ "usvg",
+]
+
 [[package]]
 name = "kurbo"
 version = "0.11.1"
@@ -1371,6 +1470,15 @@ dependencies = [
  "redox_syscall",
 ]
 
+[[package]]
+name = "libz-rs-sys"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "902bc563b5d65ad9bba616b490842ef0651066a1a1dc3ce1087113ffcb873c8d"
+dependencies = [
+ "zlib-rs",
+]
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -1458,9 +1566,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8402cab7aefae129c6977bb0ff1b8fd9a04eb5b51efc50a70bea51cda0c7924"
+checksum = "8e3e04debbb59698c15bacbb6d93584a8c0ca9cc3213cb423d31f760d8843ce5"
 dependencies = [
  "adler2",
  "simd-adler32",
@@ -1601,9 +1709,9 @@ dependencies = [
 
 [[package]]
 name = "openssl"
-version = "0.10.70"
+version = "0.10.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61cfb4e166a8bb8c9b55c500bc2308550148ece889be90f609377e58140f42c6"
+checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
 dependencies = [
  "bitflags 2.8.0",
  "cfg-if",
@@ -1642,9 +1750,9 @@ dependencies = [
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.105"
+version = "0.9.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b22d5b84be05a8d6947c7cb71f7c849aa0f112acd4bf51c2a7c1c988ac0a9dc"
+checksum = "8288979acd84749c744a9014b4382d42b8f7b2592847b5afb2ed29e5d16ede07"
 dependencies = [
  "cc",
  "libc",
@@ -1738,9 +1846,9 @@ checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
 
 [[package]]
 name = "pdf-writer"
-version = "0.12.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5df03c7d216de06f93f398ef06f1385a60f2c597bb96f8195c8d98e08a26b1d5"
+checksum = "3ea27c5015ab81753fc61e49f8cde74999346605ee148bb20008ef3d3150e0dc"
 dependencies = [
  "bitflags 2.8.0",
  "itoa",
@@ -1997,6 +2105,16 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "read-fonts"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "600e807b48ac55bad68a8cb75cc3c7739f139b9248f7e003e01e080f589b5288"
+dependencies = [
+ "bytemuck",
+ "font-types",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.8"
@@ -2315,6 +2433,16 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
+[[package]]
+name = "skrifa"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fa1e5622e4f7b98877e8a19890efddcac1230cec6198bd9de91ec0e00010dc8"
+dependencies = [
+ "bytemuck",
+ "read-fonts",
+]
+
 [[package]]
 name = "slotmap"
 version = "1.0.7"
@@ -2361,7 +2489,7 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731"
 dependencies = [
- "float-cmp",
+ "float-cmp 0.9.0",
 ]
 
 [[package]]
@@ -2404,28 +2532,11 @@ dependencies = [
 
 [[package]]
 name = "subsetter"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74f98178f34057d4d4de93d68104007c6dea4dfac930204a69ab4622daefa648"
-
-[[package]]
-name = "svg2pdf"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e50dc062439cc1a396181059c80932a6e6bd731b130e674c597c0c8874b6df22"
+checksum = "35539e8de3dcce8dd0c01f3575f85db1e5ac1aea1b996d2d09d89f148bc91497"
 dependencies = [
- "fontdb",
- "image",
- "log",
- "miniz_oxide",
- "once_cell",
- "pdf-writer",
- "resvg",
- "siphasher",
- "subsetter",
- "tiny-skia",
- "ttf-parser",
- "usvg",
+ "fxhash",
 ]
 
 [[package]]
@@ -2753,7 +2864,7 @@ dependencies = [
 [[package]]
 name = "typst-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-assets?rev=ab1295f#ab1295ff896444e51902e03c2669955e1d73604a"
+source = "git+https://github.com/typst/typst-assets?rev=c74e539#c74e539b090070a0c66fd007c550f5b6d3b724bd"
 
 [[package]]
 name = "typst-cli"
@@ -2803,7 +2914,7 @@ dependencies = [
 [[package]]
 name = "typst-dev-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-dev-assets?rev=9879589#9879589f4b3247b12c5e694d0d7fa86d4d8a198e"
+source = "git+https://github.com/typst/typst-dev-assets?rev=fddbf8b#fddbf8b99506bc370ac0edcd4959add603a7fc92"
 
 [[package]]
 name = "typst-docs"
@@ -2928,6 +3039,7 @@ dependencies = [
  "icu_provider_blob",
  "icu_segmenter",
  "kurbo",
+ "memchr",
  "rustybuzz",
  "smallvec",
  "ttf-parser",
@@ -2958,6 +3070,7 @@ dependencies = [
  "ecow",
  "flate2",
  "fontdb",
+ "glidesort",
  "hayagriva",
  "icu_properties",
  "icu_provider",
@@ -3000,6 +3113,7 @@ dependencies = [
  "unicode-segmentation",
  "unscanny",
  "usvg",
+ "utf8_iter",
  "wasmi",
  "xmlwriter",
 ]
@@ -3018,26 +3132,20 @@ dependencies = [
 name = "typst-pdf"
 version = "0.13.1"
 dependencies = [
- "arrayvec",
- "base64",
  "bytemuck",
  "comemo",
  "ecow",
  "image",
- "indexmap 2.7.1",
- "miniz_oxide",
- "pdf-writer",
+ "infer",
+ "krilla",
+ "krilla-svg",
  "serde",
- "subsetter",
- "svg2pdf",
- "ttf-parser",
  "typst-assets",
  "typst-library",
  "typst-macros",
  "typst-syntax",
  "typst-timing",
  "typst-utils",
- "xmp-writer",
 ]
 
 [[package]]
@@ -3094,6 +3202,7 @@ dependencies = [
 name = "typst-syntax"
 version = "0.13.1"
 dependencies = [
+ "comemo",
  "ecow",
  "serde",
  "toml",
@@ -3661,9 +3770,9 @@ checksum = "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9"
 
 [[package]]
 name = "xmp-writer"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb5954c9ca6dcc869e98d3e42760ed9dab08f3e70212b31d7ab8ae7f3b7a487"
+checksum = "ce9e2f4a404d9ebffc0a9832cf4f50907220ba3d7fffa9099261a5cab52f2dd7"
 
 [[package]]
 name = "xz2"
@@ -3701,7 +3810,19 @@ checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
 dependencies = [
  "serde",
  "stable_deref_trait",
- "yoke-derive",
+ "yoke-derive 0.7.5",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive 0.8.0",
  "zerofrom",
 ]
 
@@ -3717,6 +3838,18 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "yoke-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.35"
@@ -3778,7 +3911,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
 dependencies = [
  "serde",
- "yoke",
+ "yoke 0.7.5",
  "zerofrom",
  "zerovec-derive",
 ]
@@ -3796,21 +3929,25 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.2.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae9c1ea7b3a5e1f4b922ff856a129881167511563dc219869afe3787fc0c1a45"
+checksum = "27c03817464f64e23f6f37574b4fdc8cf65925b5bfd2b0f2aedf959791941f88"
 dependencies = [
  "arbitrary",
  "crc32fast",
  "crossbeam-utils",
- "displaydoc",
  "flate2",
  "indexmap 2.7.1",
  "memchr",
- "thiserror 2.0.11",
  "zopfli",
 ]
 
+[[package]]
+name = "zlib-rs"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b20717f0917c908dc63de2e44e97f1e6b126ca58d0e391cee86d504eb8fbd05"
+
 [[package]]
 name = "zopfli"
 version = "0.8.1"
diff --git a/Cargo.toml b/Cargo.toml
index 4e0d3a26c..b548245fa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,8 +32,8 @@ typst-svg = { path = "crates/typst-svg", version = "0.13.1" }
 typst-syntax = { path = "crates/typst-syntax", version = "0.13.1" }
 typst-timing = { path = "crates/typst-timing", version = "0.13.1" }
 typst-utils = { path = "crates/typst-utils", version = "0.13.1" }
-typst-assets = { git = "https://github.com/typst/typst-assets", rev = "ab1295f" }
-typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "9879589" }
+typst-assets = { git = "https://github.com/typst/typst-assets", rev = "c74e539" }
+typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "fddbf8b" }
 arrayvec = "0.7.4"
 az = "1.2"
 base64 = "0.22"
@@ -59,6 +59,7 @@ fastrand = "2.3"
 flate2 = "1"
 fontdb = { version = "0.23", default-features = false }
 fs_extra = "1.3"
+glidesort = "0.1.2"
 hayagriva = "0.8.1"
 heck = "0.5"
 hypher = "0.1.4"
@@ -68,24 +69,25 @@ icu_provider_adapters = "1.4"
 icu_provider_blob = "1.4"
 icu_segmenter = { version = "1.4", features = ["serde"] }
 if_chain = "1"
-image = { version = "0.25.5", default-features = false, features = ["png", "jpeg", "gif"] }
+image = { version = "0.25.5", default-features = false, features = ["png", "jpeg", "gif", "webp"] }
 indexmap = { version = "2", features = ["serde"] }
+infer = { version = "0.19.0", default-features = false }
 kamadak-exif = "0.6"
+krilla = { version = "0.4.0", default-features = false, features = ["raster-images", "comemo", "rayon"] }
+krilla-svg = "0.1.0"
 kurbo = "0.11"
 libfuzzer-sys = "0.4"
 lipsum = "0.9"
 memchr = "2"
-miniz_oxide = "0.8"
 native-tls = "0.2"
 notify = "8"
 once_cell = "1"
 open = "5.0.1"
-openssl = "0.10"
+openssl = "0.10.72"
 oxipng = { version = "9.0", default-features = false, features = ["filetime", "parallel", "zopfli"] }
 palette = { version = "0.7.3", default-features = false, features = ["approx", "libm"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
-pdf-writer = "0.12.1"
 phf = { version = "0.11", features = ["macros"] }
 pixglyph = "0.6"
 png = "0.17"
@@ -112,8 +114,6 @@ sigpipe = "0.1"
 siphasher = "1"
 smallvec = { version = "1.11.1", features = ["union", "const_generics", "const_new"] }
 stacker = "0.1.15"
-subsetter = "0.2"
-svg2pdf = "0.13"
 syn = { version = "2", features = ["full", "extra-traits"] }
 syntect = { version = "5", default-features = false, features = ["parsing", "regex-fancy", "plist-load", "yaml-load"] }
 tar = "0.4"
@@ -135,15 +135,15 @@ unicode-segmentation = "1"
 unscanny = "0.1"
 ureq = { version = "2", default-features = false, features = ["native-tls", "gzip", "json"] }
 usvg = { version = "0.45", default-features = false, features = ["text"] }
+utf8_iter = "1.0.4"
 walkdir = "2"
 wasmi = "0.40.0"
 web-sys = "0.3"
 xmlparser = "0.13.5"
 xmlwriter = "0.1.0"
-xmp-writer = "0.3.1"
 xz2 = { version = "0.1", features = ["static"] }
 yaml-front-matter = "0.1"
-zip = { version = "2", default-features = false, features = ["deflate"] }
+zip = { version = "2.5", default-features = false, features = ["deflate"] }
 
 [profile.dev.package."*"]
 opt-level = 2
diff --git a/README.md b/README.md
index 41f465152..9526f3df4 100644
--- a/README.md
+++ b/README.md
@@ -113,7 +113,7 @@ Typst's CLI is available from different sources:
 
 - You can install Typst through different package managers. Note that the
   versions in the package managers might lag behind the latest release.
-  - Linux: 
+  - Linux:
       - View [Typst on Repology][repology]
       - View [Typst's Snap][snap]
   - macOS: `brew install typst`
@@ -177,22 +177,22 @@ If you prefer an integrated IDE-like experience with autocompletion and instant
 preview, you can also check out [Typst's free web app][app].
 
 ## Community
-The main place where the community gathers is our [Discord server][discord].
-Feel free to join there to ask questions, help out others, share cool things
-you created with Typst, or just to chat.
+The main places where the community gathers are our [Forum][forum] and our
+[Discord server][discord]. The Forum is a great place to ask questions, help
+others, and share cool things you created with Typst. The Discord server is more
+suitable for quicker questions, discussions about contributing, or just to chat.
+We'd be happy to see you there!
 
-Aside from that there are a few places where you can find things built by
-the community:
-
-- The official [package list](https://typst.app/docs/packages)
-- The [Awesome Typst](https://github.com/qjcg/awesome-typst) repository
+[Typst Universe][universe] is where the community shares templates and packages.
+If you want to share your own creations, you can submit them to our
+[package repository][packages].
 
 If you had a bad experience in our community, please [reach out to us][contact].
 
 ## Contributing
-We would love to see contributions from the community. If you experience bugs,
-feel free to open an issue. If you would like to implement a new feature or bug
-fix, please follow the steps outlined in the [contribution guide][contributing].
+We love to see contributions from the community. If you experience bugs, feel
+free to open an issue. If you would like to implement a new feature or bug fix,
+please follow the steps outlined in the [contribution guide][contributing].
 
 To build Typst yourself, first ensure that you have the
 [latest stable Rust][rust] installed. Then, clone this repository and build the
@@ -243,6 +243,8 @@ instant preview. To achieve these goals, we follow three core design principles:
 [docs]: https://typst.app/docs/
 [app]: https://typst.app/
 [discord]: https://discord.gg/2uDybryKPe
+[forum]: https://forum.typst.app/
+[universe]: https://typst.app/universe/
 [tutorial]: https://typst.app/docs/tutorial/
 [show]: https://typst.app/docs/reference/styling/#show-rules
 [math]: https://typst.app/docs/reference/math/
diff --git a/crates/typst-cli/src/args.rs b/crates/typst-cli/src/args.rs
index d6855d100..fd0eb5f05 100644
--- a/crates/typst-cli/src/args.rs
+++ b/crates/typst-cli/src/args.rs
@@ -361,7 +361,7 @@ pub struct FontArgs {
 
     /// Ensures system fonts won't be searched, unless explicitly included via
     /// `--font-path`.
-    #[arg(long)]
+    #[arg(long, env = "TYPST_IGNORE_SYSTEM_FONTS")]
     pub ignore_system_fonts: bool,
 }
 
@@ -467,15 +467,45 @@ display_possible_values!(Feature);
 #[derive(Debug, Copy, Clone, Eq, PartialEq, ValueEnum)]
 #[allow(non_camel_case_types)]
 pub enum PdfStandard {
+    /// PDF 1.4.
+    #[value(name = "1.4")]
+    V_1_4,
+    /// PDF 1.5.
+    #[value(name = "1.5")]
+    V_1_5,
+    /// PDF 1.5.
+    #[value(name = "1.6")]
+    V_1_6,
     /// PDF 1.7.
     #[value(name = "1.7")]
     V_1_7,
+    /// PDF 2.0.
+    #[value(name = "2.0")]
+    V_2_0,
+    /// PDF/A-1b.
+    #[value(name = "a-1b")]
+    A_1b,
     /// PDF/A-2b.
     #[value(name = "a-2b")]
     A_2b,
-    /// PDF/A-3b.
+    /// PDF/A-2u.
+    #[value(name = "a-2u")]
+    A_2u,
+    /// PDF/A-3u.
     #[value(name = "a-3b")]
     A_3b,
+    /// PDF/A-3u.
+    #[value(name = "a-3u")]
+    A_3u,
+    /// PDF/A-4.
+    #[value(name = "a-4")]
+    A_4,
+    /// PDF/A-4f.
+    #[value(name = "a-4f")]
+    A_4f,
+    /// PDF/A-4e.
+    #[value(name = "a-4e")]
+    A_4e,
 }
 
 display_possible_values!(PdfStandard);
diff --git a/crates/typst-cli/src/compile.rs b/crates/typst-cli/src/compile.rs
index ae71e298c..207bb7d09 100644
--- a/crates/typst-cli/src/compile.rs
+++ b/crates/typst-cli/src/compile.rs
@@ -16,7 +16,7 @@ use typst::diag::{
 use typst::foundations::{Datetime, Smart};
 use typst::html::HtmlDocument;
 use typst::layout::{Frame, Page, PageRanges, PagedDocument};
-use typst::syntax::{FileId, Source, Span};
+use typst::syntax::{FileId, Lines, Span};
 use typst::WorldExt;
 use typst_pdf::{PdfOptions, PdfStandards, Timestamp};
 
@@ -63,8 +63,7 @@ pub struct CompileConfig {
     /// Opens the output file with the default viewer or a specific program after
     /// compilation.
     pub open: Option<Option<String>>,
-    /// One (or multiple comma-separated) PDF standards that Typst will enforce
-    /// conformance with.
+    /// A list of standards the PDF should conform to.
     pub pdf_standards: PdfStandards,
     /// A path to write a Makefile rule describing the current compilation.
     pub make_deps: Option<PathBuf>,
@@ -130,18 +129,9 @@ impl CompileConfig {
             PageRanges::new(export_ranges.iter().map(|r| r.0.clone()).collect())
         });
 
-        let pdf_standards = {
-            let list = args
-                .pdf_standard
-                .iter()
-                .map(|standard| match standard {
-                    PdfStandard::V_1_7 => typst_pdf::PdfStandard::V_1_7,
-                    PdfStandard::A_2b => typst_pdf::PdfStandard::A_2b,
-                    PdfStandard::A_3b => typst_pdf::PdfStandard::A_3b,
-                })
-                .collect::<Vec<_>>();
-            PdfStandards::new(&list)?
-        };
+        let pdf_standards = PdfStandards::new(
+            &args.pdf_standard.iter().copied().map(Into::into).collect::<Vec<_>>(),
+        )?;
 
         #[cfg(feature = "http-server")]
         let server = match watch {
@@ -295,6 +285,7 @@ fn export_pdf(document: &PagedDocument, config: &CompileConfig) -> SourceResult<
             })
         }
     };
+
     let options = PdfOptions {
         ident: Smart::Auto,
         timestamp,
@@ -705,7 +696,7 @@ fn label(world: &SystemWorld, span: Span) -> Option<Label<FileId>> {
 impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
     type FileId = FileId;
     type Name = String;
-    type Source = Source;
+    type Source = Lines<String>;
 
     fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
         let vpath = id.vpath();
@@ -765,3 +756,23 @@ impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
         })
     }
 }
+
+impl From<PdfStandard> for typst_pdf::PdfStandard {
+    fn from(standard: PdfStandard) -> Self {
+        match standard {
+            PdfStandard::V_1_4 => typst_pdf::PdfStandard::V_1_4,
+            PdfStandard::V_1_5 => typst_pdf::PdfStandard::V_1_5,
+            PdfStandard::V_1_6 => typst_pdf::PdfStandard::V_1_6,
+            PdfStandard::V_1_7 => typst_pdf::PdfStandard::V_1_7,
+            PdfStandard::V_2_0 => typst_pdf::PdfStandard::V_2_0,
+            PdfStandard::A_1b => typst_pdf::PdfStandard::A_1b,
+            PdfStandard::A_2b => typst_pdf::PdfStandard::A_2b,
+            PdfStandard::A_2u => typst_pdf::PdfStandard::A_2u,
+            PdfStandard::A_3b => typst_pdf::PdfStandard::A_3b,
+            PdfStandard::A_3u => typst_pdf::PdfStandard::A_3u,
+            PdfStandard::A_4 => typst_pdf::PdfStandard::A_4,
+            PdfStandard::A_4f => typst_pdf::PdfStandard::A_4f,
+            PdfStandard::A_4e => typst_pdf::PdfStandard::A_4e,
+        }
+    }
+}
diff --git a/crates/typst-cli/src/query.rs b/crates/typst-cli/src/query.rs
index 610f23cd4..7806e456f 100644
--- a/crates/typst-cli/src/query.rs
+++ b/crates/typst-cli/src/query.rs
@@ -2,6 +2,7 @@ use comemo::Track;
 use ecow::{eco_format, EcoString};
 use serde::Serialize;
 use typst::diag::{bail, HintedStrResult, StrResult, Warned};
+use typst::engine::Sink;
 use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
 use typst::layout::PagedDocument;
 use typst::syntax::Span;
@@ -58,6 +59,8 @@ fn retrieve(
     let selector = eval_string(
         &typst::ROUTINES,
         world.track(),
+        // TODO: propagate warnings
+        Sink::new().track_mut(),
         &command.selector,
         Span::detached(),
         EvalMode::Code,
diff --git a/crates/typst-cli/src/timings.rs b/crates/typst-cli/src/timings.rs
index 9f017dc12..3d10bbc67 100644
--- a/crates/typst-cli/src/timings.rs
+++ b/crates/typst-cli/src/timings.rs
@@ -85,6 +85,6 @@ fn resolve_span(world: &SystemWorld, span: Span) -> Option<(String, u32)> {
     let id = span.id()?;
     let source = world.source(id).ok()?;
     let range = source.range(span)?;
-    let line = source.byte_to_line(range.start)?;
+    let line = source.lines().byte_to_line(range.start)?;
     Some((format!("{id:?}"), line as u32 + 1))
 }
diff --git a/crates/typst-cli/src/world.rs b/crates/typst-cli/src/world.rs
index 12e80d273..95bee235c 100644
--- a/crates/typst-cli/src/world.rs
+++ b/crates/typst-cli/src/world.rs
@@ -9,7 +9,7 @@ use ecow::{eco_format, EcoString};
 use parking_lot::Mutex;
 use typst::diag::{FileError, FileResult};
 use typst::foundations::{Bytes, Datetime, Dict, IntoValue};
-use typst::syntax::{FileId, Source, VirtualPath};
+use typst::syntax::{FileId, Lines, Source, VirtualPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
 use typst::{Library, World};
@@ -181,10 +181,20 @@ impl SystemWorld {
         }
     }
 
-    /// Lookup a source file by id.
+    /// Lookup line metadata for a file by id.
     #[track_caller]
-    pub fn lookup(&self, id: FileId) -> Source {
-        self.source(id).expect("file id does not point to any source file")
+    pub fn lookup(&self, id: FileId) -> Lines<String> {
+        self.slot(id, |slot| {
+            if let Some(source) = slot.source.get() {
+                let source = source.as_ref().expect("file is not valid");
+                source.lines().clone()
+            } else if let Some(bytes) = slot.file.get() {
+                let bytes = bytes.as_ref().expect("file is not valid");
+                Lines::try_from(bytes).expect("file is not valid utf-8")
+            } else {
+                panic!("file id does not point to any source file");
+            }
+        })
     }
 }
 
@@ -210,7 +220,9 @@ impl World for SystemWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        self.fonts[index].get()
+        // comemo's validation may invoke this function with an invalid index. This is
+        // impossible in typst-cli but possible if a custom tool mutates the fonts.
+        self.fonts.get(index)?.get()
     }
 
     fn today(&self, offset: Option<i64>) -> Option<Datetime> {
@@ -337,6 +349,11 @@ impl<T: Clone> SlotCell<T> {
         self.accessed = false;
     }
 
+    /// Gets the contents of the cell.
+    fn get(&self) -> Option<&FileResult<T>> {
+        self.data.as_ref()
+    }
+
     /// Gets the contents of the cell or initialize them.
     fn get_or_init(
         &mut self,
diff --git a/crates/typst-eval/src/call.rs b/crates/typst-eval/src/call.rs
index 1ca7b4b8f..eaeabbab3 100644
--- a/crates/typst-eval/src/call.rs
+++ b/crates/typst-eval/src/call.rs
@@ -25,19 +25,22 @@ impl Eval for ast::FuncCall<'_> {
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         let span = self.span();
         let callee = self.callee();
-        let in_math = in_math(callee);
         let callee_span = callee.span();
         let args = self.args();
-        let trailing_comma = args.trailing_comma();
 
         vm.engine.route.check_call_depth().at(span)?;
 
         // Try to evaluate as a call to an associated function or field.
-        let (callee, args) = if let ast::Expr::FieldAccess(access) = callee {
+        let (callee_value, args_value) = if let ast::Expr::FieldAccess(access) = callee {
             let target = access.target();
             let field = access.field();
             match eval_field_call(target, field, args, span, vm)? {
-                FieldCall::Normal(callee, args) => (callee, args),
+                FieldCall::Normal(callee, args) => {
+                    if vm.inspected == Some(callee_span) {
+                        vm.trace(callee.clone());
+                    }
+                    (callee, args)
+                }
                 FieldCall::Resolved(value) => return Ok(value),
             }
         } else {
@@ -45,9 +48,15 @@ impl Eval for ast::FuncCall<'_> {
             (callee.eval(vm)?, args.eval(vm)?.spanned(span))
         };
 
-        let func_result = callee.clone().cast::<Func>();
-        if in_math && func_result.is_err() {
-            return wrap_args_in_math(callee, callee_span, args, trailing_comma);
+        let func_result = callee_value.clone().cast::<Func>();
+
+        if func_result.is_err() && in_math(callee) {
+            return wrap_args_in_math(
+                callee_value,
+                callee_span,
+                args_value,
+                args.trailing_comma(),
+            );
         }
 
         let func = func_result
@@ -56,8 +65,11 @@ impl Eval for ast::FuncCall<'_> {
 
         let point = || Tracepoint::Call(func.name().map(Into::into));
         let f = || {
-            func.call(&mut vm.engine, vm.context, args)
-                .trace(vm.world(), point, span)
+            func.call(&mut vm.engine, vm.context, args_value).trace(
+                vm.world(),
+                point,
+                span,
+            )
         };
 
         // Stacker is broken on WASM.
@@ -404,12 +416,14 @@ fn wrap_args_in_math(
     if trailing_comma {
         body += SymbolElem::packed(',');
     }
-    Ok(Value::Content(
-        callee.display().spanned(callee_span)
-            + LrElem::new(SymbolElem::packed('(') + body + SymbolElem::packed(')'))
-                .pack()
-                .spanned(args.span),
-    ))
+
+    let formatted = callee.display().spanned(callee_span)
+        + LrElem::new(SymbolElem::packed('(') + body + SymbolElem::packed(')'))
+            .pack()
+            .spanned(args.span);
+
+    args.finish()?;
+    Ok(Value::Content(formatted))
 }
 
 /// Provide a hint if the callee is a shadowed standard library function.
diff --git a/crates/typst-eval/src/lib.rs b/crates/typst-eval/src/lib.rs
index 5eae7c1df..586da26be 100644
--- a/crates/typst-eval/src/lib.rs
+++ b/crates/typst-eval/src/lib.rs
@@ -101,6 +101,7 @@ pub fn eval(
 pub fn eval_string(
     routines: &Routines,
     world: Tracked<dyn World + '_>,
+    sink: TrackedMut<Sink>,
     string: &str,
     span: Span,
     mode: EvalMode,
@@ -121,7 +122,6 @@ pub fn eval_string(
     }
 
     // Prepare the engine.
-    let mut sink = Sink::new();
     let introspector = Introspector::default();
     let traced = Traced::default();
     let engine = Engine {
@@ -129,7 +129,7 @@ pub fn eval_string(
         world,
         introspector: introspector.track(),
         traced: traced.track(),
-        sink: sink.track_mut(),
+        sink,
         route: Route::default(),
     };
 
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index aa769976e..7d78a5da4 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -263,13 +263,13 @@ fn handle(
 /// Wrap the nodes in `<html>` and `<body>` if they are not yet rooted,
 /// supplying a suitable `<head>`.
 fn root_element(output: Vec<HtmlNode>, info: &DocumentInfo) -> SourceResult<HtmlElement> {
+    let head = head_element(info);
     let body = match classify_output(output)? {
         OutputKind::Html(element) => return Ok(element),
         OutputKind::Body(body) => body,
         OutputKind::Leafs(leafs) => HtmlElement::new(tag::body).with_children(leafs),
     };
-    Ok(HtmlElement::new(tag::html)
-        .with_children(vec![head_element(info).into(), body.into()]))
+    Ok(HtmlElement::new(tag::html).with_children(vec![head.into(), body.into()]))
 }
 
 /// Generate a `<head>` element.
@@ -302,6 +302,24 @@ fn head_element(info: &DocumentInfo) -> HtmlElement {
         );
     }
 
+    if !info.author.is_empty() {
+        children.push(
+            HtmlElement::new(tag::meta)
+                .with_attr(attr::name, "authors")
+                .with_attr(attr::content, info.author.join(", "))
+                .into(),
+        )
+    }
+
+    if !info.keywords.is_empty() {
+        children.push(
+            HtmlElement::new(tag::meta)
+                .with_attr(attr::name, "keywords")
+                .with_attr(attr::content, info.keywords.join(", "))
+                .into(),
+        )
+    }
+
     HtmlElement::new(tag::head).with_children(children)
 }
 
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 91fa53f9a..c98320679 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -15,7 +15,7 @@ use typst::syntax::{
     ast, is_id_continue, is_id_start, is_ident, FileId, LinkedNode, Side, Source,
     SyntaxKind,
 };
-use typst::text::RawElem;
+use typst::text::{FontFlags, RawElem};
 use typst::visualize::Color;
 use unscanny::Scanner;
 
@@ -298,13 +298,20 @@ fn complete_math(ctx: &mut CompletionContext) -> bool {
         return false;
     }
 
-    // Start of an interpolated identifier: "#|".
+    // Start of an interpolated identifier: "$#|$".
     if ctx.leaf.kind() == SyntaxKind::Hash {
         ctx.from = ctx.cursor;
         code_completions(ctx, true);
         return true;
     }
 
+    // Behind existing interpolated identifier: "$#pa|$".
+    if ctx.leaf.kind() == SyntaxKind::Ident {
+        ctx.from = ctx.leaf.offset();
+        code_completions(ctx, true);
+        return true;
+    }
+
     // Behind existing atom or identifier: "$a|$" or "$abc|$".
     if matches!(
         ctx.leaf.kind(),
@@ -841,7 +848,9 @@ fn param_value_completions<'a>(
 /// Returns which file extensions to complete for the given parameter if any.
 fn path_completion(func: &Func, param: &ParamInfo) -> Option<&'static [&'static str]> {
     Some(match (func.name(), param.name) {
-        (Some("image"), "source") => &["png", "jpg", "jpeg", "gif", "svg", "svgz"],
+        (Some("image"), "source") => {
+            &["png", "jpg", "jpeg", "gif", "svg", "svgz", "webp"]
+        }
         (Some("csv"), "source") => &["csv"],
         (Some("plugin"), "source") => &["wasm"],
         (Some("cbor"), "source") => &["cbor"],
@@ -1081,6 +1090,24 @@ fn code_completions(ctx: &mut CompletionContext, hash: bool) {
     }
 }
 
+/// See if the AST node is somewhere within a show rule applying to equations
+fn is_in_equation_show_rule(leaf: &LinkedNode<'_>) -> bool {
+    let mut node = leaf;
+    while let Some(parent) = node.parent() {
+        if_chain! {
+            if let Some(expr) = parent.get().cast::<ast::Expr>();
+            if let ast::Expr::ShowRule(show) = expr;
+            if let Some(ast::Expr::FieldAccess(field)) = show.selector();
+            if field.field().as_str() == "equation";
+            then {
+                return true;
+            }
+        }
+        node = parent;
+    }
+    false
+}
+
 /// Context for autocompletion.
 struct CompletionContext<'a> {
     world: &'a (dyn IdeWorld + 'a),
@@ -1152,10 +1179,12 @@ impl<'a> CompletionContext<'a> {
 
     /// Add completions for all font families.
     fn font_completions(&mut self) {
-        let equation = self.before_window(25).contains("equation");
+        let equation = is_in_equation_show_rule(self.leaf);
         for (family, iter) in self.world.book().families() {
-            let detail = summarize_font_family(iter);
-            if !equation || family.contains("Math") {
+            let variants: Vec<_> = iter.collect();
+            let is_math = variants.iter().any(|f| f.flags.contains(FontFlags::MATH));
+            let detail = summarize_font_family(variants);
+            if !equation || is_math {
                 self.str_completion(
                     family,
                     Some(CompletionKind::Font),
@@ -1644,6 +1673,13 @@ mod tests {
         test("#{() .a}", -2).must_include(["at", "any", "all"]);
     }
 
+    /// Test that autocomplete in math uses the correct global scope.
+    #[test]
+    fn test_autocomplete_math_scope() {
+        test("$#col$", -2).must_include(["colbreak"]).must_exclude(["colon"]);
+        test("$col$", -2).must_include(["colon"]).must_exclude(["colbreak"]);
+    }
+
     /// Test that the `before_window` doesn't slice into invalid byte
     /// boundaries.
     #[test]
@@ -1662,7 +1698,7 @@ mod tests {
 
         // Then, add the invalid `#cite` call. Had the document been invalid
         // initially, we would have no populated document to autocomplete with.
-        let end = world.main.len_bytes();
+        let end = world.main.text().len();
         world.main.edit(end..end, " #cite()");
 
         test_with_doc(&world, -2, doc.as_ref())
@@ -1790,4 +1826,21 @@ mod tests {
             .must_include(["r", "dashed"])
             .must_exclude(["cases"]);
     }
+
+    #[test]
+    fn test_autocomplete_fonts() {
+        test("#text(font:)", -1)
+            .must_include(["\"Libertinus Serif\"", "\"New Computer Modern Math\""]);
+
+        test("#show link: set text(font: )", -1)
+            .must_include(["\"Libertinus Serif\"", "\"New Computer Modern Math\""]);
+
+        test("#show math.equation: set text(font: )", -1)
+            .must_include(["\"New Computer Modern Math\""])
+            .must_exclude(["\"Libertinus Serif\""]);
+
+        test("#show math.equation: it => { set text(font: )\nit }", -6)
+            .must_include(["\"New Computer Modern Math\""])
+            .must_exclude(["\"Libertinus Serif\""]);
+    }
 }
diff --git a/crates/typst-ide/src/jump.rs b/crates/typst-ide/src/jump.rs
index 428335426..b29bc4a48 100644
--- a/crates/typst-ide/src/jump.rs
+++ b/crates/typst-ide/src/jump.rs
@@ -3,7 +3,7 @@ use std::num::NonZeroUsize;
 use typst::layout::{Frame, FrameItem, PagedDocument, Point, Position, Size};
 use typst::model::{Destination, Url};
 use typst::syntax::{FileId, LinkedNode, Side, Source, Span, SyntaxKind};
-use typst::visualize::Geometry;
+use typst::visualize::{Curve, CurveItem, FillRule, Geometry};
 use typst::WorldExt;
 
 use crate::IdeWorld;
@@ -53,10 +53,20 @@ pub fn jump_from_click(
     for (mut pos, item) in frame.items().rev() {
         match item {
             FrameItem::Group(group) => {
-                // TODO: Handle transformation.
-                if let Some(span) =
-                    jump_from_click(world, document, &group.frame, click - pos)
-                {
+                let pos = click - pos;
+                if let Some(clip) = &group.clip {
+                    if !clip.contains(FillRule::NonZero, pos) {
+                        continue;
+                    }
+                }
+                // Realistic transforms should always be invertible.
+                // An example of one that isn't is a scale of 0, which would
+                // not be clickable anyway.
+                let Some(inv_transform) = group.transform.invert() else {
+                    continue;
+                };
+                let pos = pos.transform_inf(inv_transform);
+                if let Some(span) = jump_from_click(world, document, &group.frame, pos) {
                     return Some(span);
                 }
             }
@@ -94,9 +104,32 @@ pub fn jump_from_click(
             }
 
             FrameItem::Shape(shape, span) => {
-                let Geometry::Rect(size) = shape.geometry else { continue };
-                if is_in_rect(pos, size, click) {
-                    return Jump::from_span(world, *span);
+                if shape.fill.is_some() {
+                    let within = match &shape.geometry {
+                        Geometry::Line(..) => false,
+                        Geometry::Rect(size) => is_in_rect(pos, *size, click),
+                        Geometry::Curve(curve) => {
+                            curve.contains(shape.fill_rule, click - pos)
+                        }
+                    };
+                    if within {
+                        return Jump::from_span(world, *span);
+                    }
+                }
+
+                if let Some(stroke) = &shape.stroke {
+                    let within = !stroke.thickness.approx_empty() && {
+                        // This curve is rooted at (0, 0), not `pos`.
+                        let base_curve = match &shape.geometry {
+                            Geometry::Line(to) => &Curve(vec![CurveItem::Line(*to)]),
+                            Geometry::Rect(size) => &Curve::rect(*size),
+                            Geometry::Curve(curve) => curve,
+                        };
+                        base_curve.stroke_contains(stroke, click - pos)
+                    };
+                    if within {
+                        return Jump::from_span(world, *span);
+                    }
                 }
             }
 
@@ -146,9 +179,8 @@ pub fn jump_from_cursor(
 fn find_in_frame(frame: &Frame, span: Span) -> Option<Point> {
     for (mut pos, item) in frame.items() {
         if let FrameItem::Group(group) = item {
-            // TODO: Handle transformation.
             if let Some(point) = find_in_frame(&group.frame, span) {
-                return Some(point + pos);
+                return Some(pos + point.transform(group.transform));
             }
         }
 
@@ -269,6 +301,97 @@ mod tests {
         test_click("$a + b$", point(28.0, 14.0), cursor(5));
     }
 
+    #[test]
+    fn test_jump_from_click_transform_clip() {
+        let margin = point(10.0, 10.0);
+        test_click(
+            "#rect(width: 20pt, height: 20pt, fill: black)",
+            point(10.0, 10.0) + margin,
+            cursor(1),
+        );
+        test_click(
+            "#rect(width: 60pt, height: 10pt, fill: black)",
+            point(5.0, 30.0) + margin,
+            None,
+        );
+        test_click(
+            "#rotate(90deg, origin: bottom + left, rect(width: 60pt, height: 10pt, fill: black))",
+            point(5.0, 30.0) + margin,
+            cursor(38),
+        );
+        test_click(
+            "#scale(x: 300%, y: 300%, origin: top + left, rect(width: 10pt, height: 10pt, fill: black))",
+            point(20.0, 20.0) + margin,
+            cursor(45),
+        );
+        test_click(
+            "#box(width: 10pt, height: 10pt, clip: true, scale(x: 300%, y: 300%, \
+             origin: top + left, rect(width: 10pt, height: 10pt, fill: black)))",
+            point(20.0, 20.0) + margin,
+            None,
+        );
+        test_click(
+            "#box(width: 10pt, height: 10pt, clip: false, rect(width: 30pt, height: 30pt, fill: black))",
+            point(20.0, 20.0) + margin,
+            cursor(45),
+        );
+        test_click(
+            "#box(width: 10pt, height: 10pt, clip: true, rect(width: 30pt, height: 30pt, fill: black))",
+            point(20.0, 20.0) + margin,
+            None,
+        );
+        test_click(
+            "#rotate(90deg, origin: bottom + left)[hello world]",
+            point(5.0, 15.0) + margin,
+            cursor(40),
+        );
+    }
+
+    #[test]
+    fn test_jump_from_click_shapes() {
+        let margin = point(10.0, 10.0);
+
+        test_click(
+            "#rect(width: 30pt, height: 30pt, fill: black)",
+            point(15.0, 15.0) + margin,
+            cursor(1),
+        );
+
+        let circle = "#circle(width: 30pt, height: 30pt, fill: black)";
+        test_click(circle, point(15.0, 15.0) + margin, cursor(1));
+        test_click(circle, point(1.0, 1.0) + margin, None);
+
+        let bowtie =
+            "#polygon(fill: black, (0pt, 0pt), (20pt, 20pt), (20pt, 0pt), (0pt, 20pt))";
+        test_click(bowtie, point(1.0, 2.0) + margin, cursor(1));
+        test_click(bowtie, point(2.0, 1.0) + margin, None);
+        test_click(bowtie, point(19.0, 10.0) + margin, cursor(1));
+
+        let evenodd = r#"#polygon(fill: black, fill-rule: "even-odd",
+            (0pt, 10pt), (30pt, 10pt), (30pt, 20pt), (20pt, 20pt),
+            (20pt, 0pt), (10pt, 0pt), (10pt, 30pt), (20pt, 30pt),
+            (20pt, 20pt), (0pt, 20pt))"#;
+        test_click(evenodd, point(15.0, 15.0) + margin, None);
+        test_click(evenodd, point(5.0, 15.0) + margin, cursor(1));
+        test_click(evenodd, point(15.0, 5.0) + margin, cursor(1));
+    }
+
+    #[test]
+    fn test_jump_from_click_shapes_stroke() {
+        let margin = point(10.0, 10.0);
+
+        let rect =
+            "#place(dx: 10pt, dy: 10pt, rect(width: 10pt, height: 10pt, stroke: 5pt))";
+        test_click(rect, point(15.0, 15.0) + margin, None);
+        test_click(rect, point(10.0, 15.0) + margin, cursor(27));
+
+        test_click(
+            "#line(angle: 45deg, length: 10pt, stroke: 2pt)",
+            point(2.0, 2.0) + margin,
+            cursor(1),
+        );
+    }
+
     #[test]
     fn test_jump_from_cursor() {
         let s = "*Hello* #box[ABC] World";
@@ -281,6 +404,15 @@ mod tests {
         test_cursor("$a + b$", -3, pos(1, 27.51, 16.83));
     }
 
+    #[test]
+    fn test_jump_from_cursor_transform() {
+        test_cursor(
+            r#"#rotate(90deg, origin: bottom + left, [hello world])"#,
+            -5,
+            pos(1, 10.0, 16.58),
+        );
+    }
+
     #[test]
     fn test_backlink() {
         let s = "#footnote[Hi]";
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index 6678ab841..1176e4601 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -97,7 +97,7 @@ impl World for TestWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        Some(self.base.fonts[index].clone())
+        self.base.fonts.get(index).cloned()
     }
 
     fn today(&self, _: Option<i64>) -> Option<Datetime> {
@@ -228,7 +228,7 @@ impl FilePos for (&str, isize) {
 #[track_caller]
 fn cursor(source: &Source, cursor: isize) -> usize {
     if cursor < 0 {
-        source.len_bytes().checked_add_signed(cursor + 1).unwrap()
+        source.text().len().checked_add_signed(cursor + 1).unwrap()
     } else {
         cursor as usize
     }
diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs
index cbfffe530..528f679cf 100644
--- a/crates/typst-ide/src/tooltip.rs
+++ b/crates/typst-ide/src/tooltip.rs
@@ -86,7 +86,7 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
                 *count += 1;
                 continue;
             } else if *count > 1 {
-                write!(pieces.last_mut().unwrap(), " (x{count})").unwrap();
+                write!(pieces.last_mut().unwrap(), " (×{count})").unwrap();
             }
         }
         pieces.push(value.repr());
@@ -95,7 +95,7 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
 
     if let Some((_, count)) = last {
         if count > 1 {
-            write!(pieces.last_mut().unwrap(), " (x{count})").unwrap();
+            write!(pieces.last_mut().unwrap(), " (×{count})").unwrap();
         }
     }
 
@@ -269,7 +269,7 @@ fn font_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
             .find(|&(family, _)| family.to_lowercase().as_str() == lower.as_str());
 
         then {
-            let detail = summarize_font_family(iter);
+            let detail = summarize_font_family(iter.collect());
             return Some(Tooltip::Text(detail));
         }
     };
@@ -371,4 +371,11 @@ mod tests {
         test(&world, -2, Side::Before).must_be_none();
         test(&world, -2, Side::After).must_be_text("This star imports `a`, `b`, and `c`");
     }
+
+    #[test]
+    fn test_tooltip_field_call() {
+        let world = TestWorld::new("#import \"other.typ\"\n#other.f()")
+            .with_source("other.typ", "#let f = (x) => 1");
+        test(&world, -4, Side::After).must_be_code("(..) => ..");
+    }
 }
diff --git a/crates/typst-ide/src/utils.rs b/crates/typst-ide/src/utils.rs
index d5d584e2b..13de402ba 100644
--- a/crates/typst-ide/src/utils.rs
+++ b/crates/typst-ide/src/utils.rs
@@ -77,23 +77,20 @@ pub fn plain_docs_sentence(docs: &str) -> EcoString {
 }
 
 /// Create a short description of a font family.
-pub fn summarize_font_family<'a>(
-    variants: impl Iterator<Item = &'a FontInfo>,
-) -> EcoString {
-    let mut infos: Vec<_> = variants.collect();
-    infos.sort_by_key(|info| info.variant);
+pub fn summarize_font_family(mut variants: Vec<&FontInfo>) -> EcoString {
+    variants.sort_by_key(|info| info.variant);
 
     let mut has_italic = false;
     let mut min_weight = u16::MAX;
     let mut max_weight = 0;
-    for info in &infos {
+    for info in &variants {
         let weight = info.variant.weight.to_number();
         has_italic |= info.variant.style == FontStyle::Italic;
         min_weight = min_weight.min(weight);
         max_weight = min_weight.max(weight);
     }
 
-    let count = infos.len();
+    let count = variants.len();
     let mut detail = eco_format!("{count} variant{}.", if count == 1 { "" } else { "s" });
 
     if min_weight == max_weight {
@@ -117,7 +114,9 @@ pub fn globals<'a>(world: &'a dyn IdeWorld, leaf: &LinkedNode) -> &'a Scope {
             | Some(SyntaxKind::Math)
             | Some(SyntaxKind::MathFrac)
             | Some(SyntaxKind::MathAttach)
-    );
+    ) && leaf
+        .prev_leaf()
+        .is_none_or(|prev| !matches!(prev.kind(), SyntaxKind::Hash));
 
     let library = world.library();
     if in_math {
diff --git a/crates/typst-kit/src/download.rs b/crates/typst-kit/src/download.rs
index 40084e51b..a4d49b4f3 100644
--- a/crates/typst-kit/src/download.rs
+++ b/crates/typst-kit/src/download.rs
@@ -128,8 +128,7 @@ impl Downloader {
         }
 
         // Configure native TLS.
-        let connector =
-            tls.build().map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+        let connector = tls.build().map_err(io::Error::other)?;
         builder = builder.tls_connector(Arc::new(connector));
 
         builder.build().get(url).call()
diff --git a/crates/typst-layout/Cargo.toml b/crates/typst-layout/Cargo.toml
index 438e09e43..cc355a3db 100644
--- a/crates/typst-layout/Cargo.toml
+++ b/crates/typst-layout/Cargo.toml
@@ -30,6 +30,7 @@ icu_provider_adapters = { workspace = true }
 icu_provider_blob = { workspace = true }
 icu_segmenter = { workspace = true }
 kurbo = { workspace = true }
+memchr = { workspace = true }
 rustybuzz = { workspace = true }
 smallvec = { workspace = true }
 ttf-parser = { workspace = true }
diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index dc9e2238d..42fe38dbe 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -3,7 +3,9 @@ use std::fmt::Debug;
 use typst_library::diag::{bail, SourceResult};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Resolve, StyleChain};
-use typst_library::layout::grid::resolve::{Cell, CellGrid, LinePosition, Repeatable};
+use typst_library::layout::grid::resolve::{
+    Cell, CellGrid, Header, LinePosition, Repeatable,
+};
 use typst_library::layout::{
     Abs, Axes, Dir, Fr, Fragment, Frame, FrameItem, Length, Point, Region, Regions, Rel,
     Size, Sizing,
@@ -11,7 +13,7 @@ use typst_library::layout::{
 use typst_library::text::TextElem;
 use typst_library::visualize::Geometry;
 use typst_syntax::Span;
-use typst_utils::{MaybeReverseIter, Numeric};
+use typst_utils::Numeric;
 
 use super::{
     generate_line_segments, hline_stroke_at_column, layout_cell, vline_stroke_at_row,
@@ -30,10 +32,8 @@ pub struct GridLayouter<'a> {
     pub(super) rcols: Vec<Abs>,
     /// The sum of `rcols`.
     pub(super) width: Abs,
-    /// Resolve row sizes, by region.
+    /// Resolved row sizes, by region.
     pub(super) rrows: Vec<Vec<RowPiece>>,
-    /// Rows in the current region.
-    pub(super) lrows: Vec<Row>,
     /// The amount of unbreakable rows remaining to be laid out in the
     /// current unbreakable row group. While this is positive, no region breaks
     /// should occur.
@@ -41,24 +41,155 @@ pub struct GridLayouter<'a> {
     /// Rowspans not yet laid out because not all of their spanned rows were
     /// laid out yet.
     pub(super) rowspans: Vec<Rowspan>,
-    /// The initial size of the current region before we started subtracting.
-    pub(super) initial: Size,
+    /// Grid layout state for the current region.
+    pub(super) current: Current,
     /// Frames for finished regions.
     pub(super) finished: Vec<Frame>,
+    /// The amount and height of header rows on each finished region.
+    pub(super) finished_header_rows: Vec<FinishedHeaderRowInfo>,
     /// Whether this is an RTL grid.
     pub(super) is_rtl: bool,
-    /// The simulated header height.
-    /// This field is reset in `layout_header` and properly updated by
+    /// Currently repeating headers, one per level. Sorted by increasing
+    /// levels.
+    ///
+    /// Note that some levels may be absent, in particular level 0, which does
+    /// not exist (so all levels are >= 1).
+    pub(super) repeating_headers: Vec<&'a Header>,
+    /// Headers, repeating or not, awaiting their first successful layout.
+    /// Sorted by increasing levels.
+    pub(super) pending_headers: &'a [Repeatable<Header>],
+    /// Next headers to be processed.
+    pub(super) upcoming_headers: &'a [Repeatable<Header>],
+    /// State of the row being currently laid out.
+    ///
+    /// This is kept as a field to avoid passing down too many parameters from
+    /// `layout_row` into called functions, which would then have to pass them
+    /// down to `push_row`, which reads these values.
+    pub(super) row_state: RowState,
+    /// The span of the grid element.
+    pub(super) span: Span,
+}
+
+/// Grid layout state for the current region. This should be reset or updated
+/// on each region break.
+pub(super) struct Current {
+    /// The initial size of the current region before we started subtracting.
+    pub(super) initial: Size,
+    /// The height of the region after repeated headers were placed and footers
+    /// prepared. This also includes pending repeating headers from the start,
+    /// even if they were not repeated yet, since they will be repeated in the
+    /// next region anyway (bar orphan prevention).
+    ///
+    /// This is used to quickly tell if any additional space in the region has
+    /// been occupied since then, meaning that additional space will become
+    /// available after a region break (see
+    /// [`GridLayouter::may_progress_with_repeats`]).
+    pub(super) initial_after_repeats: Abs,
+    /// Whether `layouter.regions.may_progress()` was `true` at the top of the
+    /// region.
+    pub(super) could_progress_at_top: bool,
+    /// Rows in the current region.
+    pub(super) lrows: Vec<Row>,
+    /// The amount of repeated header rows at the start of the current region.
+    /// Thus, excludes rows from pending headers (which were placed for the
+    /// first time).
+    ///
+    /// Note that `repeating_headers` and `pending_headers` can change if we
+    /// find a new header inside the region (not at the top), so this field
+    /// is required to access information from the top of the region.
+    ///
+    /// This information is used on finish region to calculate the total height
+    /// of resolved header rows at the top of the region, which is used by
+    /// multi-page rowspans so they can properly skip the header rows at the
+    /// top of each region during layout.
+    pub(super) repeated_header_rows: usize,
+    /// The end bound of the row range of the last repeating header at the
+    /// start of the region.
+    ///
+    /// The last row might have disappeared from layout due to being empty, so
+    /// this is how we can become aware of where the last header ends without
+    /// having to check the vector of rows. Line layout uses this to determine
+    /// when to prioritize the last lines under a header.
+    ///
+    /// A value of zero indicates no repeated headers were placed.
+    pub(super) last_repeated_header_end: usize,
+    /// Stores the length of `lrows` before a sequence of rows equipped with
+    /// orphan prevention was laid out. In this case, if no more rows without
+    /// orphan prevention are laid out after those rows before the region ends,
+    /// the rows will be removed, and there may be an attempt to place them
+    /// again in the new region. Effectively, this is the mechanism used for
+    /// orphan prevention of rows.
+    ///
+    /// At the moment, this is only used by repeated headers (they aren't laid
+    /// out if alone in the region) and by new headers, which are moved to the
+    /// `pending_headers` vector and so will automatically be placed again
+    /// until they fit and are not orphans in at least one region (or exactly
+    /// one, for non-repeated headers).
+    pub(super) lrows_orphan_snapshot: Option<usize>,
+    /// The height of effectively repeating headers, that is, ignoring
+    /// non-repeating pending headers, in the current region.
+    ///
+    /// This is used by multi-page auto rows so they can inform cell layout on
+    /// how much space should be taken by headers if they break across regions.
+    /// In particular, non-repeating headers only occupy the initial region,
+    /// but disappear on new regions, so they can be ignored.
+    ///
+    /// This field is reset on each new region and properly updated by
     /// `layout_auto_row` and `layout_relative_row`, and should not be read
     /// before all header rows are fully laid out. It is usually fine because
     /// header rows themselves are unbreakable, and unbreakable rows do not
     /// need to read this field at all.
-    pub(super) header_height: Abs,
+    ///
+    /// This height is not only computed at the beginning of the region. It is
+    /// updated whenever a new header is found, subtracting the height of
+    /// headers which stopped repeating and adding the height of all new
+    /// headers.
+    pub(super) repeating_header_height: Abs,
+    /// The height for each repeating header that was placed in this region.
+    /// Note that this includes headers not at the top of the region, before
+    /// their first repetition (pending headers), and excludes headers removed
+    /// by virtue of a new, conflicting header being found (short-lived
+    /// headers).
+    ///
+    /// This is used to know how much to update `repeating_header_height` by
+    /// when finding a new header and causing existing repeating headers to
+    /// stop.
+    pub(super) repeating_header_heights: Vec<Abs>,
     /// The simulated footer height for this region.
+    ///
     /// The simulation occurs before any rows are laid out for a region.
     pub(super) footer_height: Abs,
-    /// The span of the grid element.
-    pub(super) span: Span,
+}
+
+/// Data about the row being laid out right now.
+#[derive(Debug, Default)]
+pub(super) struct RowState {
+    /// If this is `Some`, this will be updated by the currently laid out row's
+    /// height if it is auto or relative. This is used for header height
+    /// calculation.
+    pub(super) current_row_height: Option<Abs>,
+    /// This is `true` when laying out non-short lived headers and footers.
+    /// That is, headers and footers which are not immediately followed or
+    /// preceded (respectively) by conflicting headers and footers of same or
+    /// lower level, or the end or start of the table (respectively), which
+    /// would cause them to never repeat, even once.
+    ///
+    /// If this is `false`, the next row to be laid out will remove an active
+    /// orphan snapshot and will flush pending headers, as there is no risk
+    /// that they will be orphans anymore.
+    pub(super) in_active_repeatable: bool,
+}
+
+/// Data about laid out repeated header rows for a specific finished region.
+#[derive(Debug, Default)]
+pub(super) struct FinishedHeaderRowInfo {
+    /// The amount of repeated headers at the top of the region.
+    pub(super) repeated_amount: usize,
+    /// The end bound of the row range of the last repeated header at the top
+    /// of the region.
+    pub(super) last_repeated_header_end: usize,
+    /// The total height of repeated headers at the top of the region.
+    pub(super) repeated_height: Abs,
 }
 
 /// Details about a resulting row piece.
@@ -114,14 +245,27 @@ impl<'a> GridLayouter<'a> {
             rcols: vec![Abs::zero(); grid.cols.len()],
             width: Abs::zero(),
             rrows: vec![],
-            lrows: vec![],
             unbreakable_rows_left: 0,
             rowspans: vec![],
-            initial: regions.size,
             finished: vec![],
+            finished_header_rows: vec![],
             is_rtl: TextElem::dir_in(styles) == Dir::RTL,
-            header_height: Abs::zero(),
-            footer_height: Abs::zero(),
+            repeating_headers: vec![],
+            upcoming_headers: &grid.headers,
+            pending_headers: Default::default(),
+            row_state: RowState::default(),
+            current: Current {
+                initial: regions.size,
+                initial_after_repeats: regions.size.y,
+                could_progress_at_top: regions.may_progress(),
+                lrows: vec![],
+                repeated_header_rows: 0,
+                last_repeated_header_end: 0,
+                lrows_orphan_snapshot: None,
+                repeating_header_height: Abs::zero(),
+                repeating_header_heights: vec![],
+                footer_height: Abs::zero(),
+            },
             span,
         }
     }
@@ -130,38 +274,57 @@ impl<'a> GridLayouter<'a> {
     pub fn layout(mut self, engine: &mut Engine) -> SourceResult<Fragment> {
         self.measure_columns(engine)?;
 
-        if let Some(Repeatable::Repeated(footer)) = &self.grid.footer {
-            // Ensure rows in the first region will be aware of the possible
-            // presence of the footer.
-            self.prepare_footer(footer, engine, 0)?;
-            if matches!(self.grid.header, None | Some(Repeatable::NotRepeated(_))) {
-                // No repeatable header, so we won't subtract it later.
-                self.regions.size.y -= self.footer_height;
+        if let Some(footer) = &self.grid.footer {
+            if footer.repeated {
+                // Ensure rows in the first region will be aware of the
+                // possible presence of the footer.
+                self.prepare_footer(footer, engine, 0)?;
+                self.regions.size.y -= self.current.footer_height;
+                self.current.initial_after_repeats = self.regions.size.y;
             }
         }
 
-        for y in 0..self.grid.rows.len() {
-            if let Some(Repeatable::Repeated(header)) = &self.grid.header {
-                if y < header.end {
-                    if y == 0 {
-                        self.layout_header(header, engine, 0)?;
-                        self.regions.size.y -= self.footer_height;
-                    }
+        let mut y = 0;
+        let mut consecutive_header_count = 0;
+        while y < self.grid.rows.len() {
+            if let Some(next_header) = self.upcoming_headers.get(consecutive_header_count)
+            {
+                if next_header.range.contains(&y) {
+                    self.place_new_headers(&mut consecutive_header_count, engine)?;
+                    y = next_header.range.end;
+
                     // Skip header rows during normal layout.
                     continue;
                 }
             }
 
-            if let Some(Repeatable::Repeated(footer)) = &self.grid.footer {
-                if y >= footer.start {
+            if let Some(footer) = &self.grid.footer {
+                if footer.repeated && y >= footer.start {
                     if y == footer.start {
                         self.layout_footer(footer, engine, self.finished.len())?;
+                        self.flush_orphans();
                     }
+                    y = footer.end;
                     continue;
                 }
             }
 
             self.layout_row(y, engine, 0)?;
+
+            // After the first non-header row is placed, pending headers are no
+            // longer orphans and can repeat, so we move them to repeating
+            // headers.
+            //
+            // Note that this is usually done in `push_row`, since the call to
+            // `layout_row` above might trigger region breaks (for multi-page
+            // auto rows), whereas this needs to be called as soon as any part
+            // of a row is laid out. However, it's possible a row has no
+            // visible output and thus does not push any rows even though it
+            // was successfully laid out, in which case we additionally flush
+            // here just in case.
+            self.flush_orphans();
+
+            y += 1;
         }
 
         self.finish_region(engine, true)?;
@@ -184,12 +347,46 @@ impl<'a> GridLayouter<'a> {
         self.render_fills_strokes()
     }
 
-    /// Layout the given row.
+    /// Layout a row with a certain initial state, returning the final state.
+    #[inline]
+    pub(super) fn layout_row_with_state(
+        &mut self,
+        y: usize,
+        engine: &mut Engine,
+        disambiguator: usize,
+        initial_state: RowState,
+    ) -> SourceResult<RowState> {
+        // Keep a copy of the previous value in the stack, as this function can
+        // call itself recursively (e.g. if a region break is triggered and a
+        // header is placed), so we shouldn't outright overwrite it, but rather
+        // save and later restore the state when back to this call.
+        let previous = std::mem::replace(&mut self.row_state, initial_state);
+
+        // Keep it as a separate function to allow inlining the return below,
+        // as it's usually not needed.
+        self.layout_row_internal(y, engine, disambiguator)?;
+
+        Ok(std::mem::replace(&mut self.row_state, previous))
+    }
+
+    /// Layout the given row with the default row state.
+    #[inline]
     pub(super) fn layout_row(
         &mut self,
         y: usize,
         engine: &mut Engine,
         disambiguator: usize,
+    ) -> SourceResult<()> {
+        self.layout_row_with_state(y, engine, disambiguator, RowState::default())?;
+        Ok(())
+    }
+
+    /// Layout the given row using the current state.
+    pub(super) fn layout_row_internal(
+        &mut self,
+        y: usize,
+        engine: &mut Engine,
+        disambiguator: usize,
     ) -> SourceResult<()> {
         // Skip to next region if current one is full, but only for content
         // rows, not for gutter rows, and only if we aren't laying out an
@@ -206,13 +403,18 @@ impl<'a> GridLayouter<'a> {
         }
 
         // Don't layout gutter rows at the top of a region.
-        if is_content_row || !self.lrows.is_empty() {
+        if is_content_row || !self.current.lrows.is_empty() {
             match self.grid.rows[y] {
                 Sizing::Auto => self.layout_auto_row(engine, disambiguator, y)?,
                 Sizing::Rel(v) => {
                     self.layout_relative_row(engine, disambiguator, v, y)?
                 }
-                Sizing::Fr(v) => self.lrows.push(Row::Fr(v, y, disambiguator)),
+                Sizing::Fr(v) => {
+                    if !self.row_state.in_active_repeatable {
+                        self.flush_orphans();
+                    }
+                    self.current.lrows.push(Row::Fr(v, y, disambiguator))
+                }
             }
         }
 
@@ -225,8 +427,13 @@ impl<'a> GridLayouter<'a> {
     fn render_fills_strokes(mut self) -> SourceResult<Fragment> {
         let mut finished = std::mem::take(&mut self.finished);
         let frame_amount = finished.len();
-        for ((frame_index, frame), rows) in
-            finished.iter_mut().enumerate().zip(&self.rrows)
+        for (((frame_index, frame), rows), finished_header_rows) in
+            finished.iter_mut().enumerate().zip(&self.rrows).zip(
+                self.finished_header_rows
+                    .iter()
+                    .map(Some)
+                    .chain(std::iter::repeat(None)),
+            )
         {
             if self.rcols.is_empty() || rows.is_empty() {
                 continue;
@@ -347,7 +554,8 @@ impl<'a> GridLayouter<'a> {
             let hline_indices = rows
                 .iter()
                 .map(|piece| piece.y)
-                .chain(std::iter::once(self.grid.rows.len()));
+                .chain(std::iter::once(self.grid.rows.len()))
+                .enumerate();
 
             // Converts a row to the corresponding index in the vector of
             // hlines.
@@ -372,7 +580,7 @@ impl<'a> GridLayouter<'a> {
             };
 
             let mut prev_y = None;
-            for (y, dy) in hline_indices.zip(hline_offsets) {
+            for ((i, y), dy) in hline_indices.zip(hline_offsets) {
                 // Position of lines below the row index in the previous iteration.
                 let expected_prev_line_position = prev_y
                     .map(|prev_y| {
@@ -383,47 +591,40 @@ impl<'a> GridLayouter<'a> {
                     })
                     .unwrap_or(LinePosition::Before);
 
-                // FIXME: In the future, directly specify in 'self.rrows' when
-                // we place a repeated header rather than its original rows.
-                // That would let us remove most of those verbose checks, both
-                // in 'lines.rs' and here. Those checks also aren't fully
-                // accurate either, since they will also trigger when some rows
-                // have been removed between the header and what's below it.
-                let is_under_repeated_header = self
-                    .grid
-                    .header
-                    .as_ref()
-                    .and_then(Repeatable::as_repeated)
-                    .zip(prev_y)
-                    .is_some_and(|(header, prev_y)| {
-                        // Note: 'y == header.end' would mean we're right below
-                        // the NON-REPEATED header, so that case should return
-                        // false.
-                        prev_y < header.end && y > header.end
-                    });
+                // Header's lines at the bottom have priority when repeated.
+                // This will store the end bound of the last header if the
+                // current iteration is calculating lines under it.
+                let last_repeated_header_end_above = match finished_header_rows {
+                    Some(info) if prev_y.is_some() && i == info.repeated_amount => {
+                        Some(info.last_repeated_header_end)
+                    }
+                    _ => None,
+                };
 
                 // If some grid rows were omitted between the previous resolved
                 // row and the current one, we ensure lines below the previous
                 // row don't "disappear" and are considered, albeit with less
                 // priority. However, don't do this when we're below a header,
                 // as it must have more priority instead of less, so it is
-                // chained later instead of before. The exception is when the
+                // chained later instead of before (stored in the
+                // 'header_hlines' variable below). The exception is when the
                 // last row in the header is removed, in which case we append
                 // both the lines under the row above us and also (later) the
                 // lines under the header's (removed) last row.
-                let prev_lines = prev_y
-                    .filter(|prev_y| {
-                        prev_y + 1 != y
-                            && (!is_under_repeated_header
-                                || self
-                                    .grid
-                                    .header
-                                    .as_ref()
-                                    .and_then(Repeatable::as_repeated)
-                                    .is_some_and(|header| prev_y + 1 != header.end))
-                    })
-                    .map(|prev_y| get_hlines_at(prev_y + 1))
-                    .unwrap_or(&[]);
+                let prev_lines = match prev_y {
+                    Some(prev_y)
+                        if prev_y + 1 != y
+                            && last_repeated_header_end_above.is_none_or(
+                                |last_repeated_header_end| {
+                                    prev_y + 1 != last_repeated_header_end
+                                },
+                            ) =>
+                    {
+                        get_hlines_at(prev_y + 1)
+                    }
+
+                    _ => &[],
+                };
 
                 let expected_hline_position =
                     expected_line_position(y, y == self.grid.rows.len());
@@ -441,15 +642,13 @@ impl<'a> GridLayouter<'a> {
                 };
 
                 let mut expected_header_line_position = LinePosition::Before;
-                let header_hlines = if let Some((Repeatable::Repeated(header), prev_y)) =
-                    self.grid.header.as_ref().zip(prev_y)
-                {
-                    if is_under_repeated_header
-                        && (!self.grid.has_gutter
+                let header_hlines = match (last_repeated_header_end_above, prev_y) {
+                    (Some(header_end_above), Some(prev_y))
+                        if !self.grid.has_gutter
                             || matches!(
                                 self.grid.rows[prev_y],
                                 Sizing::Rel(length) if length.is_zero()
-                            ))
+                            ) =>
                     {
                         // For lines below a header, give priority to the
                         // lines originally below the header rather than
@@ -468,15 +667,13 @@ impl<'a> GridLayouter<'a> {
                         // column-gutter is specified, for example. In that
                         // case, we still repeat the line under the gutter.
                         expected_header_line_position = expected_line_position(
-                            header.end,
-                            header.end == self.grid.rows.len(),
+                            header_end_above,
+                            header_end_above == self.grid.rows.len(),
                         );
-                        get_hlines_at(header.end)
-                    } else {
-                        &[]
+                        get_hlines_at(header_end_above)
                     }
-                } else {
-                    &[]
+
+                    _ => &[],
                 };
 
                 // The effective hlines to be considered at this row index are
@@ -529,6 +726,7 @@ impl<'a> GridLayouter<'a> {
                             grid,
                             rows,
                             local_top_y,
+                            last_repeated_header_end_above,
                             in_last_region,
                             y,
                             x,
@@ -574,7 +772,7 @@ impl<'a> GridLayouter<'a> {
 
             // Reverse with RTL so that later columns start first.
             let mut dx = Abs::zero();
-            for (x, &col) in self.rcols.iter().enumerate().rev_if(self.is_rtl) {
+            for (x, &col) in self.rcols.iter().enumerate() {
                 let mut dy = Abs::zero();
                 for row in rows {
                     // We want to only draw the fill starting at the parent
@@ -643,18 +841,13 @@ impl<'a> GridLayouter<'a> {
                                     .sum()
                             };
                             let width = self.cell_spanned_width(cell, x);
-                            // In the grid, cell colspans expand to the right,
-                            // so we're at the leftmost (lowest 'x') column
-                            // spanned by the cell. However, in RTL, cells
-                            // expand to the left. Therefore, without the
-                            // offset below, cell fills would start at the
-                            // rightmost visual position of a cell and extend
-                            // over to unrelated columns to the right in RTL.
-                            // We avoid this by ensuring the fill starts at the
-                            // very left of the cell, even with colspan > 1.
-                            let offset =
-                                if self.is_rtl { -width + col } else { Abs::zero() };
-                            let pos = Point::new(dx + offset, dy);
+                            let mut pos = Point::new(dx, dy);
+                            if self.is_rtl {
+                                // In RTL cells expand to the left, thus the
+                                // position must additionally be offset by the
+                                // cell's width.
+                                pos.x = self.width - (dx + width);
+                            }
                             let size = Size::new(width, height);
                             let rect = Geometry::Rect(size).filled(fill);
                             fills.push((pos, FrameItem::Shape(rect, self.span)));
@@ -946,15 +1139,9 @@ impl<'a> GridLayouter<'a> {
             let frame = self.layout_single_row(engine, disambiguator, first, y)?;
             self.push_row(frame, y, true);
 
-            if self
-                .grid
-                .header
-                .as_ref()
-                .and_then(Repeatable::as_repeated)
-                .is_some_and(|header| y < header.end)
-            {
-                // Add to header height.
-                self.header_height += first;
+            if let Some(row_height) = &mut self.row_state.current_row_height {
+                // Add to header height, as we are in a header row.
+                *row_height += first;
             }
 
             return Ok(());
@@ -963,19 +1150,21 @@ impl<'a> GridLayouter<'a> {
         // Expand all but the last region.
         // Skip the first region if the space is eaten up by an fr row.
         let len = resolved.len();
-        for ((i, region), target) in self
-            .regions
-            .iter()
-            .enumerate()
-            .zip(&mut resolved[..len - 1])
-            .skip(self.lrows.iter().any(|row| matches!(row, Row::Fr(..))) as usize)
+        for ((i, region), target) in
+            self.regions
+                .iter()
+                .enumerate()
+                .zip(&mut resolved[..len - 1])
+                .skip(self.current.lrows.iter().any(|row| matches!(row, Row::Fr(..)))
+                    as usize)
         {
             // Subtract header and footer heights from the region height when
-            // it's not the first.
+            // it's not the first. Ignore non-repeating headers as they only
+            // appear on the first region by definition.
             target.set_max(
                 region.y
                     - if i > 0 {
-                        self.header_height + self.footer_height
+                        self.current.repeating_header_height + self.current.footer_height
                     } else {
                         Abs::zero()
                     },
@@ -1186,25 +1375,19 @@ impl<'a> GridLayouter<'a> {
         let resolved = v.resolve(self.styles).relative_to(self.regions.base().y);
         let frame = self.layout_single_row(engine, disambiguator, resolved, y)?;
 
-        if self
-            .grid
-            .header
-            .as_ref()
-            .and_then(Repeatable::as_repeated)
-            .is_some_and(|header| y < header.end)
-        {
-            // Add to header height.
-            self.header_height += resolved;
+        if let Some(row_height) = &mut self.row_state.current_row_height {
+            // Add to header height, as we are in a header row.
+            *row_height += resolved;
         }
 
         // Skip to fitting region, but only if we aren't part of an unbreakable
-        // row group. We use 'in_last_with_offset' so our 'in_last' call
-        // properly considers that a header and a footer would be added on each
-        // region break.
+        // row group. We use 'may_progress_with_repeats' to stop trying if we
+        // would skip to a region with the same height and where the same
+        // headers would be repeated.
         let height = frame.height();
         while self.unbreakable_rows_left == 0
             && !self.regions.size.y.fits(height)
-            && !in_last_with_offset(self.regions, self.header_height + self.footer_height)
+            && self.may_progress_with_repeats()
         {
             self.finish_region(engine, false)?;
 
@@ -1236,10 +1419,9 @@ impl<'a> GridLayouter<'a> {
         }
 
         let mut output = Frame::soft(Size::new(self.width, height));
-        let mut pos = Point::zero();
+        let mut offset = Point::zero();
 
-        // Reverse the column order when using RTL.
-        for (x, &rcol) in self.rcols.iter().enumerate().rev_if(self.is_rtl) {
+        for (x, &rcol) in self.rcols.iter().enumerate() {
             if let Some(cell) = self.grid.cell(x, y) {
                 // Rowspans have a separate layout step
                 if cell.rowspan.get() == 1 {
@@ -1257,25 +1439,17 @@ impl<'a> GridLayouter<'a> {
                     let frame =
                         layout_cell(cell, engine, disambiguator, self.styles, pod)?
                             .into_frame();
-                    let mut pos = pos;
+                    let mut pos = offset;
                     if self.is_rtl {
-                        // In the grid, cell colspans expand to the right,
-                        // so we're at the leftmost (lowest 'x') column
-                        // spanned by the cell. However, in RTL, cells
-                        // expand to the left. Therefore, without the
-                        // offset below, the cell's contents would be laid out
-                        // starting at its rightmost visual position and extend
-                        // over to unrelated cells to its right in RTL.
-                        // We avoid this by ensuring the rendered cell starts at
-                        // the very left of the cell, even with colspan > 1.
-                        let offset = -width + rcol;
-                        pos.x += offset;
+                        // In RTL cells expand to the left, thus the position
+                        // must additionally be offset by the cell's width.
+                        pos.x = self.width - (pos.x + width);
                     }
                     output.push_frame(pos, frame);
                 }
             }
 
-            pos.x += rcol;
+            offset.x += rcol;
         }
 
         Ok(output)
@@ -1302,8 +1476,8 @@ impl<'a> GridLayouter<'a> {
         pod.backlog = &heights[1..];
 
         // Layout the row.
-        let mut pos = Point::zero();
-        for (x, &rcol) in self.rcols.iter().enumerate().rev_if(self.is_rtl) {
+        let mut offset = Point::zero();
+        for (x, &rcol) in self.rcols.iter().enumerate() {
             if let Some(cell) = self.grid.cell(x, y) {
                 // Rowspans have a separate layout step
                 if cell.rowspan.get() == 1 {
@@ -1314,17 +1488,19 @@ impl<'a> GridLayouter<'a> {
                     let fragment =
                         layout_cell(cell, engine, disambiguator, self.styles, pod)?;
                     for (output, frame) in outputs.iter_mut().zip(fragment) {
-                        let mut pos = pos;
+                        let mut pos = offset;
                         if self.is_rtl {
-                            let offset = -width + rcol;
-                            pos.x += offset;
+                            // In RTL cells expand to the left, thus the
+                            // position must additionally be offset by the
+                            // cell's width.
+                            pos.x = self.width - (offset.x + width);
                         }
                         output.push_frame(pos, frame);
                     }
                 }
             }
 
-            pos.x += rcol;
+            offset.x += rcol;
         }
 
         Ok(Fragment::frames(outputs))
@@ -1335,8 +1511,13 @@ impl<'a> GridLayouter<'a> {
     /// will be pushed for this particular row. It can be `false` for rows
     /// spanning multiple regions.
     fn push_row(&mut self, frame: Frame, y: usize, is_last: bool) {
+        if !self.row_state.in_active_repeatable {
+            // There is now a row after the rows equipped with orphan
+            // prevention, so no need to keep moving them anymore.
+            self.flush_orphans();
+        }
         self.regions.size.y -= frame.height();
-        self.lrows.push(Row::Frame(frame, y, is_last));
+        self.current.lrows.push(Row::Frame(frame, y, is_last));
     }
 
     /// Finish rows for one region.
@@ -1345,68 +1526,73 @@ impl<'a> GridLayouter<'a> {
         engine: &mut Engine,
         last: bool,
     ) -> SourceResult<()> {
+        // The latest rows have orphan prevention (headers) and no other rows
+        // were placed, so remove those rows and try again in a new region,
+        // unless this is the last region.
+        if let Some(orphan_snapshot) = self.current.lrows_orphan_snapshot.take() {
+            if !last {
+                self.current.lrows.truncate(orphan_snapshot);
+                self.current.repeated_header_rows =
+                    self.current.repeated_header_rows.min(orphan_snapshot);
+
+                if orphan_snapshot == 0 {
+                    // Removed all repeated headers.
+                    self.current.last_repeated_header_end = 0;
+                }
+            }
+        }
+
         if self
+            .current
             .lrows
             .last()
             .is_some_and(|row| self.grid.is_gutter_track(row.index()))
         {
             // Remove the last row in the region if it is a gutter row.
-            self.lrows.pop().unwrap();
+            self.current.lrows.pop().unwrap();
+            self.current.repeated_header_rows =
+                self.current.repeated_header_rows.min(self.current.lrows.len());
         }
 
-        // If no rows other than the footer have been laid out so far, and
-        // there are rows beside the footer, then don't lay it out at all.
-        // This check doesn't apply, and is thus overridden, when there is a
-        // header.
-        let mut footer_would_be_orphan = self.lrows.is_empty()
-            && !in_last_with_offset(
-                self.regions,
-                self.header_height + self.footer_height,
-            )
-            && self
-                .grid
-                .footer
-                .as_ref()
-                .and_then(Repeatable::as_repeated)
-                .is_some_and(|footer| footer.start != 0);
-
-        if let Some(Repeatable::Repeated(header)) = &self.grid.header {
-            if self.grid.rows.len() > header.end
-                && self
-                    .grid
-                    .footer
-                    .as_ref()
-                    .and_then(Repeatable::as_repeated)
-                    .is_none_or(|footer| footer.start != header.end)
-                && self.lrows.last().is_some_and(|row| row.index() < header.end)
-                && !in_last_with_offset(
-                    self.regions,
-                    self.header_height + self.footer_height,
-                )
-            {
-                // Header and footer would be alone in this region, but there are more
-                // rows beyond the header and the footer. Push an empty region.
-                self.lrows.clear();
-                footer_would_be_orphan = true;
-            }
-        }
+        // If no rows other than the footer have been laid out so far
+        // (e.g. due to header orphan prevention), and there are rows
+        // beside the footer, then don't lay it out at all.
+        //
+        // It is worth noting that the footer is made non-repeatable at
+        // the grid resolving stage if it is short-lived, that is, if
+        // it is at the start of the table (or right after headers at
+        // the start of the table).
+        //
+        // TODO(subfooters): explicitly check for short-lived footers.
+        // TODO(subfooters): widow prevention for non-repeated footers with a
+        // similar mechanism / when implementing multiple footers.
+        let footer_would_be_widow = matches!(&self.grid.footer, Some(footer) if footer.repeated)
+            && self.current.lrows.is_empty()
+            && self.current.could_progress_at_top;
 
         let mut laid_out_footer_start = None;
-        if let Some(Repeatable::Repeated(footer)) = &self.grid.footer {
-            // Don't layout the footer if it would be alone with the header in
-            // the page, and don't layout it twice.
-            if !footer_would_be_orphan
-                && self.lrows.iter().all(|row| row.index() < footer.start)
-            {
-                laid_out_footer_start = Some(footer.start);
-                self.layout_footer(footer, engine, self.finished.len())?;
+        if !footer_would_be_widow {
+            if let Some(footer) = &self.grid.footer {
+                // Don't layout the footer if it would be alone with the header
+                // in the page (hence the widow check), and don't layout it
+                // twice (check below).
+                //
+                // TODO(subfooters): this check can be replaced by a vector of
+                // repeating footers in the future, and/or some "pending
+                // footers" vector for footers we're about to place.
+                if footer.repeated
+                    && self.current.lrows.iter().all(|row| row.index() < footer.start)
+                {
+                    laid_out_footer_start = Some(footer.start);
+                    self.layout_footer(footer, engine, self.finished.len())?;
+                }
             }
         }
 
         // Determine the height of existing rows in the region.
         let mut used = Abs::zero();
         let mut fr = Fr::zero();
-        for row in &self.lrows {
+        for row in &self.current.lrows {
             match row {
                 Row::Frame(frame, _, _) => used += frame.height(),
                 Row::Fr(v, _, _) => fr += *v,
@@ -1415,9 +1601,9 @@ impl<'a> GridLayouter<'a> {
 
         // Determine the size of the grid in this region, expanding fully if
         // there are fr rows.
-        let mut size = Size::new(self.width, used).min(self.initial);
-        if fr.get() > 0.0 && self.initial.y.is_finite() {
-            size.y = self.initial.y;
+        let mut size = Size::new(self.width, used).min(self.current.initial);
+        if fr.get() > 0.0 && self.current.initial.y.is_finite() {
+            size.y = self.current.initial.y;
         }
 
         // The frame for the region.
@@ -1425,9 +1611,10 @@ impl<'a> GridLayouter<'a> {
         let mut pos = Point::zero();
         let mut rrows = vec![];
         let current_region = self.finished.len();
+        let mut repeated_header_row_height = Abs::zero();
 
         // Place finished rows and layout fractional rows.
-        for row in std::mem::take(&mut self.lrows) {
+        for (i, row) in std::mem::take(&mut self.current.lrows).into_iter().enumerate() {
             let (frame, y, is_last) = match row {
                 Row::Frame(frame, y, is_last) => (frame, y, is_last),
                 Row::Fr(v, y, disambiguator) => {
@@ -1438,6 +1625,9 @@ impl<'a> GridLayouter<'a> {
             };
 
             let height = frame.height();
+            if i < self.current.repeated_header_rows {
+                repeated_header_row_height += height;
+            }
 
             // Ensure rowspans which span this row will have enough space to
             // be laid out over it later.
@@ -1516,7 +1706,11 @@ impl<'a> GridLayouter<'a> {
                     // we have to check the same index again in the next
                     // iteration.
                     let rowspan = self.rowspans.remove(i);
-                    self.layout_rowspan(rowspan, Some((&mut output, &rrows)), engine)?;
+                    self.layout_rowspan(
+                        rowspan,
+                        Some((&mut output, repeated_header_row_height)),
+                        engine,
+                    )?;
                 } else {
                     i += 1;
                 }
@@ -1527,21 +1721,40 @@ impl<'a> GridLayouter<'a> {
             pos.y += height;
         }
 
-        self.finish_region_internal(output, rrows);
+        self.finish_region_internal(
+            output,
+            rrows,
+            FinishedHeaderRowInfo {
+                repeated_amount: self.current.repeated_header_rows,
+                last_repeated_header_end: self.current.last_repeated_header_end,
+                repeated_height: repeated_header_row_height,
+            },
+        );
 
         if !last {
+            self.current.repeated_header_rows = 0;
+            self.current.last_repeated_header_end = 0;
+            self.current.repeating_header_height = Abs::zero();
+            self.current.repeating_header_heights.clear();
+
             let disambiguator = self.finished.len();
-            if let Some(Repeatable::Repeated(footer)) = &self.grid.footer {
+            if let Some(footer) =
+                self.grid.footer.as_ref().and_then(Repeatable::as_repeated)
+            {
                 self.prepare_footer(footer, engine, disambiguator)?;
             }
 
-            if let Some(Repeatable::Repeated(header)) = &self.grid.header {
-                // Add a header to the new region.
-                self.layout_header(header, engine, disambiguator)?;
-            }
-
             // Ensure rows don't try to overrun the footer.
-            self.regions.size.y -= self.footer_height;
+            // Note that header layout will only subtract this again if it has
+            // to skip regions to fit headers, so there is no risk of
+            // subtracting this twice.
+            self.regions.size.y -= self.current.footer_height;
+            self.current.initial_after_repeats = self.regions.size.y;
+
+            if !self.repeating_headers.is_empty() || !self.pending_headers.is_empty() {
+                // Add headers to the new region.
+                self.layout_active_headers(engine)?;
+            }
         }
 
         Ok(())
@@ -1553,11 +1766,26 @@ impl<'a> GridLayouter<'a> {
         &mut self,
         output: Frame,
         resolved_rows: Vec<RowPiece>,
+        header_row_info: FinishedHeaderRowInfo,
     ) {
         self.finished.push(output);
         self.rrows.push(resolved_rows);
         self.regions.next();
-        self.initial = self.regions.size;
+        self.current.initial = self.regions.size;
+
+        // Repeats haven't been laid out yet, so in the meantime, this will
+        // represent the initial height after repeats laid out so far, and will
+        // be gradually updated when preparing footers and repeating headers.
+        self.current.initial_after_repeats = self.current.initial.y;
+
+        self.current.could_progress_at_top = self.regions.may_progress();
+
+        if !self.grid.headers.is_empty() {
+            self.finished_header_rows.push(header_row_info);
+        }
+
+        // Ensure orphan prevention is handled before resolving rows.
+        debug_assert!(self.current.lrows_orphan_snapshot.is_none());
     }
 }
 
@@ -1572,13 +1800,3 @@ pub(super) fn points(
         offset
     })
 }
-
-/// Checks if the first region of a sequence of regions is the last usable
-/// region, assuming that the last region will always be occupied by some
-/// specific offset height, even after calling `.next()`, due to some
-/// additional logic which adds content automatically on each region turn (in
-/// our case, headers).
-pub(super) fn in_last_with_offset(regions: Regions<'_>, offset: Abs) -> bool {
-    regions.backlog.is_empty()
-        && regions.last.is_none_or(|height| regions.size.y + offset == height)
-}
diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index 7549673f1..d5da7e263 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -391,10 +391,12 @@ pub fn vline_stroke_at_row(
 ///
 /// This function assumes columns are sorted by increasing `x`, and rows are
 /// sorted by increasing `y`.
+#[allow(clippy::too_many_arguments)]
 pub fn hline_stroke_at_column(
     grid: &CellGrid,
     rows: &[RowPiece],
     local_top_y: Option<usize>,
+    header_end_above: Option<usize>,
     in_last_region: bool,
     y: usize,
     x: usize,
@@ -499,17 +501,15 @@ pub fn hline_stroke_at_column(
     // Top border stroke and header stroke are generally prioritized, unless
     // they don't have explicit hline overrides and one or more user-provided
     // hlines would appear at the same position, which then are prioritized.
-    let top_stroke_comes_from_header = grid
-        .header
-        .as_ref()
-        .and_then(Repeatable::as_repeated)
-        .zip(local_top_y)
-        .is_some_and(|(header, local_top_y)| {
-            // Ensure the row above us is a repeated header.
-            // FIXME: Make this check more robust when headers at arbitrary
-            // positions are added.
-            local_top_y < header.end && y > header.end
-        });
+    let top_stroke_comes_from_header = header_end_above.zip(local_top_y).is_some_and(
+        |(last_repeated_header_end, local_top_y)| {
+            // Check if the last repeated header row is above this line.
+            //
+            // Note that `y == last_repeated_header_end` is impossible for a
+            // strictly repeated header (not in its original position).
+            local_top_y < last_repeated_header_end && y > last_repeated_header_end
+        },
+    );
 
     // Prioritize the footer's top stroke as well where applicable.
     let bottom_stroke_comes_from_footer = grid
@@ -637,7 +637,7 @@ mod test {
             },
             vec![],
             vec![],
-            None,
+            vec![],
             None,
             entries,
         )
@@ -1175,7 +1175,7 @@ mod test {
             },
             vec![],
             vec![],
-            None,
+            vec![],
             None,
             entries,
         )
@@ -1268,6 +1268,7 @@ mod test {
                         grid,
                         &rows,
                         y.checked_sub(1),
+                        None,
                         true,
                         y,
                         x,
@@ -1461,6 +1462,7 @@ mod test {
                         grid,
                         &rows,
                         y.checked_sub(1),
+                        None,
                         true,
                         y,
                         x,
@@ -1506,6 +1508,7 @@ mod test {
                     grid,
                     &rows,
                     if y == 4 { Some(2) } else { y.checked_sub(1) },
+                    None,
                     true,
                     y,
                     x,
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 22d2a09ef..8db33df5e 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -1,57 +1,446 @@
+use std::ops::Deref;
+
 use typst_library::diag::SourceResult;
 use typst_library::engine::Engine;
 use typst_library::layout::grid::resolve::{Footer, Header, Repeatable};
 use typst_library::layout::{Abs, Axes, Frame, Regions};
 
-use super::layouter::GridLayouter;
+use super::layouter::{GridLayouter, RowState};
 use super::rowspans::UnbreakableRowGroup;
 
-impl GridLayouter<'_> {
-    /// Layouts the header's rows.
-    /// Skips regions as necessary.
-    pub fn layout_header(
+impl<'a> GridLayouter<'a> {
+    /// Checks whether a region break could help a situation where we're out of
+    /// space for the next row. The criteria are:
+    ///
+    /// 1. If we could progress at the top of the region, that indicates the
+    ///    region has a backlog, or (if we're at the first region) a region break
+    ///    is at all possible (`regions.last` is `Some()`), so that's sufficient.
+    ///
+    /// 2. Otherwise, we may progress if another region break is possible
+    ///    (`regions.last` is still `Some()`) and non-repeating rows have been
+    ///    placed, since that means the space they occupy will be available in the
+    ///    next region.
+    #[inline]
+    pub fn may_progress_with_repeats(&self) -> bool {
+        // TODO(subfooters): check below isn't enough to detect non-repeating
+        // footers... we can also change 'initial_after_repeats' to stop being
+        // calculated if there were any non-repeating footers.
+        self.current.could_progress_at_top
+            || self.regions.last.is_some()
+                && self.regions.size.y != self.current.initial_after_repeats
+    }
+
+    pub fn place_new_headers(
+        &mut self,
+        consecutive_header_count: &mut usize,
+        engine: &mut Engine,
+    ) -> SourceResult<()> {
+        *consecutive_header_count += 1;
+        let (consecutive_headers, new_upcoming_headers) =
+            self.upcoming_headers.split_at(*consecutive_header_count);
+
+        if new_upcoming_headers.first().is_some_and(|next_header| {
+            consecutive_headers.last().is_none_or(|latest_header| {
+                !latest_header.short_lived
+                    && next_header.range.start == latest_header.range.end
+            }) && !next_header.short_lived
+        }) {
+            // More headers coming, so wait until we reach them.
+            return Ok(());
+        }
+
+        self.upcoming_headers = new_upcoming_headers;
+        *consecutive_header_count = 0;
+
+        let [first_header, ..] = consecutive_headers else {
+            self.flush_orphans();
+            return Ok(());
+        };
+
+        // Assuming non-conflicting headers sorted by increasing y, this must
+        // be the header with the lowest level (sorted by increasing levels).
+        let first_level = first_header.level;
+
+        // Stop repeating conflicting headers, even if the new headers are
+        // short-lived or won't repeat.
+        //
+        // If we go to a new region before the new headers fit alongside their
+        // children (or in general, for short-lived), the old headers should
+        // not be displayed anymore.
+        let first_conflicting_pos =
+            self.repeating_headers.partition_point(|h| h.level < first_level);
+        self.repeating_headers.truncate(first_conflicting_pos);
+
+        // Ensure upcoming rows won't see that these headers will occupy any
+        // space in future regions anymore.
+        for removed_height in
+            self.current.repeating_header_heights.drain(first_conflicting_pos..)
+        {
+            self.current.repeating_header_height -= removed_height;
+        }
+
+        // Layout short-lived headers immediately.
+        if consecutive_headers.last().is_some_and(|h| h.short_lived) {
+            // No chance of orphans as we're immediately placing conflicting
+            // headers afterwards, which basically are not headers, for all intents
+            // and purposes. It is therefore guaranteed that all new headers have
+            // been placed at least once.
+            self.flush_orphans();
+
+            // Layout each conflicting header independently, without orphan
+            // prevention (as they don't go into 'pending_headers').
+            // These headers are short-lived as they are immediately followed by a
+            // header of the same or lower level, such that they never actually get
+            // to repeat.
+            self.layout_new_headers(consecutive_headers, true, engine)?;
+        } else {
+            // Let's try to place pending headers at least once.
+            // This might be a waste as we could generate an orphan and thus have
+            // to try to place old and new headers all over again, but that happens
+            // for every new region anyway, so it's rather unavoidable.
+            let snapshot_created =
+                self.layout_new_headers(consecutive_headers, false, engine)?;
+
+            // Queue the new headers for layout. They will remain in this
+            // vector due to orphan prevention.
+            //
+            // After the first subsequent row is laid out, move to repeating, as
+            // it's then confirmed the headers won't be moved due to orphan
+            // prevention anymore.
+            self.pending_headers = consecutive_headers;
+
+            if !snapshot_created {
+                // Region probably couldn't progress.
+                //
+                // Mark new pending headers as final and ensure there isn't a
+                // snapshot.
+                self.flush_orphans();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Lays out rows belonging to a header, returning the calculated header
+    /// height only for that header. Indicates to the laid out rows that they
+    /// should inform their laid out heights if appropriate (auto or fixed
+    /// size rows only).
+    #[inline]
+    fn layout_header_rows(
         &mut self,
         header: &Header,
         engine: &mut Engine,
         disambiguator: usize,
-    ) -> SourceResult<()> {
-        let header_rows =
-            self.simulate_header(header, &self.regions, engine, disambiguator)?;
-        let mut skipped_region = false;
-        while self.unbreakable_rows_left == 0
-            && !self.regions.size.y.fits(header_rows.height + self.footer_height)
-            && self.regions.may_progress()
-        {
-            // Advance regions without any output until we can place the
-            // header and the footer.
-            self.finish_region_internal(Frame::soft(Axes::splat(Abs::zero())), vec![]);
-            skipped_region = true;
+        as_short_lived: bool,
+    ) -> SourceResult<Abs> {
+        let mut header_height = Abs::zero();
+        for y in header.range.clone() {
+            header_height += self
+                .layout_row_with_state(
+                    y,
+                    engine,
+                    disambiguator,
+                    RowState {
+                        current_row_height: Some(Abs::zero()),
+                        in_active_repeatable: !as_short_lived,
+                    },
+                )?
+                .current_row_height
+                .unwrap_or_default();
+        }
+        Ok(header_height)
+    }
+
+    /// This function should be called each time an additional row has been
+    /// laid out in a region to indicate that orphan prevention has succeeded.
+    ///
+    /// It removes the current orphan snapshot and flushes pending headers,
+    /// such that a non-repeating header won't try to be laid out again
+    /// anymore, and a repeating header will begin to be part of
+    /// `repeating_headers`.
+    pub fn flush_orphans(&mut self) {
+        self.current.lrows_orphan_snapshot = None;
+        self.flush_pending_headers();
+    }
+
+    /// Indicates all currently pending headers have been successfully placed
+    /// once, since another row has been placed after them, so they are
+    /// certainly not orphans.
+    pub fn flush_pending_headers(&mut self) {
+        if self.pending_headers.is_empty() {
+            return;
         }
 
-        // Reset the header height for this region.
-        // It will be re-calculated when laying out each header row.
-        self.header_height = Abs::zero();
-
-        if let Some(Repeatable::Repeated(footer)) = &self.grid.footer {
-            if skipped_region {
-                // Simulate the footer again; the region's 'full' might have
-                // changed.
-                self.footer_height = self
-                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                    .height;
+        for header in self.pending_headers {
+            if header.repeated {
+                // Vector remains sorted by increasing levels:
+                // - 'pending_headers' themselves are sorted, since we only
+                // push non-mutually-conflicting headers at a time.
+                // - Before pushing new pending headers in
+                // 'layout_new_pending_headers', we truncate repeating headers
+                // to remove anything with the same or higher levels as the
+                // first pending header.
+                // - Assuming it was sorted before, that truncation only keeps
+                // elements with a lower level.
+                // - Therefore, by pushing this header to the end, it will have
+                // a level larger than all the previous headers, and is thus
+                // in its 'correct' position.
+                self.repeating_headers.push(header);
             }
         }
 
-        // Header is unbreakable.
+        self.pending_headers = Default::default();
+    }
+
+    /// Lays out the rows of repeating and pending headers at the top of the
+    /// region.
+    ///
+    /// Assumes the footer height for the current region has already been
+    /// calculated. Skips regions as necessary to fit all headers and all
+    /// footers.
+    pub fn layout_active_headers(&mut self, engine: &mut Engine) -> SourceResult<()> {
+        // Generate different locations for content in headers across its
+        // repetitions by assigning a unique number for each one.
+        let disambiguator = self.finished.len();
+
+        let header_height = self.simulate_header_height(
+            self.repeating_headers
+                .iter()
+                .copied()
+                .chain(self.pending_headers.iter().map(Repeatable::deref)),
+            &self.regions,
+            engine,
+            disambiguator,
+        )?;
+
+        // We already take the footer into account below.
+        // While skipping regions, footer height won't be automatically
+        // re-calculated until the end.
+        let mut skipped_region = false;
+        while self.unbreakable_rows_left == 0
+            && !self.regions.size.y.fits(header_height)
+            && self.may_progress_with_repeats()
+        {
+            // Advance regions without any output until we can place the
+            // header and the footer.
+            self.finish_region_internal(
+                Frame::soft(Axes::splat(Abs::zero())),
+                vec![],
+                Default::default(),
+            );
+
+            // TODO(layout model): re-calculate heights of headers and footers
+            // on each region if 'full' changes? (Assuming height doesn't
+            // change for now...)
+            //
+            // Would remove the footer height update below (move it here).
+            skipped_region = true;
+
+            self.regions.size.y -= self.current.footer_height;
+            self.current.initial_after_repeats = self.regions.size.y;
+        }
+
+        if let Some(footer) = &self.grid.footer {
+            if footer.repeated && skipped_region {
+                // Simulate the footer again; the region's 'full' might have
+                // changed.
+                self.regions.size.y += self.current.footer_height;
+                self.current.footer_height = self
+                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
+                    .height;
+                self.regions.size.y -= self.current.footer_height;
+            }
+        }
+
+        let repeating_header_rows =
+            total_header_row_count(self.repeating_headers.iter().copied());
+
+        let pending_header_rows =
+            total_header_row_count(self.pending_headers.iter().map(Repeatable::deref));
+
+        // Group of headers is unbreakable.
         // Thus, no risk of 'finish_region' being recursively called from
         // within 'layout_row'.
-        self.unbreakable_rows_left += header.end;
-        for y in 0..header.end {
-            self.layout_row(y, engine, disambiguator)?;
+        self.unbreakable_rows_left += repeating_header_rows + pending_header_rows;
+
+        self.current.last_repeated_header_end =
+            self.repeating_headers.last().map(|h| h.range.end).unwrap_or_default();
+
+        // Reset the header height for this region.
+        // It will be re-calculated when laying out each header row.
+        self.current.repeating_header_height = Abs::zero();
+        self.current.repeating_header_heights.clear();
+
+        debug_assert!(self.current.lrows.is_empty());
+        debug_assert!(self.current.lrows_orphan_snapshot.is_none());
+        let may_progress = self.may_progress_with_repeats();
+
+        if may_progress {
+            // Enable orphan prevention for headers at the top of the region.
+            // Otherwise, we will flush pending headers below, after laying
+            // them out.
+            //
+            // It is very rare for this to make a difference as we're usually
+            // at the 'last' region after the first skip, at which the snapshot
+            // is handled by 'layout_new_headers'. Either way, we keep this
+            // here for correctness.
+            self.current.lrows_orphan_snapshot = Some(self.current.lrows.len());
         }
+
+        // Use indices to avoid double borrow. We don't mutate headers in
+        // 'layout_row' so this is fine.
+        let mut i = 0;
+        while let Some(&header) = self.repeating_headers.get(i) {
+            let header_height =
+                self.layout_header_rows(header, engine, disambiguator, false)?;
+            self.current.repeating_header_height += header_height;
+
+            // We assume that this vector will be sorted according
+            // to increasing levels like 'repeating_headers' and
+            // 'pending_headers' - and, in particular, their union, as this
+            // vector is pushed repeating heights from both.
+            //
+            // This is guaranteed by:
+            // 1. We always push pending headers after repeating headers,
+            // as we assume they don't conflict because we remove
+            // conflicting repeating headers when pushing a new pending
+            // header.
+            //
+            // 2. We push in the same order as each.
+            //
+            // 3. This vector is also modified when pushing a new pending
+            // header, where we remove heights for conflicting repeating
+            // headers which have now stopped repeating. They are always at
+            // the end and new pending headers respect the existing sort,
+            // so the vector will remain sorted.
+            self.current.repeating_header_heights.push(header_height);
+
+            i += 1;
+        }
+
+        self.current.repeated_header_rows = self.current.lrows.len();
+        self.current.initial_after_repeats = self.regions.size.y;
+
+        let mut has_non_repeated_pending_header = false;
+        for header in self.pending_headers {
+            if !header.repeated {
+                self.current.initial_after_repeats = self.regions.size.y;
+                has_non_repeated_pending_header = true;
+            }
+            let header_height =
+                self.layout_header_rows(header, engine, disambiguator, false)?;
+            if header.repeated {
+                self.current.repeating_header_height += header_height;
+                self.current.repeating_header_heights.push(header_height);
+            }
+        }
+
+        if !has_non_repeated_pending_header {
+            self.current.initial_after_repeats = self.regions.size.y;
+        }
+
+        if !may_progress {
+            // Flush pending headers immediately, as placing them again later
+            // won't help.
+            self.flush_orphans();
+        }
+
         Ok(())
     }
 
+    /// Lays out headers found for the first time during row layout.
+    ///
+    /// If 'short_lived' is true, these headers are immediately followed by
+    /// a conflicting header, so it is assumed they will not be pushed to
+    /// pending headers.
+    ///
+    /// Returns whether orphan prevention was successfully setup, or couldn't
+    /// due to short-lived headers or the region couldn't progress.
+    pub fn layout_new_headers(
+        &mut self,
+        headers: &'a [Repeatable<Header>],
+        short_lived: bool,
+        engine: &mut Engine,
+    ) -> SourceResult<bool> {
+        // At first, only consider the height of the given headers. However,
+        // for upcoming regions, we will have to consider repeating headers as
+        // well.
+        let header_height = self.simulate_header_height(
+            headers.iter().map(Repeatable::deref),
+            &self.regions,
+            engine,
+            0,
+        )?;
+
+        while self.unbreakable_rows_left == 0
+            && !self.regions.size.y.fits(header_height)
+            && self.may_progress_with_repeats()
+        {
+            // Note that, after the first region skip, the new headers will go
+            // at the top of the region, but after the repeating headers that
+            // remained (which will be automatically placed in 'finish_region').
+            self.finish_region(engine, false)?;
+        }
+
+        // Remove new headers at the end of the region if the upcoming row
+        // doesn't fit.
+        // TODO(subfooters): what if there is a footer right after it?
+        let should_snapshot = !short_lived
+            && self.current.lrows_orphan_snapshot.is_none()
+            && self.may_progress_with_repeats();
+
+        if should_snapshot {
+            // If we don't enter this branch while laying out non-short lived
+            // headers, that means we will have to immediately flush pending
+            // headers and mark them as final, since trying to place them in
+            // the next page won't help get more space.
+            self.current.lrows_orphan_snapshot = Some(self.current.lrows.len());
+        }
+
+        let mut at_top = self.regions.size.y == self.current.initial_after_repeats;
+
+        self.unbreakable_rows_left +=
+            total_header_row_count(headers.iter().map(Repeatable::deref));
+
+        for header in headers {
+            let header_height = self.layout_header_rows(header, engine, 0, false)?;
+
+            // Only store this header height if it is actually going to
+            // become a pending header. Otherwise, pretend it's not a
+            // header... This is fine for consumers of 'header_height' as
+            // it is guaranteed this header won't appear in a future
+            // region, so multi-page rows and cells can effectively ignore
+            // this header.
+            if !short_lived && header.repeated {
+                self.current.repeating_header_height += header_height;
+                self.current.repeating_header_heights.push(header_height);
+                if at_top {
+                    self.current.initial_after_repeats = self.regions.size.y;
+                }
+            } else {
+                at_top = false;
+            }
+        }
+
+        Ok(should_snapshot)
+    }
+
+    /// Calculates the total expected height of several headers.
+    pub fn simulate_header_height<'h: 'a>(
+        &self,
+        headers: impl IntoIterator<Item = &'h Header>,
+        regions: &Regions<'_>,
+        engine: &mut Engine,
+        disambiguator: usize,
+    ) -> SourceResult<Abs> {
+        let mut height = Abs::zero();
+        for header in headers {
+            height +=
+                self.simulate_header(header, regions, engine, disambiguator)?.height;
+        }
+        Ok(height)
+    }
+
     /// Simulate the header's group of rows.
     pub fn simulate_header(
         &self,
@@ -66,8 +455,8 @@ impl GridLayouter<'_> {
         // assume that the amount of unbreakable rows following the first row
         // in the header will be precisely the rows in the header.
         self.simulate_unbreakable_row_group(
-            0,
-            Some(header.end),
+            header.range.start,
+            Some(header.range.end - header.range.start),
             regions,
             engine,
             disambiguator,
@@ -91,11 +480,22 @@ impl GridLayouter<'_> {
         {
             // Advance regions without any output until we can place the
             // footer.
-            self.finish_region_internal(Frame::soft(Axes::splat(Abs::zero())), vec![]);
+            self.finish_region_internal(
+                Frame::soft(Axes::splat(Abs::zero())),
+                vec![],
+                Default::default(),
+            );
             skipped_region = true;
         }
 
-        self.footer_height = if skipped_region {
+        // TODO(subfooters): Consider resetting header height etc. if we skip
+        // region. (Maybe move that step to `finish_region_internal`.)
+        //
+        // That is unnecessary at the moment as 'prepare_footers' is only
+        // called at the start of the region, so header height is always zero
+        // and no headers were placed so far, but what about when we can have
+        // footers in the middle of the region? Let's think about this then.
+        self.current.footer_height = if skipped_region {
             // Simulate the footer again; the region's 'full' might have
             // changed.
             self.simulate_footer(footer, &self.regions, engine, disambiguator)?
@@ -118,12 +518,22 @@ impl GridLayouter<'_> {
         // Ensure footer rows have their own height available.
         // Won't change much as we're creating an unbreakable row group
         // anyway, so this is mostly for correctness.
-        self.regions.size.y += self.footer_height;
+        self.regions.size.y += self.current.footer_height;
 
+        let repeats = self.grid.footer.as_ref().is_some_and(|f| f.repeated);
         let footer_len = self.grid.rows.len() - footer.start;
         self.unbreakable_rows_left += footer_len;
+
         for y in footer.start..self.grid.rows.len() {
-            self.layout_row(y, engine, disambiguator)?;
+            self.layout_row_with_state(
+                y,
+                engine,
+                disambiguator,
+                RowState {
+                    in_active_repeatable: repeats,
+                    ..Default::default()
+                },
+            )?;
         }
 
         Ok(())
@@ -144,10 +554,18 @@ impl GridLayouter<'_> {
         // in the footer will be precisely the rows in the footer.
         self.simulate_unbreakable_row_group(
             footer.start,
-            Some(self.grid.rows.len() - footer.start),
+            Some(footer.end - footer.start),
             regions,
             engine,
             disambiguator,
         )
     }
 }
+
+/// The total amount of rows in the given list of headers.
+#[inline]
+pub fn total_header_row_count<'h>(
+    headers: impl IntoIterator<Item = &'h Header>,
+) -> usize {
+    headers.into_iter().map(|h| h.range.end - h.range.start).sum()
+}
diff --git a/crates/typst-layout/src/grid/rowspans.rs b/crates/typst-layout/src/grid/rowspans.rs
index 21992ed02..02ea14813 100644
--- a/crates/typst-layout/src/grid/rowspans.rs
+++ b/crates/typst-layout/src/grid/rowspans.rs
@@ -3,9 +3,8 @@ use typst_library::engine::Engine;
 use typst_library::foundations::Resolve;
 use typst_library::layout::grid::resolve::Repeatable;
 use typst_library::layout::{Abs, Axes, Frame, Point, Region, Regions, Size, Sizing};
-use typst_utils::MaybeReverseIter;
 
-use super::layouter::{in_last_with_offset, points, Row, RowPiece};
+use super::layouter::{points, Row};
 use super::{layout_cell, Cell, GridLayouter};
 
 /// All information needed to layout a single rowspan.
@@ -23,6 +22,10 @@ pub struct Rowspan {
     /// specified for the parent cell's `breakable` field.
     pub is_effectively_unbreakable: bool,
     /// The horizontal offset of this rowspan in all regions.
+    ///
+    /// This is the offset from the text direction start, meaning that, on RTL
+    /// grids, this is the offset from the right of the grid, whereas, on LTR
+    /// grids, it is the offset from the left.
     pub dx: Abs,
     /// The vertical offset of this rowspan in the first region.
     pub dy: Abs,
@@ -87,10 +90,10 @@ pub struct CellMeasurementData<'layouter> {
 
 impl GridLayouter<'_> {
     /// Layout a rowspan over the already finished regions, plus the current
-    /// region's frame and resolved rows, if it wasn't finished yet (because
-    /// we're being called from `finish_region`, but note that this function is
-    /// also called once after all regions are finished, in which case
-    /// `current_region_data` is `None`).
+    /// region's frame and height of resolved header rows, if it wasn't
+    /// finished yet (because we're being called from `finish_region`, but note
+    /// that this function is also called once after all regions are finished,
+    /// in which case `current_region_data` is `None`).
     ///
     /// We need to do this only once we already know the heights of all
     /// spanned rows, which is only possible after laying out the last row
@@ -98,7 +101,7 @@ impl GridLayouter<'_> {
     pub fn layout_rowspan(
         &mut self,
         rowspan_data: Rowspan,
-        current_region_data: Option<(&mut Frame, &[RowPiece])>,
+        current_region_data: Option<(&mut Frame, Abs)>,
         engine: &mut Engine,
     ) -> SourceResult<()> {
         let Rowspan {
@@ -118,10 +121,11 @@ impl GridLayouter<'_> {
             // Nothing to layout.
             return Ok(());
         };
-        let first_column = self.rcols[x];
         let cell = self.grid.cell(x, y).unwrap();
         let width = self.cell_spanned_width(cell, x);
-        let dx = if self.is_rtl { dx - width + first_column } else { dx };
+        // In RTL cells expand to the left, thus the position
+        // must additionally be offset by the cell's width.
+        let dx = if self.is_rtl { self.width - (dx + width) } else { dx };
 
         // Prepare regions.
         let size = Size::new(width, *first_height);
@@ -142,11 +146,31 @@ impl GridLayouter<'_> {
 
         // Push the layouted frames directly into the finished frames.
         let fragment = layout_cell(cell, engine, disambiguator, self.styles, pod)?;
-        let (current_region, current_rrows) = current_region_data.unzip();
-        for ((i, finished), frame) in self
+        let (current_region, current_header_row_height) = current_region_data.unzip();
+
+        // Clever trick to process finished header rows:
+        // - If there are grid headers, the vector will be filled with one
+        // finished header row height per region, so, chaining with the height
+        // for the current one, we get the header row height for each region.
+        //
+        // - But if there are no grid headers, the vector will be empty, so in
+        // theory the regions and resolved header row heights wouldn't match.
+        // But that's fine - 'current_header_row_height' can only be either
+        // 'Some(zero)' or 'None' in such a case, and for all other rows we
+        // append infinite zeros. That is, in such a case, the resolved header
+        // row height is always zero, so that's our fallback.
+        let finished_header_rows = self
+            .finished_header_rows
+            .iter()
+            .map(|info| info.repeated_height)
+            .chain(current_header_row_height)
+            .chain(std::iter::repeat(Abs::zero()));
+
+        for ((i, (finished, header_dy)), frame) in self
             .finished
             .iter_mut()
             .chain(current_region.into_iter())
+            .zip(finished_header_rows)
             .skip(first_region)
             .enumerate()
             .zip(fragment)
@@ -158,22 +182,9 @@ impl GridLayouter<'_> {
             } else {
                 // The rowspan continuation starts after the header (thus,
                 // at a position after the sum of the laid out header
-                // rows).
-                if let Some(Repeatable::Repeated(header)) = &self.grid.header {
-                    let header_rows = self
-                        .rrows
-                        .get(i)
-                        .map(Vec::as_slice)
-                        .or(current_rrows)
-                        .unwrap_or(&[])
-                        .iter()
-                        .take_while(|row| row.y < header.end);
-
-                    header_rows.map(|row| row.height).sum()
-                } else {
-                    // Without a header, start at the very top of the region.
-                    Abs::zero()
-                }
+                // rows). Without a header, this is zero, so the rowspan can
+                // start at the very top of the region as usual.
+                header_dy
             };
 
             finished.push_frame(Point::new(dx, dy), frame);
@@ -185,10 +196,8 @@ impl GridLayouter<'_> {
     /// Checks if a row contains the beginning of one or more rowspan cells.
     /// If so, adds them to the rowspans vector.
     pub fn check_for_rowspans(&mut self, disambiguator: usize, y: usize) {
-        // We will compute the horizontal offset of each rowspan in advance.
-        // For that reason, we must reverse the column order when using RTL.
-        let offsets = points(self.rcols.iter().copied().rev_if(self.is_rtl));
-        for (x, dx) in (0..self.rcols.len()).rev_if(self.is_rtl).zip(offsets) {
+        let offsets = points(self.rcols.iter().copied());
+        for (x, dx) in (0..self.rcols.len()).zip(offsets) {
             let Some(cell) = self.grid.cell(x, y) else {
                 continue;
             };
@@ -229,15 +238,13 @@ impl GridLayouter<'_> {
             // current row is dynamic and depends on the amount of upcoming
             // unbreakable cells (with or without a rowspan setting).
             let mut amount_unbreakable_rows = None;
-            if let Some(Repeatable::NotRepeated(header)) = &self.grid.header {
-                if current_row < header.end {
-                    // Non-repeated header, so keep it unbreakable.
-                    amount_unbreakable_rows = Some(header.end);
-                }
-            }
-            if let Some(Repeatable::NotRepeated(footer)) = &self.grid.footer {
-                if current_row >= footer.start {
+            if let Some(footer) = &self.grid.footer {
+                if !footer.repeated && current_row >= footer.start {
                     // Non-repeated footer, so keep it unbreakable.
+                    //
+                    // TODO(subfooters): This will become unnecessary
+                    // once non-repeated footers are treated differently and
+                    // have widow prevention.
                     amount_unbreakable_rows = Some(self.grid.rows.len() - footer.start);
                 }
             }
@@ -252,10 +259,7 @@ impl GridLayouter<'_> {
 
             // Skip to fitting region.
             while !self.regions.size.y.fits(row_group.height)
-                && !in_last_with_offset(
-                    self.regions,
-                    self.header_height + self.footer_height,
-                )
+                && self.may_progress_with_repeats()
             {
                 self.finish_region(engine, false)?;
             }
@@ -394,16 +398,29 @@ impl GridLayouter<'_> {
             // auto rows don't depend on the backlog, as they only span one
             // region.
             if breakable
-                && (matches!(self.grid.header, Some(Repeatable::Repeated(_)))
-                    || matches!(self.grid.footer, Some(Repeatable::Repeated(_))))
+                && (!self.repeating_headers.is_empty()
+                    || !self.pending_headers.is_empty()
+                    || matches!(&self.grid.footer, Some(footer) if footer.repeated))
             {
                 // Subtract header and footer height from all upcoming regions
                 // when measuring the cell, including the last repeated region.
                 //
                 // This will update the 'custom_backlog' vector with the
                 // updated heights of the upcoming regions.
+                //
+                // We predict that header height will only include that of
+                // repeating headers, as we can assume non-repeating headers in
+                // the first region have been successfully placed, unless
+                // something didn't fit on the first region of the auto row,
+                // but we will only find that out after measurement, and if
+                // that happens, we discard the measurement and try again.
                 let mapped_regions = self.regions.map(&mut custom_backlog, |size| {
-                    Size::new(size.x, size.y - self.header_height - self.footer_height)
+                    Size::new(
+                        size.x,
+                        size.y
+                            - self.current.repeating_header_height
+                            - self.current.footer_height,
+                    )
                 });
 
                 // Callees must use the custom backlog instead of the current
@@ -457,6 +474,7 @@ impl GridLayouter<'_> {
             // Height of the rowspan covered by spanned rows in the current
             // region.
             let laid_out_height: Abs = self
+                .current
                 .lrows
                 .iter()
                 .filter_map(|row| match row {
@@ -504,7 +522,12 @@ impl GridLayouter<'_> {
                     .iter()
                     .copied()
                     .chain(std::iter::once(if breakable {
-                        self.initial.y - self.header_height - self.footer_height
+                        // Here we are calculating the available height for a
+                        // rowspan from the top of the current region, so
+                        // we have to use initial header heights (note that
+                        // header height can change in the middle of the
+                        // region).
+                        self.current.initial_after_repeats
                     } else {
                         // When measuring unbreakable auto rows, infinite
                         // height is available for content to expand.
@@ -516,11 +539,13 @@ impl GridLayouter<'_> {
                     // rowspan's already laid out heights with the current
                     // region's height and current backlog to ensure a good
                     // level of accuracy in the measurements.
-                    let backlog = self
-                        .regions
-                        .backlog
-                        .iter()
-                        .map(|&size| size - self.header_height - self.footer_height);
+                    //
+                    // Assume only repeating headers will survive starting at
+                    // the next region.
+                    let backlog = self.regions.backlog.iter().map(|&size| {
+                        size - self.current.repeating_header_height
+                            - self.current.footer_height
+                    });
 
                     heights_up_to_current_region.chain(backlog).collect::<Vec<_>>()
                 } else {
@@ -534,10 +559,10 @@ impl GridLayouter<'_> {
                 height = *rowspan_height;
                 backlog = None;
                 full = rowspan_full;
-                last = self
-                    .regions
-                    .last
-                    .map(|size| size - self.header_height - self.footer_height);
+                last = self.regions.last.map(|size| {
+                    size - self.current.repeating_header_height
+                        - self.current.footer_height
+                });
             } else {
                 // The rowspan started in the current region, as its vector
                 // of heights in regions is currently empty.
@@ -739,10 +764,11 @@ impl GridLayouter<'_> {
             simulated_regions.next();
             disambiguator += 1;
 
-            // Subtract the initial header and footer height, since that's the
-            // height we used when subtracting from the region backlog's
+            // Subtract the repeating header and footer height, since that's
+            // the height we used when subtracting from the region backlog's
             // heights while measuring cells.
-            simulated_regions.size.y -= self.header_height + self.footer_height;
+            simulated_regions.size.y -=
+                self.current.repeating_header_height + self.current.footer_height;
         }
 
         if let Some(original_last_resolved_size) = last_resolved_size {
@@ -874,12 +900,8 @@ impl GridLayouter<'_> {
         // which, when used and combined with upcoming spanned rows, covers all
         // of the requested rowspan height, we give up.
         for _attempt in 0..5 {
-            let rowspan_simulator = RowspanSimulator::new(
-                disambiguator,
-                simulated_regions,
-                self.header_height,
-                self.footer_height,
-            );
+            let rowspan_simulator =
+                RowspanSimulator::new(disambiguator, simulated_regions, &self.current);
 
             let total_spanned_height = rowspan_simulator.simulate_rowspan_layout(
                 y,
@@ -961,7 +983,8 @@ impl GridLayouter<'_> {
             {
                 extra_amount_to_grow -= simulated_regions.size.y.max(Abs::zero());
                 simulated_regions.next();
-                simulated_regions.size.y -= self.header_height + self.footer_height;
+                simulated_regions.size.y -=
+                    self.current.repeating_header_height + self.current.footer_height;
                 disambiguator += 1;
             }
             simulated_regions.size.y -= extra_amount_to_grow;
@@ -978,10 +1001,17 @@ struct RowspanSimulator<'a> {
     finished: usize,
     /// The state of regions during the simulation.
     regions: Regions<'a>,
-    /// The height of the header in the currently simulated region.
+    /// The total height of headers in the currently simulated region.
     header_height: Abs,
-    /// The height of the footer in the currently simulated region.
+    /// The total height of footers in the currently simulated region.
     footer_height: Abs,
+    /// Whether `self.regions.may_progress()` was `true` at the top of the
+    /// region, indicating we can progress anywhere in the current region,
+    /// even right after a repeated header.
+    could_progress_at_top: bool,
+    /// Available height after laying out repeated headers at the top of the
+    /// currently simulated region.
+    initial_after_repeats: Abs,
     /// The total spanned height so far in the simulation.
     total_spanned_height: Abs,
     /// Height of the latest spanned gutter row in the simulation.
@@ -995,14 +1025,19 @@ impl<'a> RowspanSimulator<'a> {
     fn new(
         finished: usize,
         regions: Regions<'a>,
-        header_height: Abs,
-        footer_height: Abs,
+        current: &super::layouter::Current,
     ) -> Self {
         Self {
             finished,
             regions,
-            header_height,
-            footer_height,
+            // There can be no new headers or footers within a multi-page
+            // rowspan, since headers and footers are unbreakable, so
+            // assuming the repeating header height and footer height
+            // won't change is safe.
+            header_height: current.repeating_header_height,
+            footer_height: current.footer_height,
+            could_progress_at_top: current.could_progress_at_top,
+            initial_after_repeats: current.initial_after_repeats,
             total_spanned_height: Abs::zero(),
             latest_spanned_gutter_height: Abs::zero(),
         }
@@ -1051,10 +1086,7 @@ impl<'a> RowspanSimulator<'a> {
                     0,
                 )?;
                 while !self.regions.size.y.fits(row_group.height)
-                    && !in_last_with_offset(
-                        self.regions,
-                        self.header_height + self.footer_height,
-                    )
+                    && self.may_progress_with_repeats()
                 {
                     self.finish_region(layouter, engine)?;
                 }
@@ -1076,10 +1108,7 @@ impl<'a> RowspanSimulator<'a> {
                     let mut skipped_region = false;
                     while unbreakable_rows_left == 0
                         && !self.regions.size.y.fits(height)
-                        && !in_last_with_offset(
-                            self.regions,
-                            self.header_height + self.footer_height,
-                        )
+                        && self.may_progress_with_repeats()
                     {
                         self.finish_region(layouter, engine)?;
 
@@ -1125,23 +1154,37 @@ impl<'a> RowspanSimulator<'a> {
         // our simulation checks what happens AFTER the auto row, so we can
         // just use the original backlog from `self.regions`.
         let disambiguator = self.finished;
-        let header_height =
-            if let Some(Repeatable::Repeated(header)) = &layouter.grid.header {
-                layouter
-                    .simulate_header(header, &self.regions, engine, disambiguator)?
-                    .height
-            } else {
-                Abs::zero()
-            };
 
-        let footer_height =
-            if let Some(Repeatable::Repeated(footer)) = &layouter.grid.footer {
-                layouter
-                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                    .height
-            } else {
-                Abs::zero()
-            };
+        let (repeating_headers, header_height) = if !layouter.repeating_headers.is_empty()
+            || !layouter.pending_headers.is_empty()
+        {
+            // Only repeating headers have survived after the first region
+            // break.
+            let repeating_headers = layouter.repeating_headers.iter().copied().chain(
+                layouter.pending_headers.iter().filter_map(Repeatable::as_repeated),
+            );
+
+            let header_height = layouter.simulate_header_height(
+                repeating_headers.clone(),
+                &self.regions,
+                engine,
+                disambiguator,
+            )?;
+
+            (Some(repeating_headers), header_height)
+        } else {
+            (None, Abs::zero())
+        };
+
+        let footer_height = if let Some(footer) =
+            layouter.grid.footer.as_ref().and_then(Repeatable::as_repeated)
+        {
+            layouter
+                .simulate_footer(footer, &self.regions, engine, disambiguator)?
+                .height
+        } else {
+            Abs::zero()
+        };
 
         let mut skipped_region = false;
 
@@ -1154,19 +1197,24 @@ impl<'a> RowspanSimulator<'a> {
             skipped_region = true;
         }
 
-        if let Some(Repeatable::Repeated(header)) = &layouter.grid.header {
+        if let Some(repeating_headers) = repeating_headers {
             self.header_height = if skipped_region {
                 // Simulate headers again, at the new region, as
                 // the full region height may change.
-                layouter
-                    .simulate_header(header, &self.regions, engine, disambiguator)?
-                    .height
+                layouter.simulate_header_height(
+                    repeating_headers,
+                    &self.regions,
+                    engine,
+                    disambiguator,
+                )?
             } else {
                 header_height
             };
         }
 
-        if let Some(Repeatable::Repeated(footer)) = &layouter.grid.footer {
+        if let Some(footer) =
+            layouter.grid.footer.as_ref().and_then(Repeatable::as_repeated)
+        {
             self.footer_height = if skipped_region {
                 // Simulate footers again, at the new region, as
                 // the full region height may change.
@@ -1183,6 +1231,7 @@ impl<'a> RowspanSimulator<'a> {
         // header or footer (as an invariant, any rowspans spanning any header
         // or footer rows are fully contained within that header's or footer's rows).
         self.regions.size.y -= self.header_height + self.footer_height;
+        self.initial_after_repeats = self.regions.size.y;
 
         Ok(())
     }
@@ -1199,8 +1248,18 @@ impl<'a> RowspanSimulator<'a> {
         self.regions.next();
         self.finished += 1;
 
+        self.could_progress_at_top = self.regions.may_progress();
         self.simulate_header_footer_layout(layouter, engine)
     }
+
+    /// Similar to [`GridLayouter::may_progress_with_repeats`] but for rowspan
+    /// simulation.
+    #[inline]
+    fn may_progress_with_repeats(&self) -> bool {
+        self.could_progress_at_top
+            || self.regions.last.is_some()
+                && self.regions.size.y != self.initial_after_repeats
+    }
 }
 
 /// Subtracts some size from the end of a vector of sizes.
diff --git a/crates/typst-layout/src/image.rs b/crates/typst-layout/src/image.rs
index 3e5b7d8bd..a8f4a0c81 100644
--- a/crates/typst-layout/src/image.rs
+++ b/crates/typst-layout/src/image.rs
@@ -1,6 +1,6 @@
 use std::ffi::OsStr;
 
-use typst_library::diag::{warning, At, SourceResult, StrResult};
+use typst_library::diag::{warning, At, LoadedWithin, SourceResult, StrResult};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Bytes, Derived, Packed, Smart, StyleChain};
 use typst_library::introspection::Locator;
@@ -27,17 +27,17 @@ pub fn layout_image(
 
     // Take the format that was explicitly defined, or parse the extension,
     // or try to detect the format.
-    let Derived { source, derived: data } = &elem.source;
+    let Derived { source, derived: loaded } = &elem.source;
     let format = match elem.format(styles) {
         Smart::Custom(v) => v,
-        Smart::Auto => determine_format(source, data).at(span)?,
+        Smart::Auto => determine_format(source, &loaded.data).at(span)?,
     };
 
     // Warn the user if the image contains a foreign object. Not perfect
     // because the svg could also be encoded, but that's an edge case.
     if format == ImageFormat::Vector(VectorFormat::Svg) {
         let has_foreign_object =
-            data.as_str().is_ok_and(|s| s.contains("<foreignObject"));
+            memchr::memmem::find(&loaded.data, b"<foreignObject").is_some();
 
         if has_foreign_object {
             engine.sink.warn(warning!(
@@ -53,7 +53,7 @@ pub fn layout_image(
     let kind = match format {
         ImageFormat::Raster(format) => ImageKind::Raster(
             RasterImage::new(
-                data.clone(),
+                loaded.data.clone(),
                 format,
                 elem.icc(styles).as_ref().map(|icc| icc.derived.clone()),
             )
@@ -61,11 +61,11 @@ pub fn layout_image(
         ),
         ImageFormat::Vector(VectorFormat::Svg) => ImageKind::Svg(
             SvgImage::with_fonts(
-                data.clone(),
+                loaded.data.clone(),
                 engine.world,
                 &families(styles).map(|f| f.as_str()).collect::<Vec<_>>(),
             )
-            .at(span)?,
+            .within(loaded)?,
         ),
     };
 
@@ -147,6 +147,7 @@ fn determine_format(source: &DataSource, data: &Bytes) -> StrResult<ImageFormat>
             "jpg" | "jpeg" => return Ok(ExchangeFormat::Jpg.into()),
             "gif" => return Ok(ExchangeFormat::Gif.into()),
             "svg" | "svgz" => return Ok(VectorFormat::Svg.into()),
+            "webp" => return Ok(ExchangeFormat::Webp.into()),
             _ => {}
         }
     }
diff --git a/crates/typst-layout/src/inline/linebreak.rs b/crates/typst-layout/src/inline/linebreak.rs
index 31512604f..ada048c7d 100644
--- a/crates/typst-layout/src/inline/linebreak.rs
+++ b/crates/typst-layout/src/inline/linebreak.rs
@@ -690,13 +690,34 @@ fn breakpoints(p: &Preparation, mut f: impl FnMut(usize, Breakpoint)) {
         let breakpoint = if point == text.len() {
             Breakpoint::Mandatory
         } else {
+            const OBJ_REPLACE: char = '\u{FFFC}';
             match lb.get(c) {
-                // Fix for: https://github.com/unicode-org/icu4x/issues/4146
-                LineBreak::Glue | LineBreak::WordJoiner | LineBreak::ZWJ => continue,
                 LineBreak::MandatoryBreak
                 | LineBreak::CarriageReturn
                 | LineBreak::LineFeed
                 | LineBreak::NextLine => Breakpoint::Mandatory,
+
+                // https://github.com/typst/typst/issues/5489
+                //
+                // OBJECT-REPLACEMENT-CHARACTERs provide Contingent Break
+                // opportunities before and after by default. This behaviour
+                // is however tailorable, see:
+                // https://www.unicode.org/reports/tr14/#CB
+                // https://www.unicode.org/reports/tr14/#TailorableBreakingRules
+                // https://www.unicode.org/reports/tr14/#LB20
+                //
+                // Don't provide a line breaking opportunity between a LTR-
+                // ISOLATE (or any other Combining Mark) and an OBJECT-
+                // REPLACEMENT-CHARACTER representing an inline item, if the
+                // LTR-ISOLATE could end up as the only character on the
+                // previous line.
+                LineBreak::CombiningMark
+                    if text[point..].starts_with(OBJ_REPLACE)
+                        && last + c.len_utf8() == point =>
+                {
+                    continue;
+                }
+
                 _ => Breakpoint::Normal,
             }
         };
diff --git a/crates/typst-layout/src/inline/mod.rs b/crates/typst-layout/src/inline/mod.rs
index 5ef820d07..6cafb9b00 100644
--- a/crates/typst-layout/src/inline/mod.rs
+++ b/crates/typst-layout/src/inline/mod.rs
@@ -9,6 +9,7 @@ mod prepare;
 mod shaping;
 
 pub use self::box_::layout_box;
+pub use self::shaping::create_shape_plan;
 
 use comemo::{Track, Tracked, TrackedMut};
 use typst_library::diag::SourceResult;
diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs
index 159619eb3..935a86b38 100644
--- a/crates/typst-layout/src/inline/shaping.rs
+++ b/crates/typst-layout/src/inline/shaping.rs
@@ -1,18 +1,16 @@
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
-use std::str::FromStr;
 use std::sync::Arc;
 
 use az::SaturatingAs;
-use ecow::EcoString;
 use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer};
 use ttf_parser::Tag;
 use typst_library::engine::Engine;
 use typst_library::foundations::{Smart, StyleChain};
 use typst_library::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size};
 use typst_library::text::{
-    families, features, is_default_ignorable, variant, Font, FontFamily, FontVariant,
-    Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
+    families, features, is_default_ignorable, language, variant, Font, FontFamily,
+    FontVariant, Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
 };
 use typst_library::World;
 use typst_utils::SliceExt;
@@ -20,7 +18,7 @@ use unicode_bidi::{BidiInfo, Level as BidiLevel};
 use unicode_script::{Script, UnicodeScript};
 
 use super::{decorate, Item, Range, SpanMapper};
-use crate::modifiers::{FrameModifiers, FrameModify};
+use crate::modifiers::FrameModifyText;
 
 /// The result of shaping text.
 ///
@@ -295,6 +293,8 @@ impl<'a> ShapedText<'a> {
                             + justification_left
                             + justification_right,
                         x_offset: shaped.x_offset + justification_left,
+                        y_advance: Em::zero(),
+                        y_offset: Em::zero(),
                         range: (shaped.range.start - range.start).saturating_as()
                             ..(shaped.range.end - range.start).saturating_as(),
                         span,
@@ -327,7 +327,7 @@ impl<'a> ShapedText<'a> {
             offset += width;
         }
 
-        frame.modify(&FrameModifiers::get_in(self.styles));
+        frame.modify_text(self.styles);
         frame
     }
 
@@ -824,12 +824,42 @@ fn shape_segment<'a>(
 
         // Add the glyph to the shaped output.
         if info.glyph_id != 0 && is_covered(cluster) {
-            // Determine the text range of the glyph.
+            // Assume we have the following sequence of (glyph_id, cluster):
+            // [(120, 0), (80, 0), (3, 3), (755, 4), (69, 4), (424, 13),
+            //  (63, 13), (193, 25), (80, 25), (3, 31)
+            //
+            // We then want the sequence of (glyph_id, text_range) to look as follows:
+            // [(120, 0..3), (80, 0..3), (3, 3..4), (755, 4..13), (69, 4..13),
+            //  (424, 13..25), (63, 13..25), (193, 25..31), (80, 25..31), (3, 31..x)]
+            //
+            // Each glyph in the same cluster should be assigned the full text
+            // range. This is necessary because only this way krilla can
+            // properly assign `ActualText` attributes in complex shaping
+            // scenarios.
+
+            // The start of the glyph's text range.
             let start = base + cluster;
-            let end = base
-                + if ltr { i.checked_add(1) } else { i.checked_sub(1) }
-                    .and_then(|last| infos.get(last))
-                    .map_or(text.len(), |info| info.cluster as usize);
+
+            // Determine the end of the glyph's text range.
+            let mut k = i;
+            let step: isize = if ltr { 1 } else { -1 };
+            let end = loop {
+                // If we've reached the end of the glyphs, the `end` of the
+                // range should be the end of the full text.
+                let Some((next, next_info)) = k
+                    .checked_add_signed(step)
+                    .and_then(|n| infos.get(n).map(|info| (n, info)))
+                else {
+                    break base + text.len();
+                };
+
+                // If the cluster doesn't match anymore, we've reached the end.
+                if next_info.cluster != info.cluster {
+                    break base + next_info.cluster as usize;
+                }
+
+                k = next;
+            };
 
             let c = text[cluster..].chars().next().unwrap();
             let script = c.script();
@@ -904,7 +934,7 @@ fn shape_segment<'a>(
 
 /// Create a shape plan.
 #[comemo::memoize]
-fn create_shape_plan(
+pub fn create_shape_plan(
     font: &Font,
     direction: rustybuzz::Direction,
     script: rustybuzz::Script,
@@ -922,7 +952,7 @@ fn create_shape_plan(
 
 /// Shape the text with tofus from the given font.
 fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
-    let x_advance = font.advance(0).unwrap_or_default();
+    let x_advance = font.x_advance(0).unwrap_or_default();
     let add_glyph = |(cluster, c): (usize, char)| {
         let start = base + cluster;
         let end = start + c.len_utf8();
@@ -1014,20 +1044,8 @@ fn calculate_adjustability(ctx: &mut ShapingContext, lang: Lang, region: Option<
 
 /// Difference between non-breaking and normal space.
 fn nbsp_delta(font: &Font) -> Option<Em> {
-    let space = font.ttf().glyph_index(' ')?.0;
     let nbsp = font.ttf().glyph_index('\u{00A0}')?.0;
-    Some(font.advance(nbsp)? - font.advance(space)?)
-}
-
-/// Process the language and region of a style chain into a
-/// rustybuzz-compatible BCP 47 language.
-fn language(styles: StyleChain) -> rustybuzz::Language {
-    let mut bcp: EcoString = TextElem::lang_in(styles).as_str().into();
-    if let Some(region) = TextElem::region_in(styles) {
-        bcp.push('-');
-        bcp.push_str(region.as_str());
-    }
-    rustybuzz::Language::from_str(&bcp).unwrap()
+    Some(font.x_advance(nbsp)? - font.space_width()?)
 }
 
 /// Returns true if all glyphs in `glyphs` have ranges within the range `range`.
diff --git a/crates/typst-layout/src/lists.rs b/crates/typst-layout/src/lists.rs
index f8d910abf..974788a70 100644
--- a/crates/typst-layout/src/lists.rs
+++ b/crates/typst-layout/src/lists.rs
@@ -96,9 +96,13 @@ pub fn layout_enum(
 
     let mut cells = vec![];
     let mut locator = locator.split();
-    let mut number =
-        elem.start(styles)
-            .unwrap_or_else(|| if reversed { elem.children.len() } else { 1 });
+    let mut number = elem.start(styles).unwrap_or_else(|| {
+        if reversed {
+            elem.children.len() as u64
+        } else {
+            1
+        }
+    });
     let mut parents = EnumElem::parents_in(styles);
 
     let full = elem.full(styles);
diff --git a/crates/typst-layout/src/math/accent.rs b/crates/typst-layout/src/math/accent.rs
index f2dfa2c45..159703b8e 100644
--- a/crates/typst-layout/src/math/accent.rs
+++ b/crates/typst-layout/src/math/accent.rs
@@ -1,9 +1,12 @@
 use typst_library::diag::SourceResult;
 use typst_library::foundations::{Packed, StyleChain};
 use typst_library::layout::{Em, Frame, Point, Size};
-use typst_library::math::{Accent, AccentElem};
+use typst_library::math::AccentElem;
 
-use super::{style_cramped, FrameFragment, GlyphFragment, MathContext, MathFragment};
+use super::{
+    style_cramped, style_dtls, style_flac, FrameFragment, GlyphFragment, MathContext,
+    MathFragment,
+};
 
 /// How much the accent can be shorter than the base.
 const ACCENT_SHORT_FALL: Em = Em::new(0.5);
@@ -15,53 +18,71 @@ pub fn layout_accent(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let cramped = style_cramped();
-    let mut base = ctx.layout_into_fragment(&elem.base, styles.chain(&cramped))?;
+    let accent = elem.accent;
+    let top_accent = !accent.is_bottom();
 
-    // Try to replace a glyph with its dotless variant.
-    if let MathFragment::Glyph(glyph) = &mut base {
-        glyph.make_dotless_form(ctx);
-    }
+    // Try to replace the base glyph with its dotless variant.
+    let dtls = style_dtls();
+    let base_styles =
+        if top_accent && elem.dotless(styles) { styles.chain(&dtls) } else { styles };
+
+    let cramped = style_cramped();
+    let base = ctx.layout_into_fragment(&elem.base, base_styles.chain(&cramped))?;
 
     // Preserve class to preserve automatic spacing.
     let base_class = base.class();
     let base_attach = base.accent_attach();
 
-    let width = elem.size(styles).relative_to(base.width());
-
-    let Accent(c) = elem.accent;
-    let mut glyph = GlyphFragment::new(ctx, styles, c, elem.span());
-
-    // Try to replace accent glyph with flattened variant.
+    // Try to replace the accent glyph with its flattened variant.
     let flattened_base_height = scaled!(ctx, styles, flattened_accent_base_height);
-    if base.ascent() > flattened_base_height {
-        glyph.make_flattened_accent_form(ctx);
-    }
+    let flac = style_flac();
+    let accent_styles = if top_accent && base.ascent() > flattened_base_height {
+        styles.chain(&flac)
+    } else {
+        styles
+    };
 
-    // Forcing the accent to be at least as large as the base makes it too
-    // wide in many case.
-    let short_fall = ACCENT_SHORT_FALL.at(glyph.font_size);
-    let variant = glyph.stretch_horizontal(ctx, width, short_fall);
-    let accent = variant.frame;
-    let accent_attach = variant.accent_attach;
+    let mut glyph =
+        GlyphFragment::new_char(ctx.font, accent_styles, accent.0, elem.span())?;
+
+    // Forcing the accent to be at least as large as the base makes it too wide
+    // in many cases.
+    let width = elem.size(styles).relative_to(base.width());
+    let short_fall = ACCENT_SHORT_FALL.at(glyph.item.size);
+    glyph.stretch_horizontal(ctx, width - short_fall);
+    let accent_attach = glyph.accent_attach.0;
+    let accent = glyph.into_frame();
+
+    let (gap, accent_pos, base_pos) = if top_accent {
+        // Descent is negative because the accent's ink bottom is above the
+        // baseline. Therefore, the default gap is the accent's negated descent
+        // minus the accent base height. Only if the base is very small, we
+        // need a larger gap so that the accent doesn't move too low.
+        let accent_base_height = scaled!(ctx, styles, accent_base_height);
+        let gap = -accent.descent() - base.ascent().min(accent_base_height);
+        let accent_pos = Point::with_x(base_attach.0 - accent_attach);
+        let base_pos = Point::with_y(accent.height() + gap);
+        (gap, accent_pos, base_pos)
+    } else {
+        let gap = -accent.ascent();
+        let accent_pos = Point::new(base_attach.1 - accent_attach, base.height() + gap);
+        let base_pos = Point::zero();
+        (gap, accent_pos, base_pos)
+    };
 
-    // Descent is negative because the accent's ink bottom is above the
-    // baseline. Therefore, the default gap is the accent's negated descent
-    // minus the accent base height. Only if the base is very small, we need
-    // a larger gap so that the accent doesn't move too low.
-    let accent_base_height = scaled!(ctx, styles, accent_base_height);
-    let gap = -accent.descent() - base.ascent().min(accent_base_height);
     let size = Size::new(base.width(), accent.height() + gap + base.height());
-    let accent_pos = Point::with_x(base_attach - accent_attach);
-    let base_pos = Point::with_y(accent.height() + gap);
     let baseline = base_pos.y + base.ascent();
+
     let base_italics_correction = base.italics_correction();
     let base_text_like = base.is_text_like();
-
     let base_ascent = match &base {
         MathFragment::Frame(frame) => frame.base_ascent,
         _ => base.ascent(),
     };
+    let base_descent = match &base {
+        MathFragment::Frame(frame) => frame.base_descent,
+        _ => base.descent(),
+    };
 
     let mut frame = Frame::soft(size);
     frame.set_baseline(baseline);
@@ -71,6 +92,7 @@ pub fn layout_accent(
         FrameFragment::new(styles, frame)
             .with_class(base_class)
             .with_base_ascent(base_ascent)
+            .with_base_descent(base_descent)
             .with_italics_correction(base_italics_correction)
             .with_accent_attach(base_attach)
             .with_text_like(base_text_like),
diff --git a/crates/typst-layout/src/math/attach.rs b/crates/typst-layout/src/math/attach.rs
index e1d7d7c9d..a7f3cad5f 100644
--- a/crates/typst-layout/src/math/attach.rs
+++ b/crates/typst-layout/src/math/attach.rs
@@ -66,7 +66,6 @@ pub fn layout_attach(
         let relative_to_width = measure!(t, width).max(measure!(b, width));
         stretch_fragment(
             ctx,
-            styles,
             &mut base,
             Some(Axis::X),
             Some(relative_to_width),
@@ -220,7 +219,6 @@ fn layout_attachments(
     // Calculate the distance each pre-script extends to the left of the base's
     // width.
     let (tl_pre_width, bl_pre_width) = compute_pre_script_widths(
-        ctx,
         &base,
         [tl.as_ref(), bl.as_ref()],
         (tx_shift, bx_shift),
@@ -231,7 +229,6 @@ fn layout_attachments(
     // base's width. Also calculate each post-script's kerning (we need this for
     // its position later).
     let ((tr_post_width, tr_kern), (br_post_width, br_kern)) = compute_post_script_widths(
-        ctx,
         &base,
         [tr.as_ref(), br.as_ref()],
         (tx_shift, bx_shift),
@@ -287,14 +284,13 @@ fn layout_attachments(
 /// post-script's kerning value. The first tuple is for the post-superscript,
 /// and the second is for the post-subscript.
 fn compute_post_script_widths(
-    ctx: &MathContext,
     base: &MathFragment,
     [tr, br]: [Option<&MathFragment>; 2],
     (tr_shift, br_shift): (Abs, Abs),
     space_after_post_script: Abs,
 ) -> ((Abs, Abs), (Abs, Abs)) {
     let tr_values = tr.map_or_default(|tr| {
-        let kern = math_kern(ctx, base, tr, tr_shift, Corner::TopRight);
+        let kern = math_kern(base, tr, tr_shift, Corner::TopRight);
         (space_after_post_script + tr.width() + kern, kern)
     });
 
@@ -302,7 +298,7 @@ fn compute_post_script_widths(
     // need to shift the post-subscript left by the base's italic correction
     // (see the kerning algorithm as described in the OpenType MATH spec).
     let br_values = br.map_or_default(|br| {
-        let kern = math_kern(ctx, base, br, br_shift, Corner::BottomRight)
+        let kern = math_kern(base, br, br_shift, Corner::BottomRight)
             - base.italics_correction();
         (space_after_post_script + br.width() + kern, kern)
     });
@@ -317,19 +313,18 @@ fn compute_post_script_widths(
 /// extends left of the base's width and the second being the distance the
 /// pre-subscript extends left of the base's width.
 fn compute_pre_script_widths(
-    ctx: &MathContext,
     base: &MathFragment,
     [tl, bl]: [Option<&MathFragment>; 2],
     (tl_shift, bl_shift): (Abs, Abs),
     space_before_pre_script: Abs,
 ) -> (Abs, Abs) {
     let tl_pre_width = tl.map_or_default(|tl| {
-        let kern = math_kern(ctx, base, tl, tl_shift, Corner::TopLeft);
+        let kern = math_kern(base, tl, tl_shift, Corner::TopLeft);
         space_before_pre_script + tl.width() + kern
     });
 
     let bl_pre_width = bl.map_or_default(|bl| {
-        let kern = math_kern(ctx, base, bl, bl_shift, Corner::BottomLeft);
+        let kern = math_kern(base, bl, bl_shift, Corner::BottomLeft);
         space_before_pre_script + bl.width() + kern
     });
 
@@ -434,9 +429,13 @@ fn compute_script_shifts(
     }
 
     if bl.is_some() || br.is_some() {
+        let descent = match &base {
+            MathFragment::Frame(frame) => frame.base_descent,
+            _ => base.descent(),
+        };
         shift_down = shift_down
             .max(sub_shift_down)
-            .max(if is_text_like { Abs::zero() } else { base.descent() + sub_drop_min })
+            .max(if is_text_like { Abs::zero() } else { descent + sub_drop_min })
             .max(measure!(bl, ascent) - sub_top_max)
             .max(measure!(br, ascent) - sub_top_max);
     }
@@ -467,13 +466,7 @@ fn compute_script_shifts(
 /// a negative value means shifting the script closer to the base. Requires the
 /// distance from the base's baseline to the script's baseline, as well as the
 /// script's corner (tl, tr, bl, br).
-fn math_kern(
-    ctx: &MathContext,
-    base: &MathFragment,
-    script: &MathFragment,
-    shift: Abs,
-    pos: Corner,
-) -> Abs {
+fn math_kern(base: &MathFragment, script: &MathFragment, shift: Abs, pos: Corner) -> Abs {
     // This process is described under the MathKernInfo table in the OpenType
     // MATH spec.
 
@@ -498,8 +491,8 @@ fn math_kern(
 
     // Calculate the sum of kerning values for each correction height.
     let summed_kern = |height| {
-        let base_kern = base.kern_at_height(ctx, pos, height);
-        let attach_kern = script.kern_at_height(ctx, pos.inv(), height);
+        let base_kern = base.kern_at_height(pos, height);
+        let attach_kern = script.kern_at_height(pos.inv(), height);
         base_kern + attach_kern
     };
 
diff --git a/crates/typst-layout/src/math/frac.rs b/crates/typst-layout/src/math/frac.rs
index 6d3caac45..091f328f6 100644
--- a/crates/typst-layout/src/math/frac.rs
+++ b/crates/typst-layout/src/math/frac.rs
@@ -109,14 +109,14 @@ fn layout_frac_like(
     frame.push_frame(denom_pos, denom);
 
     if binom {
-        let mut left = GlyphFragment::new(ctx, styles, '(', span)
-            .stretch_vertical(ctx, height, short_fall);
-        left.center_on_axis(ctx);
+        let mut left = GlyphFragment::new_char(ctx.font, styles, '(', span)?;
+        left.stretch_vertical(ctx, height - short_fall);
+        left.center_on_axis();
         ctx.push(left);
         ctx.push(FrameFragment::new(styles, frame));
-        let mut right = GlyphFragment::new(ctx, styles, ')', span)
-            .stretch_vertical(ctx, height, short_fall);
-        right.center_on_axis(ctx);
+        let mut right = GlyphFragment::new_char(ctx.font, styles, ')', span)?;
+        right.stretch_vertical(ctx, height - short_fall);
+        right.center_on_axis();
         ctx.push(right);
     } else {
         frame.push(
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
index 1b508a349..eb85eeb5d 100644
--- a/crates/typst-layout/src/math/fragment.rs
+++ b/crates/typst-layout/src/math/fragment.rs
@@ -1,28 +1,32 @@
 use std::fmt::{self, Debug, Formatter};
 
-use rustybuzz::Feature;
-use ttf_parser::gsub::{AlternateSubstitution, SingleSubstitution, SubstitutionSubtable};
-use ttf_parser::opentype_layout::LayoutTable;
-use ttf_parser::{GlyphId, Rect};
+use az::SaturatingAs;
+use rustybuzz::{BufferFlags, UnicodeBuffer};
+use ttf_parser::math::{GlyphAssembly, GlyphConstruction, GlyphPart};
+use ttf_parser::GlyphId;
+use typst_library::diag::{bail, warning, SourceResult};
 use typst_library::foundations::StyleChain;
 use typst_library::introspection::Tag;
 use typst_library::layout::{
-    Abs, Axis, Corner, Em, Frame, FrameItem, Point, Size, VAlignment,
+    Abs, Axes, Axis, Corner, Em, Frame, FrameItem, Point, Size, VAlignment,
 };
 use typst_library::math::{EquationElem, MathSize};
-use typst_library::text::{Font, Glyph, Lang, Region, TextElem, TextItem};
-use typst_library::visualize::Paint;
+use typst_library::text::{features, language, Font, Glyph, TextElem, TextItem};
 use typst_syntax::Span;
-use typst_utils::default_math_class;
+use typst_utils::{default_math_class, Get};
 use unicode_math_class::MathClass;
 
-use super::{stretch_glyph, MathContext, Scaled};
+use super::MathContext;
+use crate::inline::create_shape_plan;
 use crate::modifiers::{FrameModifiers, FrameModify};
 
+/// Maximum number of times extenders can be repeated.
+const MAX_REPEATS: usize = 1024;
+
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum MathFragment {
     Glyph(GlyphFragment),
-    Variant(VariantFragment),
     Frame(FrameFragment),
     Spacing(Abs, bool),
     Space(Abs),
@@ -33,13 +37,18 @@ pub enum MathFragment {
 
 impl MathFragment {
     pub fn size(&self) -> Size {
-        Size::new(self.width(), self.height())
+        match self {
+            Self::Glyph(glyph) => glyph.size,
+            Self::Frame(fragment) => fragment.frame.size(),
+            Self::Spacing(amount, _) => Size::with_x(*amount),
+            Self::Space(amount) => Size::with_x(*amount),
+            _ => Size::zero(),
+        }
     }
 
     pub fn width(&self) -> Abs {
         match self {
-            Self::Glyph(glyph) => glyph.width,
-            Self::Variant(variant) => variant.frame.width(),
+            Self::Glyph(glyph) => glyph.size.x,
             Self::Frame(fragment) => fragment.frame.width(),
             Self::Spacing(amount, _) => *amount,
             Self::Space(amount) => *amount,
@@ -49,8 +58,7 @@ impl MathFragment {
 
     pub fn height(&self) -> Abs {
         match self {
-            Self::Glyph(glyph) => glyph.height(),
-            Self::Variant(variant) => variant.frame.height(),
+            Self::Glyph(glyph) => glyph.size.y,
             Self::Frame(fragment) => fragment.frame.height(),
             _ => Abs::zero(),
         }
@@ -58,17 +66,15 @@ impl MathFragment {
 
     pub fn ascent(&self) -> Abs {
         match self {
-            Self::Glyph(glyph) => glyph.ascent,
-            Self::Variant(variant) => variant.frame.ascent(),
-            Self::Frame(fragment) => fragment.frame.baseline(),
+            Self::Glyph(glyph) => glyph.ascent(),
+            Self::Frame(fragment) => fragment.frame.ascent(),
             _ => Abs::zero(),
         }
     }
 
     pub fn descent(&self) -> Abs {
         match self {
-            Self::Glyph(glyph) => glyph.descent,
-            Self::Variant(variant) => variant.frame.descent(),
+            Self::Glyph(glyph) => glyph.descent(),
             Self::Frame(fragment) => fragment.frame.descent(),
             _ => Abs::zero(),
         }
@@ -85,7 +91,6 @@ impl MathFragment {
     pub fn class(&self) -> MathClass {
         match self {
             Self::Glyph(glyph) => glyph.class,
-            Self::Variant(variant) => variant.class,
             Self::Frame(fragment) => fragment.class,
             Self::Spacing(_, _) => MathClass::Space,
             Self::Space(_) => MathClass::Space,
@@ -98,7 +103,6 @@ impl MathFragment {
     pub fn math_size(&self) -> Option<MathSize> {
         match self {
             Self::Glyph(glyph) => Some(glyph.math_size),
-            Self::Variant(variant) => Some(variant.math_size),
             Self::Frame(fragment) => Some(fragment.math_size),
             _ => None,
         }
@@ -106,8 +110,7 @@ impl MathFragment {
 
     pub fn font_size(&self) -> Option<Abs> {
         match self {
-            Self::Glyph(glyph) => Some(glyph.font_size),
-            Self::Variant(variant) => Some(variant.font_size),
+            Self::Glyph(glyph) => Some(glyph.item.size),
             Self::Frame(fragment) => Some(fragment.font_size),
             _ => None,
         }
@@ -116,7 +119,6 @@ impl MathFragment {
     pub fn set_class(&mut self, class: MathClass) {
         match self {
             Self::Glyph(glyph) => glyph.class = class,
-            Self::Variant(variant) => variant.class = class,
             Self::Frame(fragment) => fragment.class = class,
             _ => {}
         }
@@ -125,7 +127,6 @@ impl MathFragment {
     pub fn set_limits(&mut self, limits: Limits) {
         match self {
             Self::Glyph(glyph) => glyph.limits = limits,
-            Self::Variant(variant) => variant.limits = limits,
             Self::Frame(fragment) => fragment.limits = limits,
             _ => {}
         }
@@ -149,7 +150,6 @@ impl MathFragment {
     pub fn is_text_like(&self) -> bool {
         match self {
             Self::Glyph(glyph) => !glyph.extended_shape,
-            Self::Variant(variant) => !variant.extended_shape,
             MathFragment::Frame(frame) => frame.text_like,
             _ => false,
         }
@@ -158,25 +158,22 @@ impl MathFragment {
     pub fn italics_correction(&self) -> Abs {
         match self {
             Self::Glyph(glyph) => glyph.italics_correction,
-            Self::Variant(variant) => variant.italics_correction,
             Self::Frame(fragment) => fragment.italics_correction,
             _ => Abs::zero(),
         }
     }
 
-    pub fn accent_attach(&self) -> Abs {
+    pub fn accent_attach(&self) -> (Abs, Abs) {
         match self {
             Self::Glyph(glyph) => glyph.accent_attach,
-            Self::Variant(variant) => variant.accent_attach,
             Self::Frame(fragment) => fragment.accent_attach,
-            _ => self.width() / 2.0,
+            _ => (self.width() / 2.0, self.width() / 2.0),
         }
     }
 
     pub fn into_frame(self) -> Frame {
         match self {
             Self::Glyph(glyph) => glyph.into_frame(),
-            Self::Variant(variant) => variant.frame,
             Self::Frame(fragment) => fragment.frame,
             Self::Tag(tag) => {
                 let mut frame = Frame::soft(Size::zero());
@@ -190,7 +187,6 @@ impl MathFragment {
     pub fn limits(&self) -> Limits {
         match self {
             MathFragment::Glyph(glyph) => glyph.limits,
-            MathFragment::Variant(variant) => variant.limits,
             MathFragment::Frame(fragment) => fragment.limits,
             _ => Limits::Never,
         }
@@ -198,11 +194,31 @@ impl MathFragment {
 
     /// If no kern table is provided for a corner, a kerning amount of zero is
     /// assumed.
-    pub fn kern_at_height(&self, ctx: &MathContext, corner: Corner, height: Abs) -> Abs {
+    pub fn kern_at_height(&self, corner: Corner, height: Abs) -> Abs {
         match self {
             Self::Glyph(glyph) => {
-                kern_at_height(ctx, glyph.font_size, glyph.id, corner, height)
-                    .unwrap_or_default()
+                // For glyph assemblies we pick either the start or end glyph
+                // depending on the corner.
+                let is_vertical =
+                    glyph.item.glyphs.iter().all(|glyph| glyph.y_advance != Em::zero());
+                let glyph_index = match (is_vertical, corner) {
+                    (true, Corner::TopLeft | Corner::TopRight) => {
+                        glyph.item.glyphs.len() - 1
+                    }
+                    (false, Corner::TopRight | Corner::BottomRight) => {
+                        glyph.item.glyphs.len() - 1
+                    }
+                    _ => 0,
+                };
+
+                kern_at_height(
+                    &glyph.item.font,
+                    GlyphId(glyph.item.glyphs[glyph_index].id),
+                    corner,
+                    Em::from_length(height, glyph.item.size),
+                )
+                .unwrap_or_default()
+                .at(glyph.item.size)
             }
             _ => Abs::zero(),
         }
@@ -215,12 +231,6 @@ impl From<GlyphFragment> for MathFragment {
     }
 }
 
-impl From<VariantFragment> for MathFragment {
-    fn from(variant: VariantFragment) -> Self {
-        Self::Variant(variant)
-    }
-}
-
 impl From<FrameFragment> for MathFragment {
     fn from(fragment: FrameFragment) -> Self {
         Self::Frame(fragment)
@@ -229,264 +239,282 @@ impl From<FrameFragment> for MathFragment {
 
 #[derive(Clone)]
 pub struct GlyphFragment {
-    pub id: GlyphId,
-    pub c: char,
-    pub font: Font,
-    pub lang: Lang,
-    pub region: Option<Region>,
-    pub fill: Paint,
-    pub shift: Abs,
-    pub width: Abs,
-    pub ascent: Abs,
-    pub descent: Abs,
+    // Text stuff.
+    pub item: TextItem,
+    pub base_glyph: Glyph,
+    // Math stuff.
+    pub size: Size,
+    pub baseline: Option<Abs>,
     pub italics_correction: Abs,
-    pub accent_attach: Abs,
-    pub font_size: Abs,
-    pub class: MathClass,
+    pub accent_attach: (Abs, Abs),
     pub math_size: MathSize,
-    pub span: Span,
-    pub modifiers: FrameModifiers,
+    pub class: MathClass,
     pub limits: Limits,
     pub extended_shape: bool,
+    pub mid_stretched: Option<bool>,
+    // External frame stuff.
+    pub modifiers: FrameModifiers,
+    pub shift: Abs,
+    pub align: Abs,
 }
 
 impl GlyphFragment {
-    pub fn new(ctx: &MathContext, styles: StyleChain, c: char, span: Span) -> Self {
-        let id = ctx.ttf.glyph_index(c).unwrap_or_default();
-        let id = Self::adjust_glyph_index(ctx, id);
-        Self::with_id(ctx, styles, c, id, span)
-    }
-
-    pub fn try_new(
-        ctx: &MathContext,
+    /// Calls `new` with the given character.
+    pub fn new_char(
+        font: &Font,
         styles: StyleChain,
         c: char,
         span: Span,
-    ) -> Option<Self> {
-        let id = ctx.ttf.glyph_index(c)?;
-        let id = Self::adjust_glyph_index(ctx, id);
-        Some(Self::with_id(ctx, styles, c, id, span))
+    ) -> SourceResult<Self> {
+        Self::new(font, styles, c.encode_utf8(&mut [0; 4]), span)
     }
 
-    pub fn with_id(
-        ctx: &MathContext,
+    /// Try to create a new glyph out of the given string. Will bail if the
+    /// result from shaping the string is not a single glyph or is a tofu.
+    #[comemo::memoize]
+    pub fn new(
+        font: &Font,
         styles: StyleChain,
-        c: char,
-        id: GlyphId,
+        text: &str,
         span: Span,
-    ) -> Self {
+    ) -> SourceResult<GlyphFragment> {
+        let mut buffer = UnicodeBuffer::new();
+        buffer.push_str(text);
+        buffer.set_language(language(styles));
+        // TODO: Use `rustybuzz::script::MATH` once
+        // https://github.com/harfbuzz/rustybuzz/pull/165 is released.
+        buffer.set_script(
+            rustybuzz::Script::from_iso15924_tag(ttf_parser::Tag::from_bytes(b"math"))
+                .unwrap(),
+        );
+        buffer.set_direction(rustybuzz::Direction::LeftToRight);
+        buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES);
+
+        let features = features(styles);
+        let plan = create_shape_plan(
+            font,
+            buffer.direction(),
+            buffer.script(),
+            buffer.language().as_ref(),
+            &features,
+        );
+
+        let buffer = rustybuzz::shape_with_plan(font.rusty(), &plan, buffer);
+        if buffer.len() != 1 {
+            bail!(span, "did not get a single glyph after shaping {}", text);
+        }
+
+        let info = buffer.glyph_infos()[0];
+        let pos = buffer.glyph_positions()[0];
+
+        // TODO: add support for coverage and fallback, like in normal text shaping.
+        if info.glyph_id == 0 {
+            bail!(span, "current font is missing a glyph for {}", text);
+        }
+
+        let cluster = info.cluster as usize;
+        let c = text[cluster..].chars().next().unwrap();
+        let limits = Limits::for_char(c);
         let class = EquationElem::class_in(styles)
             .or_else(|| default_math_class(c))
             .unwrap_or(MathClass::Normal);
 
-        let mut fragment = Self {
-            id,
-            c,
-            font: ctx.font.clone(),
+        let glyph = Glyph {
+            id: info.glyph_id as u16,
+            x_advance: font.to_em(pos.x_advance),
+            x_offset: font.to_em(pos.x_offset),
+            y_advance: font.to_em(pos.y_advance),
+            y_offset: font.to_em(pos.y_offset),
+            range: 0..text.len().saturating_as(),
+            span: (span, 0),
+        };
+
+        let item = TextItem {
+            font: font.clone(),
+            size: TextElem::size_in(styles),
+            fill: TextElem::fill_in(styles).as_decoration(),
+            stroke: TextElem::stroke_in(styles).map(|s| s.unwrap_or_default()),
             lang: TextElem::lang_in(styles),
             region: TextElem::region_in(styles),
-            fill: TextElem::fill_in(styles).as_decoration(),
-            shift: TextElem::baseline_in(styles),
-            font_size: TextElem::size_in(styles),
-            math_size: EquationElem::size_in(styles),
-            width: Abs::zero(),
-            ascent: Abs::zero(),
-            descent: Abs::zero(),
-            limits: Limits::for_char(c),
-            italics_correction: Abs::zero(),
-            accent_attach: Abs::zero(),
-            class,
-            span,
-            modifiers: FrameModifiers::get_in(styles),
-            extended_shape: false,
+            text: text.into(),
+            glyphs: vec![glyph.clone()],
         };
-        fragment.set_id(ctx, id);
-        fragment
-    }
 
-    /// Apply GSUB substitutions.
-    fn adjust_glyph_index(ctx: &MathContext, id: GlyphId) -> GlyphId {
-        if let Some(glyphwise_tables) = &ctx.glyphwise_tables {
-            glyphwise_tables.iter().fold(id, |id, table| table.apply(id))
-        } else {
-            id
-        }
+        let mut fragment = Self {
+            item,
+            base_glyph: glyph,
+            // Math
+            math_size: EquationElem::size_in(styles),
+            class,
+            limits,
+            mid_stretched: None,
+            // Math in need of updating.
+            extended_shape: false,
+            italics_correction: Abs::zero(),
+            accent_attach: (Abs::zero(), Abs::zero()),
+            size: Size::zero(),
+            baseline: None,
+            // Misc
+            align: Abs::zero(),
+            shift: TextElem::baseline_in(styles),
+            modifiers: FrameModifiers::get_in(styles),
+        };
+        fragment.update_glyph();
+        Ok(fragment)
     }
 
     /// Sets element id and boxes in appropriate way without changing other
     /// styles. This is used to replace the glyph with a stretch variant.
-    pub fn set_id(&mut self, ctx: &MathContext, id: GlyphId) {
-        let advance = ctx.ttf.glyph_hor_advance(id).unwrap_or_default();
-        let italics = italics_correction(ctx, id, self.font_size).unwrap_or_default();
-        let bbox = ctx.ttf.glyph_bounding_box(id).unwrap_or(Rect {
-            x_min: 0,
-            y_min: 0,
-            x_max: 0,
-            y_max: 0,
-        });
+    pub fn update_glyph(&mut self) {
+        let id = GlyphId(self.item.glyphs[0].id);
 
-        let mut width = advance.scaled(ctx, self.font_size);
-        let accent_attach =
-            accent_attach(ctx, id, self.font_size).unwrap_or((width + italics) / 2.0);
-
-        let extended_shape = is_extended_shape(ctx, id);
+        let extended_shape = is_extended_shape(&self.item.font, id);
+        let italics = italics_correction(&self.item.font, id).unwrap_or_default();
+        let width = self.item.width();
         if !extended_shape {
-            width += italics;
+            self.item.glyphs[0].x_advance += italics;
         }
+        let italics = italics.at(self.item.size);
 
-        self.id = id;
-        self.width = width;
-        self.ascent = bbox.y_max.scaled(ctx, self.font_size);
-        self.descent = -bbox.y_min.scaled(ctx, self.font_size);
+        let (ascent, descent) =
+            ascent_descent(&self.item.font, id).unwrap_or((Em::zero(), Em::zero()));
+
+        // The fallback for accents is half the width plus or minus the italics
+        // correction. This is similar to how top and bottom attachments are
+        // shifted. For bottom accents we do not use the accent attach of the
+        // base as it is meant for top acccents.
+        let top_accent_attach = accent_attach(&self.item.font, id)
+            .map(|x| x.at(self.item.size))
+            .unwrap_or((width + italics) / 2.0);
+        let bottom_accent_attach = (width - italics) / 2.0;
+
+        self.baseline = Some(ascent.at(self.item.size));
+        self.size = Size::new(
+            self.item.width(),
+            ascent.at(self.item.size) + descent.at(self.item.size),
+        );
         self.italics_correction = italics;
-        self.accent_attach = accent_attach;
+        self.accent_attach = (top_accent_attach, bottom_accent_attach);
         self.extended_shape = extended_shape;
     }
 
-    pub fn height(&self) -> Abs {
-        self.ascent + self.descent
+    // Reset a GlyphFragment's text field and math properties back to its
+    // base_id's. This is used to return a glyph to its unstretched state.
+    pub fn reset_glyph(&mut self) {
+        self.align = Abs::zero();
+        self.item.glyphs = vec![self.base_glyph.clone()];
+        self.update_glyph();
     }
 
-    pub fn into_variant(self) -> VariantFragment {
-        VariantFragment {
-            c: self.c,
-            font_size: self.font_size,
-            italics_correction: self.italics_correction,
-            accent_attach: self.accent_attach,
-            class: self.class,
-            math_size: self.math_size,
-            span: self.span,
-            limits: self.limits,
-            extended_shape: self.extended_shape,
-            frame: self.into_frame(),
-            mid_stretched: None,
-        }
+    pub fn baseline(&self) -> Abs {
+        self.ascent()
+    }
+
+    /// The distance from the baseline to the top of the frame.
+    pub fn ascent(&self) -> Abs {
+        self.baseline.unwrap_or(self.size.y)
+    }
+
+    /// The distance from the baseline to the bottom of the frame.
+    pub fn descent(&self) -> Abs {
+        self.size.y - self.ascent()
     }
 
     pub fn into_frame(self) -> Frame {
-        let item = TextItem {
-            font: self.font.clone(),
-            size: self.font_size,
-            fill: self.fill,
-            lang: self.lang,
-            region: self.region,
-            text: self.c.into(),
-            stroke: None,
-            glyphs: vec![Glyph {
-                id: self.id.0,
-                x_advance: Em::from_length(self.width, self.font_size),
-                x_offset: Em::zero(),
-                range: 0..self.c.len_utf8() as u16,
-                span: (self.span, 0),
-            }],
-        };
-        let size = Size::new(self.width, self.ascent + self.descent);
-        let mut frame = Frame::soft(size);
-        frame.set_baseline(self.ascent);
-        frame.push(Point::with_y(self.ascent + self.shift), FrameItem::Text(item));
+        let mut frame = Frame::soft(self.size);
+        frame.set_baseline(self.baseline());
+        frame.push(
+            Point::with_y(self.ascent() + self.shift + self.align),
+            FrameItem::Text(self.item),
+        );
         frame.modify(&self.modifiers);
         frame
     }
 
-    pub fn make_script_size(&mut self, ctx: &MathContext) {
-        let alt_id =
-            ctx.ssty_table.as_ref().and_then(|ssty| ssty.try_apply(self.id, None));
-        if let Some(alt_id) = alt_id {
-            self.set_id(ctx, alt_id);
-        }
-    }
-
-    pub fn make_script_script_size(&mut self, ctx: &MathContext) {
-        let alt_id = ctx.ssty_table.as_ref().and_then(|ssty| {
-            // We explicitly request to apply the alternate set with value 1,
-            // as opposed to the default value in ssty, as the former
-            // corresponds to second level scripts and the latter corresponds
-            // to first level scripts.
-            ssty.try_apply(self.id, Some(1))
-                .or_else(|| ssty.try_apply(self.id, None))
-        });
-        if let Some(alt_id) = alt_id {
-            self.set_id(ctx, alt_id);
-        }
-    }
-
-    pub fn make_dotless_form(&mut self, ctx: &MathContext) {
-        let alt_id =
-            ctx.dtls_table.as_ref().and_then(|dtls| dtls.try_apply(self.id, None));
-        if let Some(alt_id) = alt_id {
-            self.set_id(ctx, alt_id);
-        }
-    }
-
-    pub fn make_flattened_accent_form(&mut self, ctx: &MathContext) {
-        let alt_id =
-            ctx.flac_table.as_ref().and_then(|flac| flac.try_apply(self.id, None));
-        if let Some(alt_id) = alt_id {
-            self.set_id(ctx, alt_id);
-        }
-    }
-
     /// Try to stretch a glyph to a desired height.
-    pub fn stretch_vertical(
-        self,
-        ctx: &mut MathContext,
-        height: Abs,
-        short_fall: Abs,
-    ) -> VariantFragment {
-        stretch_glyph(ctx, self, height, short_fall, Axis::Y)
+    pub fn stretch_vertical(&mut self, ctx: &mut MathContext, height: Abs) {
+        self.stretch(ctx, height, Axis::Y)
     }
 
     /// Try to stretch a glyph to a desired width.
-    pub fn stretch_horizontal(
-        self,
-        ctx: &mut MathContext,
-        width: Abs,
-        short_fall: Abs,
-    ) -> VariantFragment {
-        stretch_glyph(ctx, self, width, short_fall, Axis::X)
+    pub fn stretch_horizontal(&mut self, ctx: &mut MathContext, width: Abs) {
+        self.stretch(ctx, width, Axis::X)
+    }
+
+    /// Try to stretch a glyph to a desired width or height.
+    ///
+    /// The resulting frame may not have the exact desired width or height.
+    pub fn stretch(&mut self, ctx: &mut MathContext, target: Abs, axis: Axis) {
+        self.reset_glyph();
+
+        // If the base glyph is good enough, use it.
+        let mut advance = self.size.get(axis);
+        if axis == Axis::X && !self.extended_shape {
+            // For consistency, we subtract the italics correction from the
+            // glyph's width if it was added in `update_glyph`.
+            advance -= self.italics_correction;
+        }
+        if target <= advance {
+            return;
+        }
+
+        let id = GlyphId(self.item.glyphs[0].id);
+        let font = self.item.font.clone();
+        let Some(construction) = glyph_construction(&font, id, axis) else { return };
+
+        // Search for a pre-made variant with a good advance.
+        let mut best_id = id;
+        let mut best_advance = advance;
+        for variant in construction.variants {
+            best_id = variant.variant_glyph;
+            best_advance =
+                self.item.font.to_em(variant.advance_measurement).at(self.item.size);
+            if target <= best_advance {
+                break;
+            }
+        }
+
+        // This is either good or the best we've got.
+        if target <= best_advance || construction.assembly.is_none() {
+            self.item.glyphs[0].id = best_id.0;
+            self.item.glyphs[0].x_advance =
+                self.item.font.x_advance(best_id.0).unwrap_or_default();
+            self.item.glyphs[0].x_offset = Em::zero();
+            self.item.glyphs[0].y_advance =
+                self.item.font.y_advance(best_id.0).unwrap_or_default();
+            self.item.glyphs[0].y_offset = Em::zero();
+            self.update_glyph();
+            return;
+        }
+
+        // Assemble from parts.
+        let assembly = construction.assembly.unwrap();
+        let min_overlap = min_connector_overlap(&self.item.font)
+            .unwrap_or_default()
+            .at(self.item.size);
+        assemble(ctx, self, assembly, min_overlap, target, axis);
+    }
+
+    /// Vertically adjust the fragment's frame so that it is centered
+    /// on the axis.
+    pub fn center_on_axis(&mut self) {
+        self.align_on_axis(VAlignment::Horizon);
+    }
+
+    /// Vertically adjust the fragment's frame so that it is aligned
+    /// to the given alignment on the axis.
+    pub fn align_on_axis(&mut self, align: VAlignment) {
+        let h = self.size.y;
+        let axis = axis_height(&self.item.font).unwrap().at(self.item.size);
+        self.align += self.baseline();
+        self.baseline = Some(align.inv().position(h + axis * 2.0));
+        self.align -= self.baseline();
     }
 }
 
 impl Debug for GlyphFragment {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "GlyphFragment({:?})", self.c)
-    }
-}
-
-#[derive(Clone)]
-pub struct VariantFragment {
-    pub c: char,
-    pub italics_correction: Abs,
-    pub accent_attach: Abs,
-    pub frame: Frame,
-    pub font_size: Abs,
-    pub class: MathClass,
-    pub math_size: MathSize,
-    pub span: Span,
-    pub limits: Limits,
-    pub mid_stretched: Option<bool>,
-    pub extended_shape: bool,
-}
-
-impl VariantFragment {
-    /// Vertically adjust the fragment's frame so that it is centered
-    /// on the axis.
-    pub fn center_on_axis(&mut self, ctx: &MathContext) {
-        self.align_on_axis(ctx, VAlignment::Horizon)
-    }
-
-    /// Vertically adjust the fragment's frame so that it is aligned
-    /// to the given alignment on the axis.
-    pub fn align_on_axis(&mut self, ctx: &MathContext, align: VAlignment) {
-        let h = self.frame.height();
-        let axis = ctx.constants.axis_height().scaled(ctx, self.font_size);
-        self.frame.set_baseline(align.inv().position(h + axis * 2.0));
-    }
-}
-
-impl Debug for VariantFragment {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "VariantFragment({:?})", self.c)
+        write!(f, "GlyphFragment({:?})", self.item.text)
     }
 }
 
@@ -499,8 +527,9 @@ pub struct FrameFragment {
     pub limits: Limits,
     pub spaced: bool,
     pub base_ascent: Abs,
+    pub base_descent: Abs,
     pub italics_correction: Abs,
-    pub accent_attach: Abs,
+    pub accent_attach: (Abs, Abs),
     pub text_like: bool,
     pub ignorant: bool,
 }
@@ -508,6 +537,7 @@ pub struct FrameFragment {
 impl FrameFragment {
     pub fn new(styles: StyleChain, frame: Frame) -> Self {
         let base_ascent = frame.ascent();
+        let base_descent = frame.descent();
         let accent_attach = frame.width() / 2.0;
         Self {
             frame: frame.modified(&FrameModifiers::get_in(styles)),
@@ -517,8 +547,9 @@ impl FrameFragment {
             limits: Limits::Never,
             spaced: false,
             base_ascent,
+            base_descent,
             italics_correction: Abs::zero(),
-            accent_attach,
+            accent_attach: (accent_attach, accent_attach),
             text_like: false,
             ignorant: false,
         }
@@ -540,11 +571,15 @@ impl FrameFragment {
         Self { base_ascent, ..self }
     }
 
+    pub fn with_base_descent(self, base_descent: Abs) -> Self {
+        Self { base_descent, ..self }
+    }
+
     pub fn with_italics_correction(self, italics_correction: Abs) -> Self {
         Self { italics_correction, ..self }
     }
 
-    pub fn with_accent_attach(self, accent_attach: Abs) -> Self {
+    pub fn with_accent_attach(self, accent_attach: (Abs, Abs)) -> Self {
         Self { accent_attach, ..self }
     }
 
@@ -557,46 +592,47 @@ impl FrameFragment {
     }
 }
 
+fn ascent_descent(font: &Font, id: GlyphId) -> Option<(Em, Em)> {
+    let bbox = font.ttf().glyph_bounding_box(id)?;
+    Some((font.to_em(bbox.y_max), -font.to_em(bbox.y_min)))
+}
+
 /// Look up the italics correction for a glyph.
-fn italics_correction(ctx: &MathContext, id: GlyphId, font_size: Abs) -> Option<Abs> {
-    Some(
-        ctx.table
-            .glyph_info?
-            .italic_corrections?
-            .get(id)?
-            .scaled(ctx, font_size),
-    )
+fn italics_correction(font: &Font, id: GlyphId) -> Option<Em> {
+    font.ttf()
+        .tables()
+        .math?
+        .glyph_info?
+        .italic_corrections?
+        .get(id)
+        .map(|value| font.to_em(value.value))
 }
 
 /// Loop up the top accent attachment position for a glyph.
-fn accent_attach(ctx: &MathContext, id: GlyphId, font_size: Abs) -> Option<Abs> {
-    Some(
-        ctx.table
-            .glyph_info?
-            .top_accent_attachments?
-            .get(id)?
-            .scaled(ctx, font_size),
-    )
+fn accent_attach(font: &Font, id: GlyphId) -> Option<Em> {
+    font.ttf()
+        .tables()
+        .math?
+        .glyph_info?
+        .top_accent_attachments?
+        .get(id)
+        .map(|value| font.to_em(value.value))
 }
 
 /// Look up whether a glyph is an extended shape.
-fn is_extended_shape(ctx: &MathContext, id: GlyphId) -> bool {
-    ctx.table
-        .glyph_info
-        .and_then(|info| info.extended_shapes)
-        .and_then(|info| info.get(id))
+fn is_extended_shape(font: &Font, id: GlyphId) -> bool {
+    font.ttf()
+        .tables()
+        .math
+        .and_then(|math| math.glyph_info)
+        .and_then(|glyph_info| glyph_info.extended_shapes)
+        .and_then(|coverage| coverage.get(id))
         .is_some()
 }
 
 /// Look up a kerning value at a specific corner and height.
-fn kern_at_height(
-    ctx: &MathContext,
-    font_size: Abs,
-    id: GlyphId,
-    corner: Corner,
-    height: Abs,
-) -> Option<Abs> {
-    let kerns = ctx.table.glyph_info?.kern_infos?.get(id)?;
+fn kern_at_height(font: &Font, id: GlyphId, corner: Corner, height: Em) -> Option<Em> {
+    let kerns = font.ttf().tables().math?.glyph_info?.kern_infos?.get(id)?;
     let kern = match corner {
         Corner::TopLeft => kerns.top_left,
         Corner::TopRight => kerns.top_right,
@@ -605,11 +641,187 @@ fn kern_at_height(
     }?;
 
     let mut i = 0;
-    while i < kern.count() && height > kern.height(i)?.scaled(ctx, font_size) {
+    while i < kern.count() && height > font.to_em(kern.height(i)?.value) {
         i += 1;
     }
 
-    Some(kern.kern(i)?.scaled(ctx, font_size))
+    Some(font.to_em(kern.kern(i)?.value))
+}
+
+fn axis_height(font: &Font) -> Option<Em> {
+    Some(font.to_em(font.ttf().tables().math?.constants?.axis_height().value))
+}
+
+pub fn stretch_axes(font: &Font, id: u16) -> Axes<bool> {
+    let id = GlyphId(id);
+    let horizontal = font
+        .ttf()
+        .tables()
+        .math
+        .and_then(|math| math.variants)
+        .and_then(|variants| variants.horizontal_constructions.get(id))
+        .is_some();
+    let vertical = font
+        .ttf()
+        .tables()
+        .math
+        .and_then(|math| math.variants)
+        .and_then(|variants| variants.vertical_constructions.get(id))
+        .is_some();
+
+    Axes::new(horizontal, vertical)
+}
+
+fn min_connector_overlap(font: &Font) -> Option<Em> {
+    font.ttf()
+        .tables()
+        .math?
+        .variants
+        .map(|variants| font.to_em(variants.min_connector_overlap))
+}
+
+fn glyph_construction(font: &Font, id: GlyphId, axis: Axis) -> Option<GlyphConstruction> {
+    font.ttf()
+        .tables()
+        .math?
+        .variants
+        .map(|variants| match axis {
+            Axis::X => variants.horizontal_constructions,
+            Axis::Y => variants.vertical_constructions,
+        })?
+        .get(id)
+}
+
+/// Assemble a glyph from parts.
+fn assemble(
+    ctx: &mut MathContext,
+    base: &mut GlyphFragment,
+    assembly: GlyphAssembly,
+    min_overlap: Abs,
+    target: Abs,
+    axis: Axis,
+) {
+    // Determine the number of times the extenders need to be repeated as well
+    // as a ratio specifying how much to spread the parts apart
+    // (0 = maximal overlap, 1 = minimal overlap).
+    let mut full;
+    let mut ratio;
+    let mut repeat = 0;
+    loop {
+        full = Abs::zero();
+        ratio = 0.0;
+
+        let mut parts = parts(assembly, repeat).peekable();
+        let mut growable = Abs::zero();
+
+        while let Some(part) = parts.next() {
+            let mut advance = base.item.font.to_em(part.full_advance).at(base.item.size);
+            if let Some(next) = parts.peek() {
+                let max_overlap = base
+                    .item
+                    .font
+                    .to_em(part.end_connector_length.min(next.start_connector_length))
+                    .at(base.item.size);
+                if max_overlap < min_overlap {
+                    // This condition happening is indicative of a bug in the
+                    // font.
+                    ctx.engine.sink.warn(warning!(
+                       base.item.glyphs[0].span.0,
+                       "glyph has assembly parts with overlap less than minConnectorOverlap";
+                       hint: "its rendering may appear broken - this is probably a font bug";
+                       hint: "please file an issue at https://github.com/typst/typst/issues"
+                    ));
+                }
+
+                advance -= max_overlap;
+                growable += max_overlap - min_overlap;
+            }
+
+            full += advance;
+        }
+
+        if full < target {
+            let delta = target - full;
+            ratio = (delta / growable).min(1.0);
+            full += ratio * growable;
+        }
+
+        if target <= full || repeat >= MAX_REPEATS {
+            break;
+        }
+
+        repeat += 1;
+    }
+
+    let mut glyphs = vec![];
+    let mut parts = parts(assembly, repeat).peekable();
+    while let Some(part) = parts.next() {
+        let mut advance = base.item.font.to_em(part.full_advance).at(base.item.size);
+        if let Some(next) = parts.peek() {
+            let max_overlap = base
+                .item
+                .font
+                .to_em(part.end_connector_length.min(next.start_connector_length))
+                .at(base.item.size);
+            advance -= max_overlap;
+            advance += ratio * (max_overlap - min_overlap);
+        }
+        let (x, y) = match axis {
+            Axis::X => (Em::from_length(advance, base.item.size), Em::zero()),
+            Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
+        };
+        glyphs.push(Glyph {
+            id: part.glyph_id.0,
+            x_advance: x,
+            x_offset: Em::zero(),
+            y_advance: y,
+            y_offset: Em::zero(),
+            ..base.item.glyphs[0].clone()
+        });
+    }
+
+    match axis {
+        Axis::X => base.size.x = full,
+        Axis::Y => {
+            base.baseline = None;
+            base.size.y = full;
+            base.size.x = glyphs
+                .iter()
+                .map(|glyph| base.item.font.x_advance(glyph.id).unwrap_or_default())
+                .max()
+                .unwrap_or_default()
+                .at(base.item.size);
+        }
+    }
+
+    base.item.glyphs = glyphs;
+    base.italics_correction = base
+        .item
+        .font
+        .to_em(assembly.italics_correction.value)
+        .at(base.item.size);
+    if axis == Axis::X {
+        base.accent_attach = (full / 2.0, full / 2.0);
+    }
+    base.mid_stretched = None;
+    base.extended_shape = true;
+}
+
+/// Return an iterator over the assembly's parts with extenders repeated the
+/// specified number of times.
+fn parts(assembly: GlyphAssembly, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
+    assembly.parts.into_iter().flat_map(move |part| {
+        let count = if part.part_flags.extender() { repeat } else { 1 };
+        std::iter::repeat_n(part, count)
+    })
+}
+
+pub fn has_dtls_feat(font: &Font) -> bool {
+    font.ttf()
+        .tables()
+        .gsub
+        .and_then(|gsub| gsub.features.index(ttf_parser::Tag::from_bytes(b"dtls")))
+        .is_some()
 }
 
 /// Describes in which situation a frame should use limits for attachments.
@@ -662,56 +874,3 @@ impl Limits {
 fn is_integral_char(c: char) -> bool {
     ('∫'..='∳').contains(&c) || ('⨋'..='⨜').contains(&c)
 }
-
-/// An OpenType substitution table that is applicable to glyph-wise substitutions.
-pub enum GlyphwiseSubsts<'a> {
-    Single(SingleSubstitution<'a>),
-    Alternate(AlternateSubstitution<'a>, u32),
-}
-
-impl<'a> GlyphwiseSubsts<'a> {
-    pub fn new(gsub: Option<LayoutTable<'a>>, feature: Feature) -> Option<Self> {
-        let gsub = gsub?;
-        let table = gsub
-            .features
-            .find(feature.tag)
-            .and_then(|feature| feature.lookup_indices.get(0))
-            .and_then(|index| gsub.lookups.get(index))?;
-        let table = table.subtables.get::<SubstitutionSubtable>(0)?;
-        match table {
-            SubstitutionSubtable::Single(single_glyphs) => {
-                Some(Self::Single(single_glyphs))
-            }
-            SubstitutionSubtable::Alternate(alt_glyphs) => {
-                Some(Self::Alternate(alt_glyphs, feature.value))
-            }
-            _ => None,
-        }
-    }
-
-    pub fn try_apply(
-        &self,
-        glyph_id: GlyphId,
-        alt_value: Option<u32>,
-    ) -> Option<GlyphId> {
-        match self {
-            Self::Single(single) => match single {
-                SingleSubstitution::Format1 { coverage, delta } => coverage
-                    .get(glyph_id)
-                    .map(|_| GlyphId(glyph_id.0.wrapping_add(*delta as u16))),
-                SingleSubstitution::Format2 { coverage, substitutes } => {
-                    coverage.get(glyph_id).and_then(|idx| substitutes.get(idx))
-                }
-            },
-            Self::Alternate(alternate, value) => alternate
-                .coverage
-                .get(glyph_id)
-                .and_then(|idx| alternate.alternate_sets.get(idx))
-                .and_then(|set| set.alternates.get(alt_value.unwrap_or(*value) as u16)),
-        }
-    }
-
-    pub fn apply(&self, glyph_id: GlyphId) -> GlyphId {
-        self.try_apply(glyph_id, None).unwrap_or(glyph_id)
-    }
-}
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
index bf8235411..a3b5cb05c 100644
--- a/crates/typst-layout/src/math/lr.rs
+++ b/crates/typst-layout/src/math/lr.rs
@@ -45,20 +45,20 @@ pub fn layout_lr(
 
     // Scale up fragments at both ends.
     match inner_fragments {
-        [one] => scale(ctx, styles, one, relative_to, height, None),
+        [one] => scale_if_delimiter(ctx, one, relative_to, height, None),
         [first, .., last] => {
-            scale(ctx, styles, first, relative_to, height, Some(MathClass::Opening));
-            scale(ctx, styles, last, relative_to, height, Some(MathClass::Closing));
+            scale_if_delimiter(ctx, first, relative_to, height, Some(MathClass::Opening));
+            scale_if_delimiter(ctx, last, relative_to, height, Some(MathClass::Closing));
         }
-        _ => {}
+        [] => {}
     }
 
-    // Handle MathFragment::Variant fragments that should be scaled up.
+    // Handle MathFragment::Glyph fragments that should be scaled up.
     for fragment in inner_fragments.iter_mut() {
-        if let MathFragment::Variant(ref mut variant) = fragment {
-            if variant.mid_stretched == Some(false) {
-                variant.mid_stretched = Some(true);
-                scale(ctx, styles, fragment, relative_to, height, Some(MathClass::Large));
+        if let MathFragment::Glyph(ref mut glyph) = fragment {
+            if glyph.mid_stretched == Some(false) {
+                glyph.mid_stretched = Some(true);
+                scale(ctx, fragment, relative_to, height);
             }
         }
     }
@@ -95,18 +95,9 @@ pub fn layout_mid(
     let mut fragments = ctx.layout_into_fragments(&elem.body, styles)?;
 
     for fragment in &mut fragments {
-        match fragment {
-            MathFragment::Glyph(glyph) => {
-                let mut new = glyph.clone().into_variant();
-                new.mid_stretched = Some(false);
-                new.class = MathClass::Fence;
-                *fragment = MathFragment::Variant(new);
-            }
-            MathFragment::Variant(variant) => {
-                variant.mid_stretched = Some(false);
-                variant.class = MathClass::Fence;
-            }
-            _ => {}
+        if let MathFragment::Glyph(ref mut glyph) = fragment {
+            glyph.mid_stretched = Some(false);
+            glyph.class = MathClass::Relation;
         }
     }
 
@@ -114,10 +105,13 @@ pub fn layout_mid(
     Ok(())
 }
 
-/// Scale a math fragment to a height.
-fn scale(
+/// Scales a math fragment to a height if it has the class Opening, Closing, or
+/// Fence.
+///
+/// In case `apply` is `Some(class)`, `class` will be applied to the fragment if
+/// it is a delimiter, in a way that cannot be overridden by the user.
+fn scale_if_delimiter(
     ctx: &mut MathContext,
-    styles: StyleChain,
     fragment: &mut MathFragment,
     relative_to: Abs,
     height: Rel<Abs>,
@@ -127,21 +121,23 @@ fn scale(
         fragment.class(),
         MathClass::Opening | MathClass::Closing | MathClass::Fence
     ) {
-        // This unwrap doesn't really matter. If it is None, then the fragment
-        // won't be stretchable anyways.
-        let short_fall = DELIM_SHORT_FALL.at(fragment.font_size().unwrap_or_default());
-        stretch_fragment(
-            ctx,
-            styles,
-            fragment,
-            Some(Axis::Y),
-            Some(relative_to),
-            height,
-            short_fall,
-        );
+        scale(ctx, fragment, relative_to, height);
 
         if let Some(class) = apply {
             fragment.set_class(class);
         }
     }
 }
+
+/// Scales a math fragment to a height.
+fn scale(
+    ctx: &mut MathContext,
+    fragment: &mut MathFragment,
+    relative_to: Abs,
+    height: Rel<Abs>,
+) {
+    // This unwrap doesn't really matter. If it is None, then the fragment
+    // won't be stretchable anyways.
+    let short_fall = DELIM_SHORT_FALL.at(fragment.font_size().unwrap_or_default());
+    stretch_fragment(ctx, fragment, Some(Axis::Y), Some(relative_to), height, short_fall);
+}
diff --git a/crates/typst-layout/src/math/mat.rs b/crates/typst-layout/src/math/mat.rs
index bf4929026..278b1343e 100644
--- a/crates/typst-layout/src/math/mat.rs
+++ b/crates/typst-layout/src/math/mat.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{bail, warning, SourceResult};
 use typst_library::foundations::{Content, Packed, Resolve, StyleChain};
 use typst_library::layout::{
     Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Point, Ratio, Rel, Size,
@@ -9,8 +9,8 @@ use typst_library::visualize::{FillRule, FixedStroke, Geometry, LineCap, Shape};
 use typst_syntax::Span;
 
 use super::{
-    alignments, delimiter_alignment, stack, style_for_denominator, AlignmentResult,
-    FrameFragment, GlyphFragment, LeftRightAlternator, MathContext, DELIM_SHORT_FALL,
+    alignments, style_for_denominator, AlignmentResult, FrameFragment, GlyphFragment,
+    LeftRightAlternator, MathContext, DELIM_SHORT_FALL,
 };
 
 const VERTICAL_PADDING: Ratio = Ratio::new(0.1);
@@ -23,67 +23,23 @@ pub fn layout_vec(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let delim = elem.delim(styles);
-    let frame = layout_vec_body(
+    let span = elem.span();
+
+    let column: Vec<&Content> = elem.children.iter().collect();
+    let frame = layout_body(
         ctx,
         styles,
-        &elem.children,
+        &[column],
         elem.align(styles),
-        elem.gap(styles),
         LeftRightAlternator::Right,
+        None,
+        Axes::with_y(elem.gap(styles)),
+        span,
+        "elements",
     )?;
 
-    layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), elem.span())
-}
-
-/// Lays out a [`MatElem`].
-#[typst_macros::time(name = "math.mat", span = elem.span())]
-pub fn layout_mat(
-    elem: &Packed<MatElem>,
-    ctx: &mut MathContext,
-    styles: StyleChain,
-) -> SourceResult<()> {
-    let augment = elem.augment(styles);
-    let rows = &elem.rows;
-
-    if let Some(aug) = &augment {
-        for &offset in &aug.hline.0 {
-            if offset == 0 || offset.unsigned_abs() >= rows.len() {
-                bail!(
-                    elem.span(),
-                    "cannot draw a horizontal line after row {} of a matrix with {} rows",
-                    if offset < 0 { rows.len() as isize + offset } else { offset },
-                    rows.len()
-                );
-            }
-        }
-
-        let ncols = rows.first().map_or(0, |row| row.len());
-
-        for &offset in &aug.vline.0 {
-            if offset == 0 || offset.unsigned_abs() >= ncols {
-                bail!(
-                        elem.span(),
-                        "cannot draw a vertical line after column {} of a matrix with {} columns",
-                        if offset < 0 { ncols as isize + offset } else { offset },
-                        ncols
-                    );
-            }
-        }
-    }
-
     let delim = elem.delim(styles);
-    let frame = layout_mat_body(
-        ctx,
-        styles,
-        rows,
-        elem.align(styles),
-        augment,
-        Axes::new(elem.column_gap(styles), elem.row_gap(styles)),
-        elem.span(),
-    )?;
-
-    layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), elem.span())
+    layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
 }
 
 /// Lays out a [`CasesElem`].
@@ -93,60 +49,100 @@ pub fn layout_cases(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let delim = elem.delim(styles);
-    let frame = layout_vec_body(
+    let span = elem.span();
+
+    let column: Vec<&Content> = elem.children.iter().collect();
+    let frame = layout_body(
         ctx,
         styles,
-        &elem.children,
+        &[column],
         FixedAlignment::Start,
-        elem.gap(styles),
         LeftRightAlternator::None,
+        None,
+        Axes::with_y(elem.gap(styles)),
+        span,
+        "branches",
     )?;
 
+    let delim = elem.delim(styles);
     let (open, close) =
         if elem.reverse(styles) { (None, delim.close()) } else { (delim.open(), None) };
-
-    layout_delimiters(ctx, styles, frame, open, close, elem.span())
+    layout_delimiters(ctx, styles, frame, open, close, span)
 }
 
-/// Layout the inner contents of a vector.
-fn layout_vec_body(
+/// Lays out a [`MatElem`].
+#[typst_macros::time(name = "math.mat", span = elem.span())]
+pub fn layout_mat(
+    elem: &Packed<MatElem>,
     ctx: &mut MathContext,
     styles: StyleChain,
-    column: &[Content],
-    align: FixedAlignment,
-    row_gap: Rel<Abs>,
-    alternator: LeftRightAlternator,
-) -> SourceResult<Frame> {
-    let gap = row_gap.relative_to(ctx.region.size.y);
+) -> SourceResult<()> {
+    let span = elem.span();
+    let rows = &elem.rows;
+    let ncols = rows.first().map_or(0, |row| row.len());
 
-    let denom_style = style_for_denominator(styles);
-    let mut flat = vec![];
-    for child in column {
-        // We allow linebreaks in cases and vectors, which are functionally
-        // identical to commas.
-        flat.extend(ctx.layout_into_run(child, styles.chain(&denom_style))?.rows());
+    let augment = elem.augment(styles);
+    if let Some(aug) = &augment {
+        for &offset in &aug.hline.0 {
+            if offset == 0 || offset.unsigned_abs() >= rows.len() {
+                bail!(
+                    span,
+                    "cannot draw a horizontal line after row {} of a matrix with {} rows",
+                    if offset < 0 { rows.len() as isize + offset } else { offset },
+                    rows.len()
+                );
+            }
+        }
+
+        for &offset in &aug.vline.0 {
+            if offset == 0 || offset.unsigned_abs() >= ncols {
+                bail!(
+                    span,
+                    "cannot draw a vertical line after column {} of a matrix with {} columns",
+                    if offset < 0 { ncols as isize + offset } else { offset },
+                    ncols
+                );
+            }
+        }
     }
-    // We pad ascent and descent with the ascent and descent of the paren
-    // to ensure that normal vectors are aligned with others unless they are
-    // way too big.
-    let paren =
-        GlyphFragment::new(ctx, styles.chain(&denom_style), '(', Span::detached());
-    Ok(stack(flat, align, gap, 0, alternator, Some((paren.ascent, paren.descent))))
+
+    // Transpose rows of the matrix into columns.
+    let mut row_iters: Vec<_> = rows.iter().map(|i| i.iter()).collect();
+    let columns: Vec<Vec<_>> = (0..ncols)
+        .map(|_| row_iters.iter_mut().map(|i| i.next().unwrap()).collect())
+        .collect();
+
+    let frame = layout_body(
+        ctx,
+        styles,
+        &columns,
+        elem.align(styles),
+        LeftRightAlternator::Right,
+        augment,
+        Axes::new(elem.column_gap(styles), elem.row_gap(styles)),
+        span,
+        "cells",
+    )?;
+
+    let delim = elem.delim(styles);
+    layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
 }
 
-/// Layout the inner contents of a matrix.
-fn layout_mat_body(
+/// Layout the inner contents of a matrix, vector, or cases.
+#[allow(clippy::too_many_arguments)]
+fn layout_body(
     ctx: &mut MathContext,
     styles: StyleChain,
-    rows: &[Vec<Content>],
+    columns: &[Vec<&Content>],
     align: FixedAlignment,
+    alternator: LeftRightAlternator,
     augment: Option<Augment<Abs>>,
     gap: Axes<Rel<Abs>>,
     span: Span,
+    children: &str,
 ) -> SourceResult<Frame> {
-    let ncols = rows.first().map_or(0, |row| row.len());
-    let nrows = rows.len();
+    let nrows = columns.first().map_or(0, |col| col.len());
+    let ncols = columns.len();
     if ncols == 0 || nrows == 0 {
         return Ok(Frame::soft(Size::zero()));
     }
@@ -178,29 +174,40 @@ fn layout_mat_body(
     // Before the full matrix body can be laid out, the
     // individual cells must first be independently laid out
     // so we can ensure alignment across rows and columns.
+    let mut cols = vec![vec![]; ncols];
 
     // This variable stores the maximum ascent and descent for each row.
     let mut heights = vec![(Abs::zero(), Abs::zero()); nrows];
 
-    // We want to transpose our data layout to columns
-    // before final layout. For efficiency, the columns
-    // variable is set up here and newly generated
-    // individual cells are then added to it.
-    let mut cols = vec![vec![]; ncols];
-
     let denom_style = style_for_denominator(styles);
     // We pad ascent and descent with the ascent and descent of the paren
     // to ensure that normal matrices are aligned with others unless they are
     // way too big.
-    let paren =
-        GlyphFragment::new(ctx, styles.chain(&denom_style), '(', Span::detached());
+    let paren = GlyphFragment::new_char(
+        ctx.font,
+        styles.chain(&denom_style),
+        '(',
+        Span::detached(),
+    )?;
 
-    for (row, (ascent, descent)) in rows.iter().zip(&mut heights) {
-        for (cell, col) in row.iter().zip(&mut cols) {
+    for (column, col) in columns.iter().zip(&mut cols) {
+        for (cell, (ascent, descent)) in column.iter().zip(&mut heights) {
+            let cell_span = cell.span();
             let cell = ctx.layout_into_run(cell, styles.chain(&denom_style))?;
 
-            ascent.set_max(cell.ascent().max(paren.ascent));
-            descent.set_max(cell.descent().max(paren.descent));
+            // We ignore linebreaks in the cells as we can't differentiate
+            // alignment points for the whole body from ones for a specific
+            // cell, and multiline cells don't quite make sense at the moment.
+            if cell.is_multiline() {
+                ctx.engine.sink.warn(warning!(
+                   cell_span,
+                   "linebreaks are ignored in {}", children;
+                   hint: "use commas instead to separate each line"
+                ));
+            }
+
+            ascent.set_max(cell.ascent().max(paren.ascent()));
+            descent.set_max(cell.descent().max(paren.descent()));
 
             col.push(cell);
         }
@@ -222,7 +229,7 @@ fn layout_mat_body(
         let mut y = Abs::zero();
 
         for (cell, &(ascent, descent)) in col.into_iter().zip(&heights) {
-            let cell = cell.into_line_frame(&points, LeftRightAlternator::Right);
+            let cell = cell.into_line_frame(&points, alternator);
             let pos = Point::new(
                 if points.is_empty() {
                     x + align.position(rcol - cell.width())
@@ -309,19 +316,19 @@ fn layout_delimiters(
     let target = height + VERTICAL_PADDING.of(height);
     frame.set_baseline(height / 2.0 + axis);
 
-    if let Some(left) = left {
-        let mut left = GlyphFragment::new(ctx, styles, left, span)
-            .stretch_vertical(ctx, target, short_fall);
-        left.align_on_axis(ctx, delimiter_alignment(left.c));
+    if let Some(left_c) = left {
+        let mut left = GlyphFragment::new_char(ctx.font, styles, left_c, span)?;
+        left.stretch_vertical(ctx, target - short_fall);
+        left.center_on_axis();
         ctx.push(left);
     }
 
     ctx.push(FrameFragment::new(styles, frame));
 
-    if let Some(right) = right {
-        let mut right = GlyphFragment::new(ctx, styles, right, span)
-            .stretch_vertical(ctx, target, short_fall);
-        right.align_on_axis(ctx, delimiter_alignment(right.c));
+    if let Some(right_c) = right {
+        let mut right = GlyphFragment::new_char(ctx.font, styles, right_c, span)?;
+        right.stretch_vertical(ctx, target - short_fall);
+        right.center_on_axis();
         ctx.push(right);
     }
 
diff --git a/crates/typst-layout/src/math/mod.rs b/crates/typst-layout/src/math/mod.rs
index 708a4443d..5fd22e578 100644
--- a/crates/typst-layout/src/math/mod.rs
+++ b/crates/typst-layout/src/math/mod.rs
@@ -13,8 +13,6 @@ mod stretch;
 mod text;
 mod underover;
 
-use rustybuzz::Feature;
-use ttf_parser::Tag;
 use typst_library::diag::{bail, SourceResult};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
@@ -30,7 +28,7 @@ use typst_library::math::*;
 use typst_library::model::ParElem;
 use typst_library::routines::{Arenas, RealizationKind};
 use typst_library::text::{
-    families, features, variant, Font, LinebreakElem, SpaceElem, TextEdgeBounds, TextElem,
+    families, variant, Font, LinebreakElem, SpaceElem, TextEdgeBounds, TextElem,
 };
 use typst_library::World;
 use typst_syntax::Span;
@@ -38,11 +36,11 @@ use typst_utils::Numeric;
 use unicode_math_class::MathClass;
 
 use self::fragment::{
-    FrameFragment, GlyphFragment, GlyphwiseSubsts, Limits, MathFragment, VariantFragment,
+    has_dtls_feat, stretch_axes, FrameFragment, GlyphFragment, Limits, MathFragment,
 };
 use self::run::{LeftRightAlternator, MathRun, MathRunFrameBuilder};
 use self::shared::*;
-use self::stretch::{stretch_fragment, stretch_glyph};
+use self::stretch::stretch_fragment;
 
 /// Layout an inline equation (in a paragraph).
 #[typst_macros::time(span = elem.span())]
@@ -58,7 +56,7 @@ pub fn layout_equation_inline(
     let font = find_math_font(engine, styles, elem.span())?;
 
     let mut locator = locator.split();
-    let mut ctx = MathContext::new(engine, &mut locator, styles, region, &font);
+    let mut ctx = MathContext::new(engine, &mut locator, region, &font);
 
     let scale_style = style_for_script_scale(&ctx);
     let styles = styles.chain(&scale_style);
@@ -113,7 +111,7 @@ pub fn layout_equation_block(
     let font = find_math_font(engine, styles, span)?;
 
     let mut locator = locator.split();
-    let mut ctx = MathContext::new(engine, &mut locator, styles, regions.base(), &font);
+    let mut ctx = MathContext::new(engine, &mut locator, regions.base(), &font);
 
     let scale_style = style_for_script_scale(&ctx);
     let styles = styles.chain(&scale_style);
@@ -374,14 +372,7 @@ struct MathContext<'a, 'v, 'e> {
     region: Region,
     // Font-related.
     font: &'a Font,
-    ttf: &'a ttf_parser::Face<'a>,
-    table: ttf_parser::math::Table<'a>,
     constants: ttf_parser::math::Constants<'a>,
-    dtls_table: Option<GlyphwiseSubsts<'a>>,
-    flac_table: Option<GlyphwiseSubsts<'a>>,
-    ssty_table: Option<GlyphwiseSubsts<'a>>,
-    glyphwise_tables: Option<Vec<GlyphwiseSubsts<'a>>>,
-    space_width: Em,
     // Mutable.
     fragments: Vec<MathFragment>,
 }
@@ -391,46 +382,20 @@ impl<'a, 'v, 'e> MathContext<'a, 'v, 'e> {
     fn new(
         engine: &'v mut Engine<'e>,
         locator: &'v mut SplitLocator<'a>,
-        styles: StyleChain<'a>,
         base: Size,
         font: &'a Font,
     ) -> Self {
-        let math_table = font.ttf().tables().math.unwrap();
-        let gsub_table = font.ttf().tables().gsub;
-        let constants = math_table.constants.unwrap();
-
-        let feat = |tag: &[u8; 4]| {
-            GlyphwiseSubsts::new(gsub_table, Feature::new(Tag::from_bytes(tag), 0, ..))
-        };
-
-        let features = features(styles);
-        let glyphwise_tables = Some(
-            features
-                .into_iter()
-                .filter_map(|feature| GlyphwiseSubsts::new(gsub_table, feature))
-                .collect(),
-        );
-
-        let ttf = font.ttf();
-        let space_width = ttf
-            .glyph_index(' ')
-            .and_then(|id| ttf.glyph_hor_advance(id))
-            .map(|advance| font.to_em(advance))
-            .unwrap_or(THICK);
+        // These unwraps are safe as the font given is one returned by the
+        // find_math_font function, which only returns fonts that have a math
+        // constants table.
+        let constants = font.ttf().tables().math.unwrap().constants.unwrap();
 
         Self {
             engine,
             locator,
             region: Region::new(base, Axes::splat(false)),
             font,
-            ttf,
-            table: math_table,
             constants,
-            dtls_table: feat(b"dtls"),
-            flac_table: feat(b"flac"),
-            ssty_table: feat(b"ssty"),
-            glyphwise_tables,
-            space_width,
             fragments: vec![],
         }
     }
@@ -529,7 +494,8 @@ fn layout_realized(
     if let Some(elem) = elem.to_packed::<TagElem>() {
         ctx.push(MathFragment::Tag(elem.tag.clone()));
     } else if elem.is::<SpaceElem>() {
-        ctx.push(MathFragment::Space(ctx.space_width.resolve(styles)));
+        let space_width = ctx.font.space_width().unwrap_or(THICK);
+        ctx.push(MathFragment::Space(space_width.resolve(styles)));
     } else if elem.is::<LinebreakElem>() {
         ctx.push(MathFragment::Linebreak);
     } else if let Some(elem) = elem.to_packed::<HElem>() {
diff --git a/crates/typst-layout/src/math/root.rs b/crates/typst-layout/src/math/root.rs
index c7f41488e..91b9b16af 100644
--- a/crates/typst-layout/src/math/root.rs
+++ b/crates/typst-layout/src/math/root.rs
@@ -49,9 +49,9 @@ pub fn layout_root(
 
     // Layout root symbol.
     let target = radicand.height() + thickness + gap;
-    let sqrt = GlyphFragment::new(ctx, styles, '√', span)
-        .stretch_vertical(ctx, target, Abs::zero())
-        .frame;
+    let mut sqrt = GlyphFragment::new_char(ctx.font, styles, '√', span)?;
+    sqrt.stretch_vertical(ctx, target);
+    let sqrt = sqrt.into_frame();
 
     // Layout the index.
     let sscript = EquationElem::set_size(MathSize::ScriptScript).wrap();
diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
index ae64368d6..4ec76c253 100644
--- a/crates/typst-layout/src/math/run.rs
+++ b/crates/typst-layout/src/math/run.rs
@@ -278,6 +278,9 @@ impl MathRun {
         frame
     }
 
+    /// Convert this run of math fragments into a vector of inline items for
+    /// paragraph layout. Creates multiple fragments when relation or binary
+    /// operators are present to allow for line-breaking opportunities later.
     pub fn into_par_items(self) -> Vec<InlineItem> {
         let mut items = vec![];
 
@@ -295,21 +298,24 @@ impl MathRun {
 
         let mut space_is_visible = false;
 
-        let is_relation = |f: &MathFragment| matches!(f.class(), MathClass::Relation);
         let is_space = |f: &MathFragment| {
             matches!(f, MathFragment::Space(_) | MathFragment::Spacing(_, _))
         };
+        let is_line_break_opportunity = |class, next_fragment| match class {
+            // Don't split when two relations are in a row or when preceding a
+            // closing parenthesis.
+            MathClass::Binary => next_fragment != Some(MathClass::Closing),
+            MathClass::Relation => {
+                !matches!(next_fragment, Some(MathClass::Relation | MathClass::Closing))
+            }
+            _ => false,
+        };
 
         let mut iter = self.0.into_iter().peekable();
         while let Some(fragment) = iter.next() {
-            if space_is_visible {
-                match fragment {
-                    MathFragment::Space(width) | MathFragment::Spacing(width, _) => {
-                        items.push(InlineItem::Space(width, true));
-                        continue;
-                    }
-                    _ => {}
-                }
+            if space_is_visible && is_space(&fragment) {
+                items.push(InlineItem::Space(fragment.width(), true));
+                continue;
             }
 
             let class = fragment.class();
@@ -323,10 +329,9 @@ impl MathRun {
             frame.push_frame(pos, fragment.into_frame());
             empty = false;
 
-            if class == MathClass::Binary
-                || (class == MathClass::Relation
-                    && !iter.peek().map(is_relation).unwrap_or_default())
-            {
+            // Split our current frame when we encounter a binary operator or
+            // relation so that there is a line-breaking opportunity.
+            if is_line_break_opportunity(class, iter.peek().map(|f| f.class())) {
                 let mut frame_prev =
                     std::mem::replace(&mut frame, Frame::soft(Size::zero()));
 
diff --git a/crates/typst-layout/src/math/shared.rs b/crates/typst-layout/src/math/shared.rs
index 5aebdacac..1f88d2dd7 100644
--- a/crates/typst-layout/src/math/shared.rs
+++ b/crates/typst-layout/src/math/shared.rs
@@ -1,7 +1,9 @@
 use ttf_parser::math::MathValue;
+use ttf_parser::Tag;
 use typst_library::foundations::{Style, StyleChain};
-use typst_library::layout::{Abs, Em, FixedAlignment, Frame, Point, Size, VAlignment};
+use typst_library::layout::{Abs, Em, FixedAlignment, Frame, Point, Size};
 use typst_library::math::{EquationElem, MathSize};
+use typst_library::text::{FontFeatures, TextElem};
 use typst_utils::LazyHash;
 
 use super::{LeftRightAlternator, MathContext, MathFragment, MathRun};
@@ -59,6 +61,16 @@ pub fn style_cramped() -> LazyHash<Style> {
     EquationElem::set_cramped(true).wrap()
 }
 
+/// Sets flac OpenType feature.
+pub fn style_flac() -> LazyHash<Style> {
+    TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"flac"), 1)])).wrap()
+}
+
+/// Sets dtls OpenType feature.
+pub fn style_dtls() -> LazyHash<Style> {
+    TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"dtls"), 1)])).wrap()
+}
+
 /// The style for subscripts in the current style.
 pub fn style_for_subscript(styles: StyleChain) -> [LazyHash<Style>; 2] {
     [style_for_superscript(styles), EquationElem::set_cramped(true).wrap()]
@@ -97,15 +109,6 @@ pub fn style_for_script_scale(ctx: &MathContext) -> LazyHash<Style> {
     .wrap()
 }
 
-/// How a delimieter should be aligned when scaling.
-pub fn delimiter_alignment(delimiter: char) -> VAlignment {
-    match delimiter {
-        '⌜' | '⌝' => VAlignment::Top,
-        '⌞' | '⌟' => VAlignment::Bottom,
-        _ => VAlignment::Horizon,
-    }
-}
-
 /// Stack rows on top of each other.
 ///
 /// Add a `gap` between each row and uses the baseline of the `baseline`-th
@@ -117,7 +120,6 @@ pub fn stack(
     gap: Abs,
     baseline: usize,
     alternator: LeftRightAlternator,
-    minimum_ascent_descent: Option<(Abs, Abs)>,
 ) -> Frame {
     let AlignmentResult { points, width } = alignments(&rows);
     let rows: Vec<_> = rows
@@ -125,13 +127,9 @@ pub fn stack(
         .map(|row| row.into_line_frame(&points, alternator))
         .collect();
 
-    let padded_height = |height: Abs| {
-        height.max(minimum_ascent_descent.map_or(Abs::zero(), |(a, d)| a + d))
-    };
-
     let mut frame = Frame::soft(Size::new(
         width,
-        rows.iter().map(|row| padded_height(row.height())).sum::<Abs>()
+        rows.iter().map(|row| row.height()).sum::<Abs>()
             + rows.len().saturating_sub(1) as f64 * gap,
     ));
 
@@ -142,14 +140,11 @@ pub fn stack(
         } else {
             Abs::zero()
         };
-        let ascent_padded_part = minimum_ascent_descent
-            .map_or(Abs::zero(), |(a, _)| (a - row.ascent()))
-            .max(Abs::zero());
-        let pos = Point::new(x, y + ascent_padded_part);
+        let pos = Point::new(x, y);
         if i == baseline {
-            frame.set_baseline(y + row.baseline() + ascent_padded_part);
+            frame.set_baseline(y + row.baseline());
         }
-        y += padded_height(row.height()) + gap;
+        y += row.height() + gap;
         frame.push_frame(pos, row);
     }
 
diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs
index f45035e27..d4370e7b9 100644
--- a/crates/typst-layout/src/math/stretch.rs
+++ b/crates/typst-layout/src/math/stretch.rs
@@ -1,19 +1,10 @@
-use ttf_parser::math::{GlyphAssembly, GlyphConstruction, GlyphPart};
-use ttf_parser::LazyArray16;
 use typst_library::diag::{warning, SourceResult};
 use typst_library::foundations::{Packed, StyleChain};
-use typst_library::layout::{Abs, Axis, Frame, Point, Rel, Size};
+use typst_library::layout::{Abs, Axis, Rel};
 use typst_library::math::StretchElem;
 use typst_utils::Get;
 
-use super::{
-    delimiter_alignment, GlyphFragment, MathContext, MathFragment, Scaled,
-    VariantFragment,
-};
-use crate::modifiers::FrameModify;
-
-/// Maximum number of times extenders can be repeated.
-const MAX_REPEATS: usize = 1024;
+use super::{stretch_axes, MathContext, MathFragment};
 
 /// Lays out a [`StretchElem`].
 #[typst_macros::time(name = "math.stretch", span = elem.span())]
@@ -23,15 +14,7 @@ pub fn layout_stretch(
     styles: StyleChain,
 ) -> SourceResult<()> {
     let mut fragment = ctx.layout_into_fragment(&elem.body, styles)?;
-    stretch_fragment(
-        ctx,
-        styles,
-        &mut fragment,
-        None,
-        None,
-        elem.size(styles),
-        Abs::zero(),
-    );
+    stretch_fragment(ctx, &mut fragment, None, None, elem.size(styles), Abs::zero());
     ctx.push(fragment);
     Ok(())
 }
@@ -39,269 +22,49 @@ pub fn layout_stretch(
 /// Attempts to stretch the given fragment by/to the amount given in stretch.
 pub fn stretch_fragment(
     ctx: &mut MathContext,
-    styles: StyleChain,
     fragment: &mut MathFragment,
     axis: Option<Axis>,
     relative_to: Option<Abs>,
     stretch: Rel<Abs>,
     short_fall: Abs,
 ) {
-    let glyph = match fragment {
-        MathFragment::Glyph(glyph) => glyph.clone(),
-        MathFragment::Variant(variant) => {
-            GlyphFragment::new(ctx, styles, variant.c, variant.span)
-        }
-        _ => return,
-    };
+    let size = fragment.size();
+
+    let MathFragment::Glyph(ref mut glyph) = fragment else { return };
 
     // Return if we attempt to stretch along an axis which isn't stretchable,
     // so that the original fragment isn't modified.
-    let Some(stretch_axis) = stretch_axis(ctx, &glyph) else { return };
-    let axis = axis.unwrap_or(stretch_axis);
-    if axis != stretch_axis {
-        return;
-    }
-
-    let relative_to_size = relative_to.unwrap_or_else(|| fragment.size().get(axis));
-
-    let mut variant = stretch_glyph(
-        ctx,
-        glyph,
-        stretch.relative_to(relative_to_size),
-        short_fall,
-        axis,
-    );
-
-    if axis == Axis::Y {
-        variant.align_on_axis(ctx, delimiter_alignment(variant.c));
-    }
-
-    *fragment = MathFragment::Variant(variant);
-}
-
-/// Return whether the glyph is stretchable and if it is, along which axis it
-/// can be stretched.
-fn stretch_axis(ctx: &mut MathContext, base: &GlyphFragment) -> Option<Axis> {
-    let base_id = base.id;
-    let vertical = ctx
-        .table
-        .variants
-        .and_then(|variants| variants.vertical_constructions.get(base_id))
-        .map(|_| Axis::Y);
-    let horizontal = ctx
-        .table
-        .variants
-        .and_then(|variants| variants.horizontal_constructions.get(base_id))
-        .map(|_| Axis::X);
-
-    match (vertical, horizontal) {
-        (vertical, None) => vertical,
-        (None, horizontal) => horizontal,
-        _ => {
-            // As far as we know, there aren't any glyphs that have both
-            // vertical and horizontal constructions. So for the time being, we
-            // will assume that a glyph cannot have both.
-            ctx.engine.sink.warn(warning!(
-               base.span,
-               "glyph has both vertical and horizontal constructions";
-               hint: "this is probably a font bug";
-               hint: "please file an issue at https://github.com/typst/typst/issues"
-            ));
-
-            None
+    let axes = stretch_axes(&glyph.item.font, glyph.base_glyph.id);
+    let stretch_axis = if let Some(axis) = axis {
+        if !axes.get(axis) {
+            return;
         }
-    }
-}
-
-/// Try to stretch a glyph to a desired width or height.
-///
-/// The resulting frame may not have the exact desired width.
-pub fn stretch_glyph(
-    ctx: &mut MathContext,
-    mut base: GlyphFragment,
-    target: Abs,
-    short_fall: Abs,
-    axis: Axis,
-) -> VariantFragment {
-    // If the base glyph is good enough, use it.
-    let advance = match axis {
-        Axis::X => base.width,
-        Axis::Y => base.height(),
-    };
-    let short_target = target - short_fall;
-    if short_target <= advance {
-        return base.into_variant();
-    }
-
-    let mut min_overlap = Abs::zero();
-    let construction = ctx
-        .table
-        .variants
-        .and_then(|variants| {
-            min_overlap = variants.min_connector_overlap.scaled(ctx, base.font_size);
-            match axis {
-                Axis::X => variants.horizontal_constructions,
-                Axis::Y => variants.vertical_constructions,
+        axis
+    } else {
+        match (axes.x, axes.y) {
+            (true, false) => Axis::X,
+            (false, true) => Axis::Y,
+            (false, false) => return,
+            (true, true) => {
+                // As far as we know, there aren't any glyphs that have both
+                // vertical and horizontal constructions. So for the time being, we
+                // will assume that a glyph cannot have both.
+                ctx.engine.sink.warn(warning!(
+                   glyph.item.glyphs[0].span.0,
+                   "glyph has both vertical and horizontal constructions";
+                   hint: "this is probably a font bug";
+                   hint: "please file an issue at https://github.com/typst/typst/issues"
+                ));
+                return;
             }
-            .get(base.id)
-        })
-        .unwrap_or(GlyphConstruction { assembly: None, variants: LazyArray16::new(&[]) });
-
-    // Search for a pre-made variant with a good advance.
-    let mut best_id = base.id;
-    let mut best_advance = base.width;
-    for variant in construction.variants {
-        best_id = variant.variant_glyph;
-        best_advance = base.font.to_em(variant.advance_measurement).at(base.font_size);
-        if short_target <= best_advance {
-            break;
         }
-    }
-
-    // This is either good or the best we've got.
-    if short_target <= best_advance || construction.assembly.is_none() {
-        base.set_id(ctx, best_id);
-        return base.into_variant();
-    }
-
-    // Assemble from parts.
-    let assembly = construction.assembly.unwrap();
-    assemble(ctx, base, assembly, min_overlap, target, axis)
-}
-
-/// Assemble a glyph from parts.
-fn assemble(
-    ctx: &mut MathContext,
-    base: GlyphFragment,
-    assembly: GlyphAssembly,
-    min_overlap: Abs,
-    target: Abs,
-    axis: Axis,
-) -> VariantFragment {
-    // Determine the number of times the extenders need to be repeated as well
-    // as a ratio specifying how much to spread the parts apart
-    // (0 = maximal overlap, 1 = minimal overlap).
-    let mut full;
-    let mut ratio;
-    let mut repeat = 0;
-    loop {
-        full = Abs::zero();
-        ratio = 0.0;
-
-        let mut parts = parts(assembly, repeat).peekable();
-        let mut growable = Abs::zero();
-
-        while let Some(part) = parts.next() {
-            let mut advance = part.full_advance.scaled(ctx, base.font_size);
-            if let Some(next) = parts.peek() {
-                let max_overlap = part
-                    .end_connector_length
-                    .min(next.start_connector_length)
-                    .scaled(ctx, base.font_size);
-                if max_overlap < min_overlap {
-                    // This condition happening is indicative of a bug in the
-                    // font.
-                    ctx.engine.sink.warn(warning!(
-                       base.span,
-                       "glyph has assembly parts with overlap less than minConnectorOverlap";
-                       hint: "its rendering may appear broken - this is probably a font bug";
-                       hint: "please file an issue at https://github.com/typst/typst/issues"
-                    ));
-                }
-
-                advance -= max_overlap;
-                growable += max_overlap - min_overlap;
-            }
-
-            full += advance;
-        }
-
-        if full < target {
-            let delta = target - full;
-            ratio = (delta / growable).min(1.0);
-            full += ratio * growable;
-        }
-
-        if target <= full || repeat >= MAX_REPEATS {
-            break;
-        }
-
-        repeat += 1;
-    }
-
-    let mut selected = vec![];
-    let mut parts = parts(assembly, repeat).peekable();
-    while let Some(part) = parts.next() {
-        let mut advance = part.full_advance.scaled(ctx, base.font_size);
-        if let Some(next) = parts.peek() {
-            let max_overlap = part
-                .end_connector_length
-                .min(next.start_connector_length)
-                .scaled(ctx, base.font_size);
-            advance -= max_overlap;
-            advance += ratio * (max_overlap - min_overlap);
-        }
-
-        let mut fragment = base.clone();
-        fragment.set_id(ctx, part.glyph_id);
-        selected.push((fragment, advance));
-    }
-
-    let size;
-    let baseline;
-    match axis {
-        Axis::X => {
-            let height = base.ascent + base.descent;
-            size = Size::new(full, height);
-            baseline = base.ascent;
-        }
-        Axis::Y => {
-            let axis = ctx.constants.axis_height().scaled(ctx, base.font_size);
-            let width = selected.iter().map(|(f, _)| f.width).max().unwrap_or_default();
-            size = Size::new(width, full);
-            baseline = full / 2.0 + axis;
-        }
-    }
-
-    let mut frame = Frame::soft(size);
-    let mut offset = Abs::zero();
-    frame.set_baseline(baseline);
-    frame.modify(&base.modifiers);
-
-    for (fragment, advance) in selected {
-        let pos = match axis {
-            Axis::X => Point::new(offset, frame.baseline() - fragment.ascent),
-            Axis::Y => Point::with_y(full - offset - fragment.height()),
-        };
-        frame.push_frame(pos, fragment.into_frame());
-        offset += advance;
-    }
-
-    let accent_attach = match axis {
-        Axis::X => frame.width() / 2.0,
-        Axis::Y => base.accent_attach,
     };
 
-    VariantFragment {
-        c: base.c,
-        frame,
-        font_size: base.font_size,
-        italics_correction: Abs::zero(),
-        accent_attach,
-        class: base.class,
-        math_size: base.math_size,
-        span: base.span,
-        limits: base.limits,
-        mid_stretched: None,
-        extended_shape: true,
+    let relative_to_size = relative_to.unwrap_or_else(|| size.get(stretch_axis));
+
+    glyph.stretch(ctx, stretch.relative_to(relative_to_size) - short_fall, stretch_axis);
+
+    if stretch_axis == Axis::Y {
+        glyph.center_on_axis();
     }
 }
-
-/// Return an iterator over the assembly's parts with extenders repeated the
-/// specified number of times.
-fn parts(assembly: GlyphAssembly, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
-    assembly.parts.into_iter().flat_map(move |part| {
-        let count = if part.part_flags.extender() { repeat } else { 1 };
-        std::iter::repeat_n(part, count)
-    })
-}
diff --git a/crates/typst-layout/src/math/text.rs b/crates/typst-layout/src/math/text.rs
index 59ac5b089..67dc0a2c8 100644
--- a/crates/typst-layout/src/math/text.rs
+++ b/crates/typst-layout/src/math/text.rs
@@ -12,7 +12,10 @@ use typst_syntax::{is_newline, Span};
 use unicode_math_class::MathClass;
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::{FrameFragment, GlyphFragment, MathContext, MathFragment, MathRun};
+use super::{
+    has_dtls_feat, style_dtls, FrameFragment, GlyphFragment, MathContext, MathFragment,
+    MathRun,
+};
 
 /// Lays out a [`TextElem`].
 pub fn layout_text(
@@ -65,19 +68,9 @@ fn layout_inline_text(
         // Small optimization for numbers. Note that this lays out slightly
         // differently to normal text and is worth re-evaluating in the future.
         let mut fragments = vec![];
-        let is_single = text.chars().count() == 1;
         for unstyled_c in text.chars() {
             let c = styled_char(styles, unstyled_c, false);
-            let mut glyph = GlyphFragment::new(ctx, styles, c, span);
-            if is_single {
-                // Duplicate what `layout_glyph` does exactly even if it's
-                // probably incorrect here.
-                match EquationElem::size_in(styles) {
-                    MathSize::Script => glyph.make_script_size(ctx),
-                    MathSize::ScriptScript => glyph.make_script_script_size(ctx),
-                    _ => {}
-                }
-            }
+            let glyph = GlyphFragment::new_char(ctx.font, styles, c, span)?;
             fragments.push(glyph.into());
         }
         let frame = MathRun::new(fragments).into_frame(styles);
@@ -126,54 +119,45 @@ pub fn layout_symbol(
 ) -> SourceResult<()> {
     // Switch dotless char to normal when we have the dtls OpenType feature.
     // This should happen before the main styling pass.
-    let (unstyled_c, dtls) = match try_dotless(elem.text) {
-        Some(c) if ctx.dtls_table.is_some() => (c, true),
-        _ => (elem.text, false),
+    let dtls = style_dtls();
+    let (unstyled_c, symbol_styles) = match try_dotless(elem.text) {
+        Some(c) if has_dtls_feat(ctx.font) => (c, styles.chain(&dtls)),
+        _ => (elem.text, styles),
     };
     let c = styled_char(styles, unstyled_c, true);
-    let fragment = match GlyphFragment::try_new(ctx, styles, c, elem.span()) {
-        Some(glyph) => layout_glyph(glyph, dtls, ctx, styles),
-        None => {
-            // Not in the math font, fallback to normal inline text layout.
-            layout_inline_text(c.encode_utf8(&mut [0; 4]), elem.span(), ctx, styles)?
-                .into()
-        }
-    };
+    let fragment: MathFragment =
+        match GlyphFragment::new_char(ctx.font, symbol_styles, c, elem.span()) {
+            Ok(mut glyph) => {
+                adjust_glyph_layout(&mut glyph, ctx, styles);
+                glyph.into()
+            }
+            Err(_) => {
+                // Not in the math font, fallback to normal inline text layout.
+                // TODO: Should replace this with proper fallback in [`GlyphFragment::new`].
+                layout_inline_text(c.encode_utf8(&mut [0; 4]), elem.span(), ctx, styles)?
+                    .into()
+            }
+        };
     ctx.push(fragment);
     Ok(())
 }
 
-/// Layout a [`GlyphFragment`].
-fn layout_glyph(
-    mut glyph: GlyphFragment,
-    dtls: bool,
+/// Centers large glyphs vertically on the axis, scaling them if in display
+/// style.
+fn adjust_glyph_layout(
+    glyph: &mut GlyphFragment,
     ctx: &mut MathContext,
     styles: StyleChain,
-) -> MathFragment {
-    if dtls {
-        glyph.make_dotless_form(ctx);
-    }
-    let math_size = EquationElem::size_in(styles);
-    match math_size {
-        MathSize::Script => glyph.make_script_size(ctx),
-        MathSize::ScriptScript => glyph.make_script_script_size(ctx),
-        _ => {}
-    }
-
+) {
     if glyph.class == MathClass::Large {
-        let mut variant = if math_size == MathSize::Display {
+        if EquationElem::size_in(styles) == MathSize::Display {
             let height = scaled!(ctx, styles, display_operator_min_height)
-                .max(SQRT_2 * glyph.height());
-            glyph.stretch_vertical(ctx, height, Abs::zero())
-        } else {
-            glyph.into_variant()
+                .max(SQRT_2 * glyph.size.y);
+            glyph.stretch_vertical(ctx, height);
         };
         // TeXbook p 155. Large operators are always vertically centered on the
         // axis.
-        variant.center_on_axis(ctx);
-        variant.into()
-    } else {
-        glyph.into()
+        glyph.center_on_axis();
     }
 }
 
diff --git a/crates/typst-layout/src/math/underover.rs b/crates/typst-layout/src/math/underover.rs
index 7b3617c3e..c29d99478 100644
--- a/crates/typst-layout/src/math/underover.rs
+++ b/crates/typst-layout/src/math/underover.rs
@@ -285,14 +285,14 @@ fn layout_underoverspreader(
     let body = ctx.layout_into_run(body, styles)?;
     let body_class = body.class();
     let body = body.into_fragment(styles);
-    let glyph = GlyphFragment::new(ctx, styles, c, span);
-    let stretched = glyph.stretch_horizontal(ctx, body.width(), Abs::zero());
+    let mut glyph = GlyphFragment::new_char(ctx.font, styles, c, span)?;
+    glyph.stretch_horizontal(ctx, body.width());
 
     let mut rows = vec![];
     let baseline = match position {
         Position::Under => {
             rows.push(MathRun::new(vec![body]));
-            rows.push(stretched.into());
+            rows.push(glyph.into());
             if let Some(annotation) = annotation {
                 let under_style = style_for_subscript(styles);
                 let annotation_styles = styles.chain(&under_style);
@@ -306,20 +306,14 @@ fn layout_underoverspreader(
                 let annotation_styles = styles.chain(&over_style);
                 rows.extend(ctx.layout_into_run(annotation, annotation_styles)?.rows());
             }
-            rows.push(stretched.into());
+            rows.push(glyph.into());
             rows.push(MathRun::new(vec![body]));
             rows.len() - 1
         }
     };
 
-    let frame = stack(
-        rows,
-        FixedAlignment::Center,
-        gap,
-        baseline,
-        LeftRightAlternator::Right,
-        None,
-    );
+    let frame =
+        stack(rows, FixedAlignment::Center, gap, baseline, LeftRightAlternator::Right);
     ctx.push(FrameFragment::new(styles, frame).with_class(body_class));
 
     Ok(())
diff --git a/crates/typst-layout/src/modifiers.rs b/crates/typst-layout/src/modifiers.rs
index ac5f40b04..b0371d63e 100644
--- a/crates/typst-layout/src/modifiers.rs
+++ b/crates/typst-layout/src/modifiers.rs
@@ -1,6 +1,6 @@
 use typst_library::foundations::StyleChain;
-use typst_library::layout::{Fragment, Frame, FrameItem, HideElem, Point};
-use typst_library::model::{Destination, LinkElem};
+use typst_library::layout::{Abs, Fragment, Frame, FrameItem, HideElem, Point, Sides};
+use typst_library::model::{Destination, LinkElem, ParElem};
 
 /// Frame-level modifications resulting from styles that do not impose any
 /// layout structure.
@@ -52,14 +52,7 @@ pub trait FrameModify {
 
 impl FrameModify for Frame {
     fn modify(&mut self, modifiers: &FrameModifiers) {
-        if let Some(dest) = &modifiers.dest {
-            let size = self.size();
-            self.push(Point::zero(), FrameItem::Link(dest.clone(), size));
-        }
-
-        if modifiers.hidden {
-            self.hide();
-        }
+        modify_frame(self, modifiers, None);
     }
 }
 
@@ -82,6 +75,41 @@ where
     }
 }
 
+pub trait FrameModifyText {
+    /// Resolve and apply [`FrameModifiers`] for this text frame.
+    fn modify_text(&mut self, styles: StyleChain);
+}
+
+impl FrameModifyText for Frame {
+    fn modify_text(&mut self, styles: StyleChain) {
+        let modifiers = FrameModifiers::get_in(styles);
+        let expand_y = 0.5 * ParElem::leading_in(styles);
+        let outset = Sides::new(Abs::zero(), expand_y, Abs::zero(), expand_y);
+        modify_frame(self, &modifiers, Some(outset));
+    }
+}
+
+fn modify_frame(
+    frame: &mut Frame,
+    modifiers: &FrameModifiers,
+    link_box_outset: Option<Sides<Abs>>,
+) {
+    if let Some(dest) = &modifiers.dest {
+        let mut pos = Point::zero();
+        let mut size = frame.size();
+        if let Some(outset) = link_box_outset {
+            pos.y -= outset.top;
+            pos.x -= outset.left;
+            size += outset.sum_by_axis();
+        }
+        frame.push(pos, FrameItem::Link(dest.clone(), size));
+    }
+
+    if modifiers.hidden {
+        frame.hide();
+    }
+}
+
 /// Performs layout and modification in one step.
 ///
 /// This just runs `layout(styles).modified(&FrameModifiers::get_in(styles))`,
diff --git a/crates/typst-library/Cargo.toml b/crates/typst-library/Cargo.toml
index 71729b63a..f4b219882 100644
--- a/crates/typst-library/Cargo.toml
+++ b/crates/typst-library/Cargo.toml
@@ -29,6 +29,7 @@ csv = { workspace = true }
 ecow = { workspace = true }
 flate2 = { workspace = true }
 fontdb = { workspace = true }
+glidesort = { workspace = true }
 hayagriva = { workspace = true }
 icu_properties = { workspace = true }
 icu_provider = { workspace = true }
@@ -65,6 +66,7 @@ unicode-normalization = { workspace = true }
 unicode-segmentation = { workspace = true }
 unscanny = { workspace = true }
 usvg = { workspace = true }
+utf8_iter = { workspace = true }
 wasmi = { workspace = true }
 xmlwriter = { workspace = true }
 
diff --git a/crates/typst-library/src/diag.rs b/crates/typst-library/src/diag.rs
index 49cbd02c6..41b92ed65 100644
--- a/crates/typst-library/src/diag.rs
+++ b/crates/typst-library/src/diag.rs
@@ -1,17 +1,20 @@
 //! Diagnostics.
 
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Display, Formatter, Write as _};
 use std::io;
 use std::path::{Path, PathBuf};
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 
+use az::SaturatingAs;
 use comemo::Tracked;
 use ecow::{eco_vec, EcoVec};
 use typst_syntax::package::{PackageSpec, PackageVersion};
-use typst_syntax::{Span, Spanned, SyntaxError};
+use typst_syntax::{Lines, Span, Spanned, SyntaxError};
+use utf8_iter::ErrorReportingUtf8Chars;
 
 use crate::engine::Engine;
+use crate::loading::{LoadSource, Loaded};
 use crate::{World, WorldExt};
 
 /// Early-return with a [`StrResult`] or [`SourceResult`].
@@ -148,7 +151,7 @@ pub struct Warned<T> {
     pub warnings: EcoVec<SourceDiagnostic>,
 }
 
-/// An error or warning in a source file.
+/// An error or warning in a source or text file.
 ///
 /// The contained spans will only be detached if any of the input source files
 /// were detached.
@@ -568,31 +571,287 @@ impl From<PackageError> for EcoString {
     }
 }
 
+/// A result type with a data-loading-related error.
+pub type LoadResult<T> = Result<T, LoadError>;
+
+/// A call site independent error that occurred during data loading. This avoids
+/// polluting the memoization with [`Span`]s and [`FileId`]s from source files.
+/// Can be turned into a [`SourceDiagnostic`] using the [`LoadedWithin::within`]
+/// method available on [`LoadResult`].
+///
+/// [`FileId`]: typst_syntax::FileId
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct LoadError {
+    /// The position in the file at which the error occured.
+    pos: ReportPos,
+    /// Must contain a message formatted like this: `"failed to do thing (cause)"`.
+    message: EcoString,
+}
+
+impl LoadError {
+    /// Creates a new error from a position in a file, a base message
+    /// (e.g. `failed to parse JSON`) and a concrete error (e.g. `invalid
+    /// number`)
+    pub fn new(
+        pos: impl Into<ReportPos>,
+        message: impl std::fmt::Display,
+        error: impl std::fmt::Display,
+    ) -> Self {
+        Self {
+            pos: pos.into(),
+            message: eco_format!("{message} ({error})"),
+        }
+    }
+}
+
+impl From<Utf8Error> for LoadError {
+    fn from(err: Utf8Error) -> Self {
+        let start = err.valid_up_to();
+        let end = start + err.error_len().unwrap_or(0);
+        LoadError::new(
+            start..end,
+            "failed to convert to string",
+            "file is not valid utf-8",
+        )
+    }
+}
+
+/// Convert a [`LoadResult`] to a [`SourceResult`] by adding the [`Loaded`]
+/// context.
+pub trait LoadedWithin<T> {
+    /// Report an error, possibly in an external file.
+    fn within(self, loaded: &Loaded) -> SourceResult<T>;
+}
+
+impl<T, E> LoadedWithin<T> for Result<T, E>
+where
+    E: Into<LoadError>,
+{
+    fn within(self, loaded: &Loaded) -> SourceResult<T> {
+        self.map_err(|err| {
+            let LoadError { pos, message } = err.into();
+            load_err_in_text(loaded, pos, message)
+        })
+    }
+}
+
+/// Report an error, possibly in an external file. This will delegate to
+/// [`load_err_in_invalid_text`] if the data isn't valid utf-8.
+fn load_err_in_text(
+    loaded: &Loaded,
+    pos: impl Into<ReportPos>,
+    mut message: EcoString,
+) -> EcoVec<SourceDiagnostic> {
+    let pos = pos.into();
+    // This also does utf-8 validation. Only report an error in an external
+    // file if it is human readable (valid utf-8), otherwise fall back to
+    // `load_err_in_invalid_text`.
+    let lines = Lines::try_from(&loaded.data);
+    match (loaded.source.v, lines) {
+        (LoadSource::Path(file_id), Ok(lines)) => {
+            if let Some(range) = pos.range(&lines) {
+                let span = Span::from_range(file_id, range);
+                return eco_vec![SourceDiagnostic::error(span, message)];
+            }
+
+            // Either `ReportPos::None` was provided, or resolving the range
+            // from the line/column failed. If present report the possibly
+            // wrong line/column in the error message anyway.
+            let span = Span::from_range(file_id, 0..loaded.data.len());
+            if let Some(pair) = pos.line_col(&lines) {
+                message.pop();
+                let (line, col) = pair.numbers();
+                write!(&mut message, " at {line}:{col})").ok();
+            }
+            eco_vec![SourceDiagnostic::error(span, message)]
+        }
+        (LoadSource::Bytes, Ok(lines)) => {
+            if let Some(pair) = pos.line_col(&lines) {
+                message.pop();
+                let (line, col) = pair.numbers();
+                write!(&mut message, " at {line}:{col})").ok();
+            }
+            eco_vec![SourceDiagnostic::error(loaded.source.span, message)]
+        }
+        _ => load_err_in_invalid_text(loaded, pos, message),
+    }
+}
+
+/// Report an error (possibly from an external file) that isn't valid utf-8.
+fn load_err_in_invalid_text(
+    loaded: &Loaded,
+    pos: impl Into<ReportPos>,
+    mut message: EcoString,
+) -> EcoVec<SourceDiagnostic> {
+    let line_col = pos.into().try_line_col(&loaded.data).map(|p| p.numbers());
+    match (loaded.source.v, line_col) {
+        (LoadSource::Path(file), _) => {
+            message.pop();
+            if let Some(package) = file.package() {
+                write!(
+                    &mut message,
+                    " in {package}{}",
+                    file.vpath().as_rooted_path().display()
+                )
+                .ok();
+            } else {
+                write!(&mut message, " in {}", file.vpath().as_rootless_path().display())
+                    .ok();
+            };
+            if let Some((line, col)) = line_col {
+                write!(&mut message, ":{line}:{col}").ok();
+            }
+            message.push(')');
+        }
+        (LoadSource::Bytes, Some((line, col))) => {
+            message.pop();
+            write!(&mut message, " at {line}:{col})").ok();
+        }
+        (LoadSource::Bytes, None) => (),
+    }
+    eco_vec![SourceDiagnostic::error(loaded.source.span, message)]
+}
+
+/// A position at which an error was reported.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub enum ReportPos {
+    /// Contains a range, and a line/column pair.
+    Full(std::ops::Range<u32>, LineCol),
+    /// Contains a range.
+    Range(std::ops::Range<u32>),
+    /// Contains a line/column pair.
+    LineCol(LineCol),
+    #[default]
+    None,
+}
+
+impl From<std::ops::Range<usize>> for ReportPos {
+    fn from(value: std::ops::Range<usize>) -> Self {
+        Self::Range(value.start.saturating_as()..value.end.saturating_as())
+    }
+}
+
+impl From<LineCol> for ReportPos {
+    fn from(value: LineCol) -> Self {
+        Self::LineCol(value)
+    }
+}
+
+impl ReportPos {
+    /// Creates a position from a pre-existing range and line-column pair.
+    pub fn full(range: std::ops::Range<usize>, pair: LineCol) -> Self {
+        let range = range.start.saturating_as()..range.end.saturating_as();
+        Self::Full(range, pair)
+    }
+
+    /// Tries to determine the byte range for this position.
+    fn range(&self, lines: &Lines<String>) -> Option<std::ops::Range<usize>> {
+        match self {
+            ReportPos::Full(range, _) => Some(range.start as usize..range.end as usize),
+            ReportPos::Range(range) => Some(range.start as usize..range.end as usize),
+            &ReportPos::LineCol(pair) => {
+                let i =
+                    lines.line_column_to_byte(pair.line as usize, pair.col as usize)?;
+                Some(i..i)
+            }
+            ReportPos::None => None,
+        }
+    }
+
+    /// Tries to determine the line/column for this position.
+    fn line_col(&self, lines: &Lines<String>) -> Option<LineCol> {
+        match self {
+            &ReportPos::Full(_, pair) => Some(pair),
+            ReportPos::Range(range) => {
+                let (line, col) = lines.byte_to_line_column(range.start as usize)?;
+                Some(LineCol::zero_based(line, col))
+            }
+            &ReportPos::LineCol(pair) => Some(pair),
+            ReportPos::None => None,
+        }
+    }
+
+    /// Either gets the line/column pair, or tries to compute it from possibly
+    /// invalid utf-8 data.
+    fn try_line_col(&self, bytes: &[u8]) -> Option<LineCol> {
+        match self {
+            &ReportPos::Full(_, pair) => Some(pair),
+            ReportPos::Range(range) => {
+                LineCol::try_from_byte_pos(range.start as usize, bytes)
+            }
+            &ReportPos::LineCol(pair) => Some(pair),
+            ReportPos::None => None,
+        }
+    }
+}
+
+/// A line/column pair.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct LineCol {
+    /// The 0-based line.
+    line: u32,
+    /// The 0-based column.
+    col: u32,
+}
+
+impl LineCol {
+    /// Constructs the line/column pair from 0-based indices.
+    pub fn zero_based(line: usize, col: usize) -> Self {
+        Self {
+            line: line.saturating_as(),
+            col: col.saturating_as(),
+        }
+    }
+
+    /// Constructs the line/column pair from 1-based numbers.
+    pub fn one_based(line: usize, col: usize) -> Self {
+        Self::zero_based(line.saturating_sub(1), col.saturating_sub(1))
+    }
+
+    /// Try to compute a line/column pair from possibly invalid utf-8 data.
+    pub fn try_from_byte_pos(pos: usize, bytes: &[u8]) -> Option<Self> {
+        let bytes = &bytes[..pos];
+        let mut line = 0;
+        #[allow(clippy::double_ended_iterator_last)]
+        let line_start = memchr::memchr_iter(b'\n', bytes)
+            .inspect(|_| line += 1)
+            .last()
+            .map(|i| i + 1)
+            .unwrap_or(bytes.len());
+
+        let col = ErrorReportingUtf8Chars::new(&bytes[line_start..]).count();
+        Some(LineCol::zero_based(line, col))
+    }
+
+    /// Returns the 0-based line/column indices.
+    pub fn indices(&self) -> (usize, usize) {
+        (self.line as usize, self.col as usize)
+    }
+
+    /// Returns the 1-based line/column numbers.
+    pub fn numbers(&self) -> (usize, usize) {
+        (self.line as usize + 1, self.col as usize + 1)
+    }
+}
+
 /// Format a user-facing error message for an XML-like file format.
-pub fn format_xml_like_error(format: &str, error: roxmltree::Error) -> EcoString {
-    match error {
-        roxmltree::Error::UnexpectedCloseTag(expected, actual, pos) => {
-            eco_format!(
-                "failed to parse {format} (found closing tag '{actual}' \
-                 instead of '{expected}' in line {})",
-                pos.row
-            )
+pub fn format_xml_like_error(format: &str, error: roxmltree::Error) -> LoadError {
+    let pos = LineCol::one_based(error.pos().row as usize, error.pos().col as usize);
+    let message = match error {
+        roxmltree::Error::UnexpectedCloseTag(expected, actual, _) => {
+            eco_format!("failed to parse {format} (found closing tag '{actual}' instead of '{expected}')")
         }
-        roxmltree::Error::UnknownEntityReference(entity, pos) => {
-            eco_format!(
-                "failed to parse {format} (unknown entity '{entity}' in line {})",
-                pos.row
-            )
+        roxmltree::Error::UnknownEntityReference(entity, _) => {
+            eco_format!("failed to parse {format} (unknown entity '{entity}')")
         }
-        roxmltree::Error::DuplicatedAttribute(attr, pos) => {
-            eco_format!(
-                "failed to parse {format} (duplicate attribute '{attr}' in line {})",
-                pos.row
-            )
+        roxmltree::Error::DuplicatedAttribute(attr, _) => {
+            eco_format!("failed to parse {format} (duplicate attribute '{attr}')")
         }
         roxmltree::Error::NoRootNode => {
             eco_format!("failed to parse {format} (missing root node)")
         }
         err => eco_format!("failed to parse {format} ({err})"),
-    }
+    };
+
+    LoadError { pos: pos.into(), message }
 }
diff --git a/crates/typst-library/src/foundations/array.rs b/crates/typst-library/src/foundations/array.rs
index e81b9e645..c1fcb6b49 100644
--- a/crates/typst-library/src/foundations/array.rs
+++ b/crates/typst-library/src/foundations/array.rs
@@ -172,17 +172,29 @@ impl Array {
     }
 
     /// Returns the first item in the array. May be used on the left-hand side
-    /// of an assignment. Fails with an error if the array is empty.
+    /// an assignment. Returns the default value if the array is empty
+    /// or fails with an error is no default value was specified.
     #[func]
-    pub fn first(&self) -> StrResult<Value> {
-        self.0.first().cloned().ok_or_else(array_is_empty)
+    pub fn first(
+        &self,
+        /// A default value to return if the array is empty.
+        #[named]
+        default: Option<Value>,
+    ) -> StrResult<Value> {
+        self.0.first().cloned().or(default).ok_or_else(array_is_empty)
     }
 
     /// Returns the last item in the array. May be used on the left-hand side of
-    /// an assignment. Fails with an error if the array is empty.
+    /// an assignment. Returns the default value if the array is empty
+    /// or fails with an error is no default value was specified.
     #[func]
-    pub fn last(&self) -> StrResult<Value> {
-        self.0.last().cloned().ok_or_else(array_is_empty)
+    pub fn last(
+        &self,
+        /// A default value to return if the array is empty.
+        #[named]
+        default: Option<Value>,
+    ) -> StrResult<Value> {
+        self.0.last().cloned().or(default).ok_or_else(array_is_empty)
     }
 
     /// Returns the item at the specified index in the array. May be used on the
@@ -796,7 +808,7 @@ impl Array {
     /// function. The sorting algorithm used is stable.
     ///
     /// Returns an error if two values could not be compared or if the key
-    /// function (if given) yields an error.
+    /// or comparison function (if given) yields an error.
     ///
     /// To sort according to multiple criteria at once, e.g. in case of equality
     /// between some criteria, the key function can return an array. The results
@@ -820,33 +832,134 @@ impl Array {
         /// determine the keys to sort by.
         #[named]
         key: Option<Func>,
+        /// If given, uses this function to compare elements in the array.
+        ///
+        /// This function should return a boolean: `{true}` indicates that the
+        /// elements are in order, while `{false}` indicates that they should be
+        /// swapped. To keep the sort stable, if the two elements are equal, the
+        /// function should return `{true}`.
+        ///
+        /// If this function does not order the elements properly (e.g., by
+        /// returning `{false}` for both `{(x, y)}` and `{(y, x)}`, or for
+        /// `{(x, x)}`), the resulting array will be in unspecified order.
+        ///
+        /// When used together with `key`, `by` will be passed the keys instead
+        /// of the elements.
+        ///
+        /// ```example
+        /// #(
+        ///   "sorted",
+        ///   "by",
+        ///   "decreasing",
+        ///   "length",
+        /// ).sorted(
+        ///   key: s => s.len(),
+        ///   by: (l, r) => l >= r,
+        /// )
+        /// ```
+        #[named]
+        by: Option<Func>,
     ) -> SourceResult<Array> {
-        let mut result = Ok(());
-        let mut vec = self.0;
-        let mut key_of = |x: Value| match &key {
-            // NOTE: We are relying on `comemo`'s memoization of function
-            // evaluation to not excessively reevaluate the `key`.
-            Some(f) => f.call(engine, context, [x]),
-            None => Ok(x),
-        };
-        vec.make_mut().sort_by(|a, b| {
-            // Until we get `try` blocks :)
-            match (key_of(a.clone()), key_of(b.clone())) {
-                (Ok(a), Ok(b)) => ops::compare(&a, &b).unwrap_or_else(|err| {
-                    if result.is_ok() {
-                        result = Err(err).at(span);
+        match by {
+            Some(by) => {
+                let mut are_in_order = |mut x, mut y| {
+                    if let Some(f) = &key {
+                        // We rely on `comemo`'s memoization of function
+                        // evaluation to not excessively reevaluate the key.
+                        x = f.call(engine, context, [x])?;
+                        y = f.call(engine, context, [y])?;
                     }
-                    Ordering::Equal
-                }),
-                (Err(e), _) | (_, Err(e)) => {
-                    if result.is_ok() {
-                        result = Err(e);
+                    match by.call(engine, context, [x, y])? {
+                        Value::Bool(b) => Ok(b),
+                        x => {
+                            bail!(
+                                span,
+                                "expected boolean from `by` function, got {}",
+                                x.ty(),
+                            )
+                        }
                     }
-                    Ordering::Equal
-                }
+                };
+                // If a comparison function is provided, we use `glidesort`
+                // instead of the standard library sorting algorithm to prevent
+                // panics in case the comparison function does not define a
+                // valid order (see https://github.com/typst/typst/pull/5627).
+                let mut result = Ok(());
+                let mut vec = self.0.into_iter().enumerate().collect::<Vec<_>>();
+                glidesort::sort_by(&mut vec, |(i, x), (j, y)| {
+                    // Because we use booleans for the comparison function, in
+                    // order to keep the sort stable, we need to compare in the
+                    // right order.
+                    if i < j {
+                        // If `x` and `y` appear in this order in the original
+                        // array, then we should change their order (i.e.,
+                        // return `Ordering::Greater`) iff `y` is strictly less
+                        // than `x` (i.e., `compare(x, y)` returns `false`).
+                        // Otherwise, we should keep them in the same order
+                        // (i.e., return `Ordering::Less`).
+                        match are_in_order(x.clone(), y.clone()) {
+                            Ok(false) => Ordering::Greater,
+                            Ok(true) => Ordering::Less,
+                            Err(err) => {
+                                if result.is_ok() {
+                                    result = Err(err);
+                                }
+                                Ordering::Equal
+                            }
+                        }
+                    } else {
+                        // If `x` and `y` appear in the opposite order in the
+                        // original array, then we should change their order
+                        // (i.e., return `Ordering::Less`) iff `x` is strictly
+                        // less than `y` (i.e., `compare(y, x)` returns
+                        // `false`). Otherwise, we should keep them in the same
+                        // order (i.e., return `Ordering::Less`).
+                        match are_in_order(y.clone(), x.clone()) {
+                            Ok(false) => Ordering::Less,
+                            Ok(true) => Ordering::Greater,
+                            Err(err) => {
+                                if result.is_ok() {
+                                    result = Err(err);
+                                }
+                                Ordering::Equal
+                            }
+                        }
+                    }
+                });
+                result.map(|()| vec.into_iter().map(|(_, x)| x).collect())
             }
-        });
-        result.map(|_| vec.into())
+
+            None => {
+                let mut key_of = |x: Value| match &key {
+                    // We rely on `comemo`'s memoization of function evaluation
+                    // to not excessively reevaluate the key.
+                    Some(f) => f.call(engine, context, [x]),
+                    None => Ok(x),
+                };
+                // If no comparison function is provided, we know the order is
+                // valid, so we can use the standard library sort and prevent an
+                // extra allocation.
+                let mut result = Ok(());
+                let mut vec = self.0;
+                vec.make_mut().sort_by(|a, b| {
+                    match (key_of(a.clone()), key_of(b.clone())) {
+                        (Ok(a), Ok(b)) => ops::compare(&a, &b).unwrap_or_else(|err| {
+                            if result.is_ok() {
+                                result = Err(err).at(span);
+                            }
+                            Ordering::Equal
+                        }),
+                        (Err(e), _) | (_, Err(e)) => {
+                            if result.is_ok() {
+                                result = Err(e);
+                            }
+                            Ordering::Equal
+                        }
+                    }
+                });
+                result.map(|()| vec.into())
+            }
+        }
     }
 
     /// Deduplicates all items in the array.
diff --git a/crates/typst-library/src/foundations/bytes.rs b/crates/typst-library/src/foundations/bytes.rs
index d633c99ad..180dcdad5 100644
--- a/crates/typst-library/src/foundations/bytes.rs
+++ b/crates/typst-library/src/foundations/bytes.rs
@@ -7,6 +7,7 @@ use std::sync::Arc;
 
 use ecow::{eco_format, EcoString};
 use serde::{Serialize, Serializer};
+use typst_syntax::Lines;
 use typst_utils::LazyHash;
 
 use crate::diag::{bail, StrResult};
@@ -286,6 +287,16 @@ impl Serialize for Bytes {
     }
 }
 
+impl TryFrom<&Bytes> for Lines<String> {
+    type Error = Utf8Error;
+
+    #[comemo::memoize]
+    fn try_from(value: &Bytes) -> Result<Lines<String>, Utf8Error> {
+        let text = value.as_str()?;
+        Ok(Lines::new(text.to_string()))
+    }
+}
+
 /// Any type that can back a byte buffer.
 trait Bytelike: Send + Sync {
     fn as_bytes(&self) -> &[u8];
diff --git a/crates/typst-library/src/foundations/calc.rs b/crates/typst-library/src/foundations/calc.rs
index a8e0eaeb3..7f481a23b 100644
--- a/crates/typst-library/src/foundations/calc.rs
+++ b/crates/typst-library/src/foundations/calc.rs
@@ -708,12 +708,13 @@ pub fn fract(
     }
 }
 
-/// Rounds a number to the nearest integer away from zero.
+/// Rounds a number to the nearest integer.
 ///
-/// Optionally, a number of decimal places can be specified.
+/// Half-integers are rounded away from zero.
 ///
-/// If the number of digits is negative, its absolute value will indicate the
-/// amount of significant integer digits to remove before the decimal point.
+/// Optionally, a number of decimal places can be specified. If negative, its
+/// absolute value will indicate the amount of significant integer digits to
+/// remove before the decimal point.
 ///
 /// Note that this function will return the same type as the operand. That is,
 /// applying `round` to a [`float`] will return a `float`, and to a [`decimal`],
diff --git a/crates/typst-library/src/foundations/content.rs b/crates/typst-library/src/foundations/content.rs
index 76cd6a222..1855bb70b 100644
--- a/crates/typst-library/src/foundations/content.rs
+++ b/crates/typst-library/src/foundations/content.rs
@@ -3,7 +3,7 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::iter::{self, Sum};
 use std::marker::PhantomData;
-use std::ops::{Add, AddAssign, Deref, DerefMut};
+use std::ops::{Add, AddAssign, ControlFlow, Deref, DerefMut};
 use std::sync::Arc;
 
 use comemo::Tracked;
@@ -414,10 +414,11 @@ impl Content {
     /// Elements produced in `show` rules will not be included in the results.
     pub fn query(&self, selector: Selector) -> Vec<Content> {
         let mut results = Vec::new();
-        self.traverse(&mut |element| {
+        let _ = self.traverse(&mut |element| -> ControlFlow<()> {
             if selector.matches(&element, None) {
                 results.push(element);
             }
+            ControlFlow::Continue(())
         });
         results
     }
@@ -427,54 +428,58 @@ impl Content {
     ///
     /// Elements produced in `show` rules will not be included in the results.
     pub fn query_first(&self, selector: &Selector) -> Option<Content> {
-        let mut result = None;
-        self.traverse(&mut |element| {
-            if result.is_none() && selector.matches(&element, None) {
-                result = Some(element);
+        self.traverse(&mut |element| -> ControlFlow<Content> {
+            if selector.matches(&element, None) {
+                ControlFlow::Break(element)
+            } else {
+                ControlFlow::Continue(())
             }
-        });
-        result
+        })
+        .break_value()
     }
 
     /// Extracts the plain text of this content.
     pub fn plain_text(&self) -> EcoString {
         let mut text = EcoString::new();
-        self.traverse(&mut |element| {
+        let _ = self.traverse(&mut |element| -> ControlFlow<()> {
             if let Some(textable) = element.with::<dyn PlainText>() {
                 textable.plain_text(&mut text);
             }
+            ControlFlow::Continue(())
         });
         text
     }
 
     /// Traverse this content.
-    fn traverse<F>(&self, f: &mut F)
+    fn traverse<F, B>(&self, f: &mut F) -> ControlFlow<B>
     where
-        F: FnMut(Content),
+        F: FnMut(Content) -> ControlFlow<B>,
     {
-        f(self.clone());
-
-        self.inner
-            .elem
-            .fields()
-            .into_iter()
-            .for_each(|(_, value)| walk_value(value, f));
-
         /// Walks a given value to find any content that matches the selector.
-        fn walk_value<F>(value: Value, f: &mut F)
+        ///
+        /// Returns early if the function gives `ControlFlow::Break`.
+        fn walk_value<F, B>(value: Value, f: &mut F) -> ControlFlow<B>
         where
-            F: FnMut(Content),
+            F: FnMut(Content) -> ControlFlow<B>,
         {
             match value {
                 Value::Content(content) => content.traverse(f),
                 Value::Array(array) => {
                     for value in array {
-                        walk_value(value, f);
+                        walk_value(value, f)?;
                     }
+                    ControlFlow::Continue(())
                 }
-                _ => {}
+                _ => ControlFlow::Continue(()),
             }
         }
+
+        // Call f on the element itself before recursively iterating its fields.
+        f(self.clone())?;
+        for (_, value) in self.inner.elem.fields() {
+            walk_value(value, f)?;
+        }
+        ControlFlow::Continue(())
     }
 }
 
diff --git a/crates/typst-library/src/foundations/int.rs b/crates/typst-library/src/foundations/int.rs
index 83a89bf8a..f65641ff1 100644
--- a/crates/typst-library/src/foundations/int.rs
+++ b/crates/typst-library/src/foundations/int.rs
@@ -1,4 +1,6 @@
-use std::num::{NonZeroI64, NonZeroIsize, NonZeroU64, NonZeroUsize, ParseIntError};
+use std::num::{
+    NonZeroI64, NonZeroIsize, NonZeroU32, NonZeroU64, NonZeroUsize, ParseIntError,
+};
 
 use ecow::{eco_format, EcoString};
 use smallvec::SmallVec;
@@ -482,3 +484,16 @@ cast! {
             "number too large"
         })?,
 }
+
+cast! {
+    NonZeroU32,
+    self => Value::Int(self.get() as _),
+    v: i64 => v
+        .try_into()
+        .and_then(|v: u32| v.try_into())
+        .map_err(|_| if v <= 0 {
+            "number must be positive"
+        } else {
+            "number too large"
+        })?,
+}
diff --git a/crates/typst-library/src/foundations/mod.rs b/crates/typst-library/src/foundations/mod.rs
index 8e3aa060d..d42be15b1 100644
--- a/crates/typst-library/src/foundations/mod.rs
+++ b/crates/typst-library/src/foundations/mod.rs
@@ -77,6 +77,7 @@ pub use {
     indexmap::IndexMap,
 };
 
+use comemo::TrackedMut;
 use ecow::EcoString;
 use typst_syntax::Spanned;
 
@@ -297,5 +298,14 @@ pub fn eval(
     for (key, value) in dict {
         scope.bind(key.into(), Binding::new(value, span));
     }
-    (engine.routines.eval_string)(engine.routines, engine.world, &text, span, mode, scope)
+
+    (engine.routines.eval_string)(
+        engine.routines,
+        engine.world,
+        TrackedMut::reborrow_mut(&mut engine.sink),
+        &text,
+        span,
+        mode,
+        scope,
+    )
 }
diff --git a/crates/typst-library/src/foundations/module.rs b/crates/typst-library/src/foundations/module.rs
index 8d9626a1a..55d8bab63 100644
--- a/crates/typst-library/src/foundations/module.rs
+++ b/crates/typst-library/src/foundations/module.rs
@@ -7,9 +7,10 @@ use typst_syntax::FileId;
 use crate::diag::{bail, DeprecationSink, StrResult};
 use crate::foundations::{repr, ty, Content, Scope, Value};
 
-/// An module of definitions.
+/// A collection of variables and functions that are commonly related to
+/// a single theme.
 ///
-/// A module
+/// A module can
 /// - be built-in
 /// - stem from a [file import]($scripting/#modules)
 /// - stem from a [package import]($scripting/#packages) (and thus indirectly
diff --git a/crates/typst-library/src/foundations/plugin.rs b/crates/typst-library/src/foundations/plugin.rs
index 31f8cd732..a04443bf4 100644
--- a/crates/typst-library/src/foundations/plugin.rs
+++ b/crates/typst-library/src/foundations/plugin.rs
@@ -151,8 +151,8 @@ pub fn plugin(
     /// A [path]($syntax/#paths) to a WebAssembly file or raw WebAssembly bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Module> {
-    let data = source.load(engine.world)?;
-    Plugin::module(data).at(source.span)
+    let loaded = source.load(engine.world)?;
+    Plugin::module(loaded.data).at(source.span)
 }
 
 #[scope]
diff --git a/crates/typst-library/src/foundations/ty.rs b/crates/typst-library/src/foundations/ty.rs
index 40f7003c3..9d7690283 100644
--- a/crates/typst-library/src/foundations/ty.rs
+++ b/crates/typst-library/src/foundations/ty.rs
@@ -39,11 +39,25 @@ use crate::foundations::{
 /// #type(image("glacier.jpg")).
 /// ```
 ///
-/// The type of `10` is `int`. Now, what is the type of `int` or even `type`?
+/// The type of `{10}` is `int`. Now, what is the type of `int` or even `type`?
 /// ```example
 /// #type(int) \
 /// #type(type)
 /// ```
+///
+/// Unlike other types like `int`, [none] and [auto] do not have a name
+/// representing them. To test if a value is one of these, compare your value to
+/// them directly, e.g:
+/// ```example
+/// #let val = none
+/// #if val == none [
+///   Yep, it's none.
+/// ]
+/// ```
+///
+/// Note that `type` will return [`content`] for all document elements. To
+/// programmatically determine which kind of content you are dealing with, see
+/// [`content.func`].
 #[ty(scope, cast)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Type(Static<NativeTypeData>);
diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index 5432df238..772bea963 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -229,10 +229,10 @@ impl Counter {
         if self.is_page() {
             let at_delta =
                 engine.introspector.page(location).get().saturating_sub(at_page.get());
-            at_state.step(NonZeroUsize::ONE, at_delta);
+            at_state.step(NonZeroUsize::ONE, at_delta as u64);
             let final_delta =
                 engine.introspector.pages().get().saturating_sub(final_page.get());
-            final_state.step(NonZeroUsize::ONE, final_delta);
+            final_state.step(NonZeroUsize::ONE, final_delta as u64);
         }
         Ok(CounterState(smallvec![at_state.first(), final_state.first()]))
     }
@@ -250,7 +250,7 @@ impl Counter {
         if self.is_page() {
             let delta =
                 engine.introspector.page(location).get().saturating_sub(page.get());
-            state.step(NonZeroUsize::ONE, delta);
+            state.step(NonZeroUsize::ONE, delta as u64);
         }
         Ok(state)
     }
@@ -319,7 +319,7 @@ impl Counter {
 
                 let delta = page.get() - prev.get();
                 if delta > 0 {
-                    state.step(NonZeroUsize::ONE, delta);
+                    state.step(NonZeroUsize::ONE, delta as u64);
                 }
             }
 
@@ -500,7 +500,7 @@ impl Counter {
         let (mut state, page) = sequence.last().unwrap().clone();
         if self.is_page() {
             let delta = engine.introspector.pages().get().saturating_sub(page.get());
-            state.step(NonZeroUsize::ONE, delta);
+            state.step(NonZeroUsize::ONE, delta as u64);
         }
         Ok(state)
     }
@@ -616,13 +616,13 @@ pub trait Count {
 
 /// Counts through elements with different levels.
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct CounterState(pub SmallVec<[usize; 3]>);
+pub struct CounterState(pub SmallVec<[u64; 3]>);
 
 impl CounterState {
     /// Get the initial counter state for the key.
     pub fn init(page: bool) -> Self {
         // Special case, because pages always start at one.
-        Self(smallvec![usize::from(page)])
+        Self(smallvec![u64::from(page)])
     }
 
     /// Advance the counter and return the numbers for the given heading.
@@ -645,7 +645,7 @@ impl CounterState {
     }
 
     /// Advance the number of the given level by the specified amount.
-    pub fn step(&mut self, level: NonZeroUsize, by: usize) {
+    pub fn step(&mut self, level: NonZeroUsize, by: u64) {
         let level = level.get();
 
         while self.0.len() < level {
@@ -657,7 +657,7 @@ impl CounterState {
     }
 
     /// Get the first number of the state.
-    pub fn first(&self) -> usize {
+    pub fn first(&self) -> u64 {
         self.0.first().copied().unwrap_or(1)
     }
 
@@ -675,7 +675,7 @@ impl CounterState {
 cast! {
     CounterState,
     self => Value::Array(self.0.into_iter().map(IntoValue::into_value).collect()),
-    num: usize => Self(smallvec![num]),
+    num: u64 => Self(smallvec![num]),
     array: Array => Self(array
         .into_iter()
         .map(Value::cast)
@@ -758,7 +758,7 @@ impl Show for Packed<CounterDisplayElem> {
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct ManualPageCounter {
     physical: NonZeroUsize,
-    logical: usize,
+    logical: u64,
 }
 
 impl ManualPageCounter {
@@ -773,7 +773,7 @@ impl ManualPageCounter {
     }
 
     /// Get the current logical page counter state.
-    pub fn logical(&self) -> usize {
+    pub fn logical(&self) -> u64 {
         self.logical
     }
 
diff --git a/crates/typst-library/src/layout/grid/mod.rs b/crates/typst-library/src/layout/grid/mod.rs
index 6616c3311..52621c647 100644
--- a/crates/typst-library/src/layout/grid/mod.rs
+++ b/crates/typst-library/src/layout/grid/mod.rs
@@ -1,6 +1,6 @@
 pub mod resolve;
 
-use std::num::NonZeroUsize;
+use std::num::{NonZeroU32, NonZeroUsize};
 use std::sync::Arc;
 
 use comemo::Track;
@@ -468,6 +468,17 @@ pub struct GridHeader {
     #[default(true)]
     pub repeat: bool,
 
+    /// The level of the header. Must not be zero.
+    ///
+    /// This allows repeating multiple headers at once. Headers with different
+    /// levels can repeat together, as long as they have ascending levels.
+    ///
+    /// Notably, when a header with a lower level starts repeating, all higher
+    /// or equal level headers stop repeating (they are "replaced" by the new
+    /// header).
+    #[default(NonZeroU32::ONE)]
+    pub level: NonZeroU32,
+
     /// The cells and lines within the header.
     #[variadic]
     pub children: Vec<GridItem>,
@@ -755,7 +766,14 @@ impl Show for Packed<GridCell> {
 
 impl Default for Packed<GridCell> {
     fn default() -> Self {
-        Packed::new(GridCell::new(Content::default()))
+        Packed::new(
+            // Explicitly set colspan and rowspan to ensure they won't be
+            // overridden by set rules (default cells are created after
+            // colspans and rowspans are processed in the resolver)
+            GridCell::new(Content::default())
+                .with_colspan(NonZeroUsize::ONE)
+                .with_rowspan(NonZeroUsize::ONE),
+        )
     }
 }
 
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index 08d0130da..baf6b7383 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -1,4 +1,5 @@
-use std::num::NonZeroUsize;
+use std::num::{NonZeroU32, NonZeroUsize};
+use std::ops::{Deref, DerefMut, Range};
 use std::sync::Arc;
 
 use ecow::eco_format;
@@ -20,6 +21,8 @@ use typst_library::Dir;
 use typst_syntax::Span;
 use typst_utils::NonZeroExt;
 
+use crate::introspection::SplitLocator;
+
 /// Convert a grid to a cell grid.
 #[typst_macros::time(span = elem.span())]
 pub fn grid_to_cellgrid<'a>(
@@ -45,6 +48,7 @@ pub fn grid_to_cellgrid<'a>(
     let children = elem.children.iter().map(|child| match child {
         GridChild::Header(header) => ResolvableGridChild::Header {
             repeat: header.repeat(styles),
+            level: header.level(styles),
             span: header.span(),
             items: header.children.iter().map(resolve_item),
         },
@@ -57,7 +61,7 @@ pub fn grid_to_cellgrid<'a>(
             ResolvableGridChild::Item(grid_item_to_resolvable(item, styles))
         }
     });
-    CellGrid::resolve(
+    resolve_cellgrid(
         tracks,
         gutter,
         locator,
@@ -98,6 +102,7 @@ pub fn table_to_cellgrid<'a>(
     let children = elem.children.iter().map(|child| match child {
         TableChild::Header(header) => ResolvableGridChild::Header {
             repeat: header.repeat(styles),
+            level: header.level(styles),
             span: header.span(),
             items: header.children.iter().map(resolve_item),
         },
@@ -110,7 +115,7 @@ pub fn table_to_cellgrid<'a>(
             ResolvableGridChild::Item(table_item_to_resolvable(item, styles))
         }
     });
-    CellGrid::resolve(
+    resolve_cellgrid(
         tracks,
         gutter,
         locator,
@@ -421,41 +426,79 @@ pub struct Line {
 }
 
 /// A repeatable grid header. Starts at the first row.
+#[derive(Debug)]
 pub struct Header {
-    /// The index after the last row included in this header.
-    pub end: usize,
+    /// The range of rows included in this header.
+    pub range: Range<usize>,
+    /// The header's level.
+    ///
+    /// Higher level headers repeat together with lower level headers. If a
+    /// lower level header stops repeating, all higher level headers do as
+    /// well.
+    pub level: u32,
+    /// Whether this header cannot be repeated nor should have orphan
+    /// prevention because it would be about to cease repetition, either
+    /// because it is followed by headers of conflicting levels, or because
+    /// it is at the end of the table (possibly followed by some footers at the
+    /// end).
+    pub short_lived: bool,
 }
 
 /// A repeatable grid footer. Stops at the last row.
+#[derive(Debug)]
 pub struct Footer {
     /// The first row included in this footer.
     pub start: usize,
+    /// The index after the last row included in this footer.
+    pub end: usize,
+    /// The footer's level.
+    ///
+    /// Used similarly to header level.
+    pub level: u32,
 }
 
-/// A possibly repeatable grid object.
+impl Footer {
+    /// The footer's range of included rows.
+    #[inline]
+    pub fn range(&self) -> Range<usize> {
+        self.start..self.end
+    }
+}
+
+/// A possibly repeatable grid child (header or footer).
+///
 /// It still exists even when not repeatable, but must not have additional
 /// considerations by grid layout, other than for consistency (such as making
 /// a certain group of rows unbreakable).
-pub enum Repeatable<T> {
-    Repeated(T),
-    NotRepeated(T),
+pub struct Repeatable<T> {
+    inner: T,
+
+    /// Whether the user requested the child to repeat.
+    pub repeated: bool,
+}
+
+impl<T> Deref for Repeatable<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for Repeatable<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
 }
 
 impl<T> Repeatable<T> {
-    /// Gets the value inside this repeatable, regardless of whether
-    /// it repeats.
-    pub fn unwrap(&self) -> &T {
-        match self {
-            Self::Repeated(repeated) => repeated,
-            Self::NotRepeated(not_repeated) => not_repeated,
-        }
-    }
-
     /// Returns `Some` if the value is repeated, `None` otherwise.
+    #[inline]
     pub fn as_repeated(&self) -> Option<&T> {
-        match self {
-            Self::Repeated(repeated) => Some(repeated),
-            Self::NotRepeated(_) => None,
+        if self.repeated {
+            Some(&self.inner)
+        } else {
+            None
         }
     }
 }
@@ -612,7 +655,7 @@ impl<'a> Entry<'a> {
 
 /// Any grid child, which can be either a header or an item.
 pub enum ResolvableGridChild<T: ResolvableCell, I> {
-    Header { repeat: bool, span: Span, items: I },
+    Header { repeat: bool, level: NonZeroU32, span: Span, items: I },
     Footer { repeat: bool, span: Span, items: I },
     Item(ResolvableGridItem<T>),
 }
@@ -633,8 +676,8 @@ pub struct CellGrid<'a> {
     /// Gutter rows are not included.
     /// Contains up to 'rows_without_gutter.len() + 1' vectors of lines.
     pub hlines: Vec<Vec<Line>>,
-    /// The repeatable header of this grid.
-    pub header: Option<Repeatable<Header>>,
+    /// The repeatable headers of this grid.
+    pub headers: Vec<Repeatable<Header>>,
     /// The repeatable footer of this grid.
     pub footer: Option<Repeatable<Footer>>,
     /// Whether this grid has gutters.
@@ -649,773 +692,7 @@ impl<'a> CellGrid<'a> {
         cells: impl IntoIterator<Item = Cell<'a>>,
     ) -> Self {
         let entries = cells.into_iter().map(Entry::Cell).collect();
-        Self::new_internal(tracks, gutter, vec![], vec![], None, None, entries)
-    }
-
-    /// Resolves and positions all cells in the grid before creating it.
-    /// Allows them to keep track of their final properties and positions
-    /// and adjust their fields accordingly.
-    /// Cells must implement Clone as they will be owned. Additionally, they
-    /// must implement Default in order to fill positions in the grid which
-    /// weren't explicitly specified by the user with empty cells.
-    #[allow(clippy::too_many_arguments)]
-    pub fn resolve<T, C, I>(
-        tracks: Axes<&[Sizing]>,
-        gutter: Axes<&[Sizing]>,
-        locator: Locator<'a>,
-        children: C,
-        fill: &Celled<Option<Paint>>,
-        align: &Celled<Smart<Alignment>>,
-        inset: &Celled<Sides<Option<Rel<Length>>>>,
-        stroke: &ResolvedCelled<Sides<Option<Option<Arc<Stroke>>>>>,
-        engine: &mut Engine,
-        styles: StyleChain,
-        span: Span,
-    ) -> SourceResult<Self>
-    where
-        T: ResolvableCell + Default,
-        I: Iterator<Item = ResolvableGridItem<T>>,
-        C: IntoIterator<Item = ResolvableGridChild<T, I>>,
-        C::IntoIter: ExactSizeIterator,
-    {
-        let mut locator = locator.split();
-
-        // Number of content columns: Always at least one.
-        let c = tracks.x.len().max(1);
-
-        // Lists of lines.
-        // Horizontal lines are only pushed later to be able to check for row
-        // validity, since the amount of rows isn't known until all items were
-        // analyzed in the for loop below.
-        // We keep their spans so we can report errors later.
-        // The additional boolean indicates whether the hline had an automatic
-        // 'y' index, and is used to change the index of hlines at the top of a
-        // header or footer.
-        let mut pending_hlines: Vec<(Span, Line, bool)> = vec![];
-
-        // For consistency, only push vertical lines later as well.
-        let mut pending_vlines: Vec<(Span, Line)> = vec![];
-        let has_gutter = gutter.any(|tracks| !tracks.is_empty());
-
-        let mut header: Option<Header> = None;
-        let mut repeat_header = false;
-
-        // Stores where the footer is supposed to end, its span, and the
-        // actual footer structure.
-        let mut footer: Option<(usize, Span, Footer)> = None;
-        let mut repeat_footer = false;
-
-        // Resolves the breakability of a cell. Cells that span at least one
-        // auto-sized row or gutter are considered breakable.
-        let resolve_breakable = |y, rowspan| {
-            let auto = Sizing::Auto;
-            let zero = Sizing::Rel(Rel::zero());
-            tracks
-                .y
-                .iter()
-                .chain(std::iter::repeat(tracks.y.last().unwrap_or(&auto)))
-                .skip(y)
-                .take(rowspan)
-                .any(|row| row == &Sizing::Auto)
-                || gutter
-                    .y
-                    .iter()
-                    .chain(std::iter::repeat(gutter.y.last().unwrap_or(&zero)))
-                    .skip(y)
-                    .take(rowspan - 1)
-                    .any(|row_gutter| row_gutter == &Sizing::Auto)
-        };
-
-        // We can't just use the cell's index in the 'cells' vector to
-        // determine its automatic position, since cells could have arbitrary
-        // positions, so the position of a cell in 'cells' can differ from its
-        // final position in 'resolved_cells' (see below).
-        // Therefore, we use a counter, 'auto_index', to determine the position
-        // of the next cell with (x: auto, y: auto). It is only stepped when
-        // a cell with (x: auto, y: auto), usually the vast majority, is found.
-        let mut auto_index: usize = 0;
-
-        // We have to rebuild the grid to account for arbitrary positions.
-        // Create at least 'children.len()' positions, since there could be at
-        // least 'children.len()' cells (if no explicit lines were specified),
-        // even though some of them might be placed in arbitrary positions and
-        // thus cause the grid to expand.
-        // Additionally, make sure we allocate up to the next multiple of 'c',
-        // since each row will have 'c' cells, even if the last few cells
-        // weren't explicitly specified by the user.
-        // We apply '% c' twice so that the amount of cells potentially missing
-        // is zero when 'children.len()' is already a multiple of 'c' (thus
-        // 'children.len() % c' would be zero).
-        let children = children.into_iter();
-        let Some(child_count) = children.len().checked_add((c - children.len() % c) % c)
-        else {
-            bail!(span, "too many cells or lines were given")
-        };
-        let mut resolved_cells: Vec<Option<Entry>> = Vec::with_capacity(child_count);
-        for child in children {
-            let mut is_header = false;
-            let mut is_footer = false;
-            let mut child_start = usize::MAX;
-            let mut child_end = 0;
-            let mut child_span = Span::detached();
-            let mut start_new_row = false;
-            let mut first_index_of_top_hlines = usize::MAX;
-            let mut first_index_of_non_top_hlines = usize::MAX;
-
-            let (header_footer_items, simple_item) = match child {
-                ResolvableGridChild::Header { repeat, span, items, .. } => {
-                    if header.is_some() {
-                        bail!(span, "cannot have more than one header");
-                    }
-
-                    is_header = true;
-                    child_span = span;
-                    repeat_header = repeat;
-
-                    // If any cell in the header is automatically positioned,
-                    // have it skip to the next row. This is to avoid having a
-                    // header after a partially filled row just add cells to
-                    // that row instead of starting a new one.
-                    // FIXME: Revise this approach when headers can start from
-                    // arbitrary rows.
-                    start_new_row = true;
-
-                    // Any hlines at the top of the header will start at this
-                    // index.
-                    first_index_of_top_hlines = pending_hlines.len();
-
-                    (Some(items), None)
-                }
-                ResolvableGridChild::Footer { repeat, span, items, .. } => {
-                    if footer.is_some() {
-                        bail!(span, "cannot have more than one footer");
-                    }
-
-                    is_footer = true;
-                    child_span = span;
-                    repeat_footer = repeat;
-
-                    // If any cell in the footer is automatically positioned,
-                    // have it skip to the next row. This is to avoid having a
-                    // footer after a partially filled row just add cells to
-                    // that row instead of starting a new one.
-                    start_new_row = true;
-
-                    // Any hlines at the top of the footer will start at this
-                    // index.
-                    first_index_of_top_hlines = pending_hlines.len();
-
-                    (Some(items), None)
-                }
-                ResolvableGridChild::Item(item) => (None, Some(item)),
-            };
-
-            let items = header_footer_items
-                .into_iter()
-                .flatten()
-                .chain(simple_item.into_iter());
-            for item in items {
-                let cell = match item {
-                    ResolvableGridItem::HLine {
-                        y,
-                        start,
-                        end,
-                        stroke,
-                        span,
-                        position,
-                    } => {
-                        let has_auto_y = y.is_auto();
-                        let y = y.unwrap_or_else(|| {
-                            // Avoid placing the hline inside consecutive
-                            // rowspans occupying all columns, as it'd just
-                            // disappear, at least when there's no column
-                            // gutter.
-                            skip_auto_index_through_fully_merged_rows(
-                                &resolved_cells,
-                                &mut auto_index,
-                                c,
-                            );
-
-                            // When no 'y' is specified for the hline, we place
-                            // it under the latest automatically positioned
-                            // cell.
-                            // The current value of the auto index is always
-                            // the index of the latest automatically positioned
-                            // cell placed plus one (that's what we do in
-                            // 'resolve_cell_position'), so we subtract 1 to
-                            // get that cell's index, and place the hline below
-                            // its row. The exception is when the auto_index is
-                            // 0, meaning no automatically positioned cell was
-                            // placed yet. In that case, we place the hline at
-                            // the top of the table.
-                            //
-                            // Exceptionally, the hline will be placed before
-                            // the minimum auto index if the current auto index
-                            // from previous iterations is smaller than the
-                            // minimum it should have for the current grid
-                            // child. Effectively, this means that a hline at
-                            // the start of a header will always appear above
-                            // that header's first row. Similarly for footers.
-                            auto_index
-                                .checked_sub(1)
-                                .map_or(0, |last_auto_index| last_auto_index / c + 1)
-                        });
-                        if end.is_some_and(|end| end.get() < start) {
-                            bail!(span, "line cannot end before it starts");
-                        }
-                        let line = Line { index: y, start, end, stroke, position };
-
-                        // Since the amount of rows is dynamic, delay placing
-                        // hlines until after all cells were placed so we can
-                        // properly verify if they are valid. Note that we
-                        // can't place hlines even if we already know they
-                        // would be in a valid row, since it's possible that we
-                        // pushed pending hlines in the same row as this one in
-                        // previous iterations, and we need to ensure that
-                        // hlines from previous iterations are pushed to the
-                        // final vector of hlines first - the order of hlines
-                        // must be kept, as this matters when determining which
-                        // one "wins" in case of conflict. Pushing the current
-                        // hline before we push pending hlines later would
-                        // change their order!
-                        pending_hlines.push((span, line, has_auto_y));
-                        continue;
-                    }
-                    ResolvableGridItem::VLine {
-                        x,
-                        start,
-                        end,
-                        stroke,
-                        span,
-                        position,
-                    } => {
-                        let x = x.unwrap_or_else(|| {
-                            // When no 'x' is specified for the vline, we place
-                            // it after the latest automatically positioned
-                            // cell.
-                            // The current value of the auto index is always
-                            // the index of the latest automatically positioned
-                            // cell placed plus one (that's what we do in
-                            // 'resolve_cell_position'), so we subtract 1 to
-                            // get that cell's index, and place the vline after
-                            // its column. The exception is when the auto_index
-                            // is 0, meaning no automatically positioned cell
-                            // was placed yet. In that case, we place the vline
-                            // to the left of the table.
-                            //
-                            // Exceptionally, a vline is also placed to the
-                            // left of the table if we should start a new row
-                            // for the next automatically positioned cell.
-                            // For example, this means that a vline at
-                            // the beginning of a header will be placed to its
-                            // left rather than after the previous
-                            // automatically positioned cell. Same for footers.
-                            auto_index
-                                .checked_sub(1)
-                                .filter(|_| !start_new_row)
-                                .map_or(0, |last_auto_index| last_auto_index % c + 1)
-                        });
-                        if end.is_some_and(|end| end.get() < start) {
-                            bail!(span, "line cannot end before it starts");
-                        }
-                        let line = Line { index: x, start, end, stroke, position };
-
-                        // For consistency with hlines, we only push vlines to
-                        // the final vector of vlines after processing every
-                        // cell.
-                        pending_vlines.push((span, line));
-                        continue;
-                    }
-                    ResolvableGridItem::Cell(cell) => cell,
-                };
-                let cell_span = cell.span();
-                let colspan = cell.colspan(styles).get();
-                let rowspan = cell.rowspan(styles).get();
-                // Let's calculate the cell's final position based on its
-                // requested position.
-                let resolved_index = {
-                    let cell_x = cell.x(styles);
-                    let cell_y = cell.y(styles);
-                    resolve_cell_position(
-                        cell_x,
-                        cell_y,
-                        colspan,
-                        rowspan,
-                        &resolved_cells,
-                        &mut auto_index,
-                        &mut start_new_row,
-                        c,
-                    )
-                    .at(cell_span)?
-                };
-                let x = resolved_index % c;
-                let y = resolved_index / c;
-
-                if colspan > c - x {
-                    bail!(
-                        cell_span,
-                        "cell's colspan would cause it to exceed the available column(s)";
-                        hint: "try placing the cell in another position or reducing its colspan"
-                    )
-                }
-
-                let Some(largest_index) = c
-                    .checked_mul(rowspan - 1)
-                    .and_then(|full_rowspan_offset| {
-                        resolved_index.checked_add(full_rowspan_offset)
-                    })
-                    .and_then(|last_row_pos| last_row_pos.checked_add(colspan - 1))
-                else {
-                    bail!(
-                        cell_span,
-                        "cell would span an exceedingly large position";
-                        hint: "try reducing the cell's rowspan or colspan"
-                    )
-                };
-
-                // Let's resolve the cell so it can determine its own fields
-                // based on its final position.
-                let cell = cell.resolve_cell(
-                    x,
-                    y,
-                    &fill.resolve(engine, styles, x, y)?,
-                    align.resolve(engine, styles, x, y)?,
-                    inset.resolve(engine, styles, x, y)?,
-                    stroke.resolve(engine, styles, x, y)?,
-                    resolve_breakable(y, rowspan),
-                    locator.next(&cell_span),
-                    styles,
-                );
-
-                if largest_index >= resolved_cells.len() {
-                    // Ensure the length of the vector of resolved cells is
-                    // always a multiple of 'c' by pushing full rows every
-                    // time. Here, we add enough absent positions (later
-                    // converted to empty cells) to ensure the last row in the
-                    // new vector length is completely filled. This is
-                    // necessary so that those positions, even if not
-                    // explicitly used at the end, are eventually susceptible
-                    // to show rules and receive grid styling, as they will be
-                    // resolved as empty cells in a second loop below.
-                    let Some(new_len) = largest_index
-                        .checked_add(1)
-                        .and_then(|new_len| new_len.checked_add((c - new_len % c) % c))
-                    else {
-                        bail!(cell_span, "cell position too large")
-                    };
-
-                    // Here, the cell needs to be placed in a position which
-                    // doesn't exist yet in the grid (out of bounds). We will
-                    // add enough absent positions for this to be possible.
-                    // They must be absent as no cells actually occupy them
-                    // (they can be overridden later); however, if no cells
-                    // occupy them as we finish building the grid, then such
-                    // positions will be replaced by empty cells.
-                    resolved_cells.resize_with(new_len, || None);
-                }
-
-                // The vector is large enough to contain the cell, so we can
-                // just index it directly to access the position it will be
-                // placed in. However, we still need to ensure we won't try to
-                // place a cell where there already is one.
-                let slot = &mut resolved_cells[resolved_index];
-                if slot.is_some() {
-                    bail!(
-                        cell_span,
-                        "attempted to place a second cell at column {x}, row {y}";
-                        hint: "try specifying your cells in a different order"
-                    );
-                }
-
-                *slot = Some(Entry::Cell(cell));
-
-                // Now, if the cell spans more than one row or column, we fill
-                // the spanned positions in the grid with Entry::Merged
-                // pointing to the original cell as its parent.
-                for rowspan_offset in 0..rowspan {
-                    let spanned_y = y + rowspan_offset;
-                    let first_row_index = resolved_index + c * rowspan_offset;
-                    for (colspan_offset, slot) in resolved_cells[first_row_index..]
-                        [..colspan]
-                        .iter_mut()
-                        .enumerate()
-                    {
-                        let spanned_x = x + colspan_offset;
-                        if spanned_x == x && spanned_y == y {
-                            // This is the parent cell.
-                            continue;
-                        }
-                        if slot.is_some() {
-                            bail!(
-                                cell_span,
-                                "cell would span a previously placed cell at column {spanned_x}, row {spanned_y}";
-                                hint: "try specifying your cells in a different order or reducing the cell's rowspan or colspan"
-                            )
-                        }
-                        *slot = Some(Entry::Merged { parent: resolved_index });
-                    }
-                }
-
-                if is_header || is_footer {
-                    // Ensure each cell in a header or footer is fully
-                    // contained within it.
-                    child_start = child_start.min(y);
-                    child_end = child_end.max(y + rowspan);
-
-                    if start_new_row && child_start <= auto_index.div_ceil(c) {
-                        // No need to start a new row as we already include
-                        // the row of the next automatically positioned cell in
-                        // the header or footer.
-                        start_new_row = false;
-                    }
-
-                    if !start_new_row {
-                        // From now on, upcoming hlines won't be at the top of
-                        // the child, as the first automatically positioned
-                        // cell was placed.
-                        first_index_of_non_top_hlines =
-                            first_index_of_non_top_hlines.min(pending_hlines.len());
-                    }
-                }
-            }
-
-            if (is_header || is_footer) && child_start == usize::MAX {
-                // Empty header/footer: consider the header/footer to be
-                // at the next empty row after the latest auto index.
-                auto_index = find_next_empty_row(&resolved_cells, auto_index, c);
-                child_start = auto_index.div_ceil(c);
-                child_end = child_start + 1;
-
-                if resolved_cells.len() <= c * child_start {
-                    // Ensure the automatically chosen row actually exists.
-                    resolved_cells.resize_with(c * (child_start + 1), || None);
-                }
-            }
-
-            if is_header {
-                if child_start != 0 {
-                    bail!(
-                        child_span,
-                        "header must start at the first row";
-                        hint: "remove any rows before the header"
-                    );
-                }
-
-                header = Some(Header {
-                    // Later on, we have to correct this number in case there
-                    // is gutter. But only once all cells have been analyzed
-                    // and the header has fully expanded in the fixup loop
-                    // below.
-                    end: child_end,
-                });
-            }
-
-            if is_footer {
-                // Only check if the footer is at the end later, once we know
-                // the final amount of rows.
-                footer = Some((
-                    child_end,
-                    child_span,
-                    Footer {
-                        // Later on, we have to correct this number in case there
-                        // is gutter, but only once all cells have been analyzed
-                        // and the header's and footer's exact boundaries are
-                        // known. That is because the gutter row immediately
-                        // before the footer might not be included as part of
-                        // the footer if it is contained within the header.
-                        start: child_start,
-                    },
-                ));
-            }
-
-            if is_header || is_footer {
-                let amount_hlines = pending_hlines.len();
-                for (_, top_hline, has_auto_y) in pending_hlines
-                    .get_mut(
-                        first_index_of_top_hlines
-                            ..first_index_of_non_top_hlines.min(amount_hlines),
-                    )
-                    .unwrap_or(&mut [])
-                {
-                    if *has_auto_y {
-                        // Move this hline to the top of the child, as it was
-                        // placed before the first automatically positioned cell
-                        // and had an automatic index.
-                        top_hline.index = child_start;
-                    }
-                }
-
-                // Next automatically positioned cell goes under this header.
-                // FIXME: Consider only doing this if the header has any fully
-                // automatically positioned cells. Otherwise,
-                // `resolve_cell_position` should be smart enough to skip
-                // upcoming headers.
-                // Additionally, consider that cells with just an 'x' override
-                // could end up going too far back and making previous
-                // non-header rows into header rows (maybe they should be
-                // placed at the first row that is fully empty or something).
-                // Nothing we can do when both 'x' and 'y' were overridden, of
-                // course.
-                // None of the above are concerns for now, as headers must
-                // start at the first row.
-                auto_index = auto_index.max(c * child_end);
-            }
-        }
-
-        // If the user specified cells occupying less rows than the given rows,
-        // we shall expand the grid so that it has at least the given amount of
-        // rows.
-        let Some(expected_total_cells) = c.checked_mul(tracks.y.len()) else {
-            bail!(span, "too many rows were specified");
-        };
-        let missing_cells = expected_total_cells.saturating_sub(resolved_cells.len());
-
-        // Fixup phase (final step in cell grid generation):
-        // 1. Replace absent entries by resolved empty cells, and produce a
-        // vector of 'Entry' from 'Option<Entry>'.
-        // 2. Add enough empty cells to the end of the grid such that it has at
-        // least the given amount of rows.
-        // 3. If any cells were added to the header's rows after the header's
-        // creation, ensure the header expands enough to accommodate them
-        // across all of their spanned rows. Same for the footer.
-        // 4. If any cells before the footer try to span it, error.
-        let resolved_cells = resolved_cells
-            .into_iter()
-            .chain(std::iter::repeat_with(|| None).take(missing_cells))
-            .enumerate()
-            .map(|(i, cell)| {
-                if let Some(cell) = cell {
-                    if let Some(parent_cell) = cell.as_cell() {
-                        if let Some(header) = &mut header
-                        {
-                            let y = i / c;
-                            if y < header.end {
-                                // Ensure the header expands enough such that
-                                // all cells inside it, even those added later,
-                                // are fully contained within the header.
-                                // FIXME: check if start < y < end when start can
-                                // be != 0.
-                                // FIXME: when start can be != 0, decide what
-                                // happens when a cell after the header placed
-                                // above it tries to span the header (either
-                                // error or expand upwards).
-                                header.end = header.end.max(y + parent_cell.rowspan.get());
-                            }
-                        }
-
-                        if let Some((end, footer_span, footer)) = &mut footer {
-                            let x = i % c;
-                            let y = i / c;
-                            let cell_end = y + parent_cell.rowspan.get();
-                            if y < footer.start && cell_end > footer.start {
-                                // Don't allow a cell before the footer to span
-                                // it. Surely, we could move the footer to
-                                // start at where this cell starts, so this is
-                                // more of a design choice, as it's unlikely
-                                // for the user to intentionally include a cell
-                                // before the footer spanning it but not
-                                // being repeated with it.
-                                bail!(
-                                    *footer_span,
-                                    "footer would conflict with a cell placed before it at column {x} row {y}";
-                                    hint: "try reducing that cell's rowspan or moving the footer"
-                                );
-                            }
-                            if y >= footer.start && y < *end {
-                                // Expand the footer to include all rows
-                                // spanned by this cell, as it is inside the
-                                // footer.
-                                *end = (*end).max(cell_end);
-                            }
-                        }
-                    }
-
-                    Ok(cell)
-                } else {
-                    let x = i % c;
-                    let y = i / c;
-
-                    // Ensure all absent entries are affected by show rules and
-                    // grid styling by turning them into resolved empty cells.
-                    let new_cell = T::default().resolve_cell(
-                        x,
-                        y,
-                        &fill.resolve(engine, styles, x, y)?,
-                        align.resolve(engine, styles, x, y)?,
-                        inset.resolve(engine, styles, x, y)?,
-                        stroke.resolve(engine, styles, x, y)?,
-                        resolve_breakable(y, 1),
-                        locator.next(&()),
-                        styles,
-                    );
-                    Ok(Entry::Cell(new_cell))
-                }
-            })
-            .collect::<SourceResult<Vec<Entry>>>()?;
-
-        // Populate the final lists of lines.
-        // For each line type (horizontal or vertical), we keep a vector for
-        // every group of lines with the same index.
-        let mut vlines: Vec<Vec<Line>> = vec![];
-        let mut hlines: Vec<Vec<Line>> = vec![];
-        let row_amount = resolved_cells.len().div_ceil(c);
-
-        for (line_span, line, _) in pending_hlines {
-            let y = line.index;
-            if y > row_amount {
-                bail!(line_span, "cannot place horizontal line at invalid row {y}");
-            }
-            if y == row_amount && line.position == LinePosition::After {
-                bail!(
-                    line_span,
-                    "cannot place horizontal line at the 'bottom' position of the bottom border (y = {y})";
-                    hint: "set the line's position to 'top' or place it at a smaller 'y' index"
-                );
-            }
-            let line = if line.position == LinePosition::After
-                && (!has_gutter || y + 1 == row_amount)
-            {
-                // Just place the line on top of the next row if
-                // there's no gutter and the line should be placed
-                // after the one with given index.
-                //
-                // Note that placing after the last row is also the same as
-                // just placing on the grid's bottom border, even with
-                // gutter.
-                Line {
-                    index: y + 1,
-                    position: LinePosition::Before,
-                    ..line
-                }
-            } else {
-                line
-            };
-            let y = line.index;
-
-            if hlines.len() <= y {
-                hlines.resize_with(y + 1, Vec::new);
-            }
-            hlines[y].push(line);
-        }
-
-        for (line_span, line) in pending_vlines {
-            let x = line.index;
-            if x > c {
-                bail!(line_span, "cannot place vertical line at invalid column {x}");
-            }
-            if x == c && line.position == LinePosition::After {
-                bail!(
-                    line_span,
-                    "cannot place vertical line at the 'end' position of the end border (x = {c})";
-                    hint: "set the line's position to 'start' or place it at a smaller 'x' index"
-                );
-            }
-            let line =
-                if line.position == LinePosition::After && (!has_gutter || x + 1 == c) {
-                    // Just place the line before the next column if
-                    // there's no gutter and the line should be placed
-                    // after the one with given index.
-                    //
-                    // Note that placing after the last column is also the
-                    // same as just placing on the grid's end border, even
-                    // with gutter.
-                    Line {
-                        index: x + 1,
-                        position: LinePosition::Before,
-                        ..line
-                    }
-                } else {
-                    line
-                };
-            let x = line.index;
-
-            if vlines.len() <= x {
-                vlines.resize_with(x + 1, Vec::new);
-            }
-            vlines[x].push(line);
-        }
-
-        let header = header
-            .map(|mut header| {
-                // Repeat the gutter below a header (hence why we don't
-                // subtract 1 from the gutter case).
-                // Don't do this if there are no rows under the header.
-                if has_gutter {
-                    // - 'header.end' is always 'last y + 1'. The header stops
-                    // before that row.
-                    // - Therefore, '2 * header.end' will be 2 * (last y + 1),
-                    // which is the adjusted index of the row before which the
-                    // header stops, meaning it will still stop right before it
-                    // even with gutter thanks to the multiplication below.
-                    // - This means that it will span all rows up to
-                    // '2 * (last y + 1) - 1 = 2 * last y + 1', which equates
-                    // to the index of the gutter row right below the header,
-                    // which is what we want (that gutter spacing should be
-                    // repeated across pages to maintain uniformity).
-                    header.end *= 2;
-
-                    // If the header occupies the entire grid, ensure we don't
-                    // include an extra gutter row when it doesn't exist, since
-                    // the last row of the header is at the very bottom,
-                    // therefore '2 * last y + 1' is not a valid index.
-                    let row_amount = (2 * row_amount).saturating_sub(1);
-                    header.end = header.end.min(row_amount);
-                }
-                header
-            })
-            .map(|header| {
-                if repeat_header {
-                    Repeatable::Repeated(header)
-                } else {
-                    Repeatable::NotRepeated(header)
-                }
-            });
-
-        let footer = footer
-            .map(|(footer_end, footer_span, mut footer)| {
-                if footer_end != row_amount {
-                    bail!(footer_span, "footer must end at the last row");
-                }
-
-                let header_end =
-                    header.as_ref().map(Repeatable::unwrap).map(|header| header.end);
-
-                if has_gutter {
-                    // Convert the footer's start index to post-gutter coordinates.
-                    footer.start *= 2;
-
-                    // Include the gutter right before the footer, unless there is
-                    // none, or the gutter is already included in the header (no
-                    // rows between the header and the footer).
-                    if header_end != Some(footer.start) {
-                        footer.start = footer.start.saturating_sub(1);
-                    }
-                }
-
-                if header_end.is_some_and(|header_end| header_end > footer.start) {
-                    bail!(footer_span, "header and footer must not have common rows");
-                }
-
-                Ok(footer)
-            })
-            .transpose()?
-            .map(|footer| {
-                if repeat_footer {
-                    Repeatable::Repeated(footer)
-                } else {
-                    Repeatable::NotRepeated(footer)
-                }
-            });
-
-        Ok(Self::new_internal(
-            tracks,
-            gutter,
-            vlines,
-            hlines,
-            header,
-            footer,
-            resolved_cells,
-        ))
+        Self::new_internal(tracks, gutter, vec![], vec![], vec![], None, entries)
     }
 
     /// Generates the cell grid, given the tracks and resolved entries.
@@ -1424,7 +701,7 @@ impl<'a> CellGrid<'a> {
         gutter: Axes<&[Sizing]>,
         vlines: Vec<Vec<Line>>,
         hlines: Vec<Vec<Line>>,
-        header: Option<Repeatable<Header>>,
+        headers: Vec<Repeatable<Header>>,
         footer: Option<Repeatable<Footer>>,
         entries: Vec<Entry<'a>>,
     ) -> Self {
@@ -1432,14 +709,14 @@ impl<'a> CellGrid<'a> {
         let mut rows = vec![];
 
         // Number of content columns: Always at least one.
-        let c = tracks.x.len().max(1);
+        let num_cols = tracks.x.len().max(1);
 
         // Number of content rows: At least as many as given, but also at least
         // as many as needed to place each item.
-        let r = {
+        let num_rows = {
             let len = entries.len();
             let given = tracks.y.len();
-            let needed = len / c + (len % c).clamp(0, 1);
+            let needed = len / num_cols + (len % num_cols).clamp(0, 1);
             given.max(needed)
         };
 
@@ -1451,7 +728,7 @@ impl<'a> CellGrid<'a> {
         };
 
         // Collect content and gutter columns.
-        for x in 0..c {
+        for x in 0..num_cols {
             cols.push(get_or(tracks.x, x, auto));
             if has_gutter {
                 cols.push(get_or(gutter.x, x, zero));
@@ -1459,7 +736,7 @@ impl<'a> CellGrid<'a> {
         }
 
         // Collect content and gutter rows.
-        for y in 0..r {
+        for y in 0..num_rows {
             rows.push(get_or(tracks.y, y, auto));
             if has_gutter {
                 rows.push(get_or(gutter.y, y, zero));
@@ -1478,7 +755,7 @@ impl<'a> CellGrid<'a> {
             entries,
             vlines,
             hlines,
-            header,
+            headers,
             footer,
             has_gutter,
         }
@@ -1613,6 +890,1224 @@ impl<'a> CellGrid<'a> {
             self.cols.len()
         }
     }
+
+    #[inline]
+    pub fn has_repeated_headers(&self) -> bool {
+        self.headers.iter().any(|h| h.repeated)
+    }
+}
+
+/// Resolves and positions all cells in the grid before creating it.
+/// Allows them to keep track of their final properties and positions
+/// and adjust their fields accordingly.
+/// Cells must implement Clone as they will be owned. Additionally, they
+/// must implement Default in order to fill positions in the grid which
+/// weren't explicitly specified by the user with empty cells.
+#[allow(clippy::too_many_arguments)]
+pub fn resolve_cellgrid<'a, 'x, T, C, I>(
+    tracks: Axes<&'a [Sizing]>,
+    gutter: Axes<&'a [Sizing]>,
+    locator: Locator<'x>,
+    children: C,
+    fill: &'a Celled<Option<Paint>>,
+    align: &'a Celled<Smart<Alignment>>,
+    inset: &'a Celled<Sides<Option<Rel<Length>>>>,
+    stroke: &'a ResolvedCelled<Sides<Option<Option<Arc<Stroke>>>>>,
+    engine: &'a mut Engine,
+    styles: StyleChain<'a>,
+    span: Span,
+) -> SourceResult<CellGrid<'x>>
+where
+    T: ResolvableCell + Default,
+    I: Iterator<Item = ResolvableGridItem<T>>,
+    C: IntoIterator<Item = ResolvableGridChild<T, I>>,
+    C::IntoIter: ExactSizeIterator,
+{
+    CellGridResolver {
+        tracks,
+        gutter,
+        locator: locator.split(),
+        fill,
+        align,
+        inset,
+        stroke,
+        engine,
+        styles,
+        span,
+    }
+    .resolve(children)
+}
+
+struct CellGridResolver<'a, 'b, 'x> {
+    tracks: Axes<&'a [Sizing]>,
+    gutter: Axes<&'a [Sizing]>,
+    locator: SplitLocator<'x>,
+    fill: &'a Celled<Option<Paint>>,
+    align: &'a Celled<Smart<Alignment>>,
+    inset: &'a Celled<Sides<Option<Rel<Length>>>>,
+    stroke: &'a ResolvedCelled<Sides<Option<Option<Arc<Stroke>>>>>,
+    engine: &'a mut Engine<'b>,
+    styles: StyleChain<'a>,
+    span: Span,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum RowGroupKind {
+    Header,
+    Footer,
+}
+
+impl RowGroupKind {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Header => "header",
+            Self::Footer => "footer",
+        }
+    }
+}
+
+struct RowGroupData {
+    /// The range of rows of cells inside this grid row group. The
+    /// first and last rows are guaranteed to have cells (an exception
+    /// is made when there is gutter, in which case the group range may
+    /// be expanded to include an additional gutter row when there is a
+    /// repeatable header or footer). This is `None` until the first
+    /// cell of the row group is placed, then it is continually adjusted
+    /// to fit the cells inside the row group.
+    ///
+    /// This stays as `None` for fully empty headers and footers.
+    range: Option<Range<usize>>,
+    span: Span,
+    kind: RowGroupKind,
+
+    /// Whether this header or footer may repeat.
+    repeat: bool,
+
+    /// Level of this header or footer.
+    repeatable_level: NonZeroU32,
+
+    /// Start of the range of indices of hlines at the top of the row group.
+    /// This is always the first index after the last hline before we started
+    /// building the row group - any upcoming hlines would appear at least at
+    /// this index.
+    ///
+    /// These hlines were auto-positioned and appeared before any auto-pos
+    /// cells, so they will appear at the first possible row (above the
+    /// first row spanned by the row group).
+    top_hlines_start: usize,
+
+    /// End of the range of indices of hlines at the top of the row group.
+    ///
+    /// This starts as `None`, meaning that, if we stop the loop before we find
+    /// any auto-pos cells, all auto-pos hlines after the last hline (after the
+    /// index `top_hlines_start`) should be moved to the top of the row group.
+    ///
+    /// It becomes `Some(index of last hline at the top)` when an auto-pos cell
+    /// is found, as auto-pos hlines after any auto-pos cells appear below
+    /// them, not at the top of the row group.
+    top_hlines_end: Option<usize>,
+}
+
+impl<'x> CellGridResolver<'_, '_, 'x> {
+    fn resolve<T, C, I>(mut self, children: C) -> SourceResult<CellGrid<'x>>
+    where
+        T: ResolvableCell + Default,
+        I: Iterator<Item = ResolvableGridItem<T>>,
+        C: IntoIterator<Item = ResolvableGridChild<T, I>>,
+        C::IntoIter: ExactSizeIterator,
+    {
+        // Number of content columns: Always at least one.
+        let columns = self.tracks.x.len().max(1);
+
+        // Lists of lines.
+        // Horizontal lines are only pushed later to be able to check for row
+        // validity, since the amount of rows isn't known until all items were
+        // analyzed in the for loop below.
+        // We keep their spans so we can report errors later.
+        // The additional boolean indicates whether the hline had an automatic
+        // 'y' index, and is used to change the index of hlines at the top of a
+        // header or footer.
+        let mut pending_hlines: Vec<(Span, Line, bool)> = vec![];
+
+        // For consistency, only push vertical lines later as well.
+        let mut pending_vlines: Vec<(Span, Line)> = vec![];
+        let has_gutter = self.gutter.any(|tracks| !tracks.is_empty());
+
+        let mut headers: Vec<Repeatable<Header>> = vec![];
+
+        // Stores where the footer is supposed to end, its span, and the
+        // actual footer structure.
+        let mut footer: Option<(usize, Span, Footer)> = None;
+        let mut repeat_footer = false;
+
+        // If true, there has been at least one cell besides headers and
+        // footers. When false, footers at the end are forced to not repeat.
+        let mut at_least_one_cell = false;
+
+        // We can't just use the cell's index in the 'cells' vector to
+        // determine its automatic position, since cells could have arbitrary
+        // positions, so the position of a cell in 'cells' can differ from its
+        // final position in 'resolved_cells' (see below).
+        // Therefore, we use a counter, 'auto_index', to determine the position
+        // of the next cell with (x: auto, y: auto). It is only stepped when
+        // a cell with (x: auto, y: auto), usually the vast majority, is found.
+        //
+        // Note that a separate counter ('local_auto_index') is used within
+        // headers and footers, as explained above its definition. Outside of
+        // those (when the table child being processed is a single cell),
+        // 'local_auto_index' will simply be an alias for 'auto_index', which
+        // will be updated after that cell is placed, if it is an
+        // automatically-positioned cell.
+        let mut auto_index: usize = 0;
+
+        // The next header after the latest auto-positioned cell. This is used
+        // to avoid checking for collision with headers that were already
+        // skipped.
+        let mut next_header = 0;
+
+        // We have to rebuild the grid to account for fixed cell positions.
+        //
+        // Create at least 'children.len()' positions, since there could be at
+        // least 'children.len()' cells (if no explicit lines were specified),
+        // even though some of them might be placed in fixed positions and thus
+        // cause the grid to expand.
+        //
+        // Additionally, make sure we allocate up to the next multiple of
+        // 'columns', since each row will have 'columns' cells, even if the
+        // last few cells weren't explicitly specified by the user.
+        let children = children.into_iter();
+        let Some(child_count) = children.len().checked_next_multiple_of(columns) else {
+            bail!(self.span, "too many cells or lines were given")
+        };
+        let mut resolved_cells: Vec<Option<Entry>> = Vec::with_capacity(child_count);
+        for child in children {
+            self.resolve_grid_child(
+                columns,
+                &mut pending_hlines,
+                &mut pending_vlines,
+                &mut headers,
+                &mut footer,
+                &mut repeat_footer,
+                &mut auto_index,
+                &mut next_header,
+                &mut resolved_cells,
+                &mut at_least_one_cell,
+                child,
+            )?;
+        }
+
+        let resolved_cells = self.fixup_cells::<T>(resolved_cells, columns)?;
+
+        let row_amount = resolved_cells.len().div_ceil(columns);
+        let (hlines, vlines) = self.collect_lines(
+            pending_hlines,
+            pending_vlines,
+            has_gutter,
+            columns,
+            row_amount,
+        )?;
+
+        let footer = self.finalize_headers_and_footers(
+            has_gutter,
+            &mut headers,
+            footer,
+            repeat_footer,
+            row_amount,
+            at_least_one_cell,
+        )?;
+
+        Ok(CellGrid::new_internal(
+            self.tracks,
+            self.gutter,
+            vlines,
+            hlines,
+            headers,
+            footer,
+            resolved_cells,
+        ))
+    }
+
+    /// Resolve a grid child, which can be a header, a footer (both of which
+    /// are row groups, and thus contain multiple grid items inside them), or
+    /// a grid item - a cell, an hline or a vline.
+    ///
+    /// This process consists of placing the child and any sub-items into
+    /// appropriate positions in the resolved grid. This is mostly relevant for
+    /// items without fixed positions, such that they must be placed after the
+    /// previous one, perhaps skipping existing cells along the way.
+    #[allow(clippy::too_many_arguments)]
+    fn resolve_grid_child<T, I>(
+        &mut self,
+        columns: usize,
+        pending_hlines: &mut Vec<(Span, Line, bool)>,
+        pending_vlines: &mut Vec<(Span, Line)>,
+        headers: &mut Vec<Repeatable<Header>>,
+        footer: &mut Option<(usize, Span, Footer)>,
+        repeat_footer: &mut bool,
+        auto_index: &mut usize,
+        next_header: &mut usize,
+        resolved_cells: &mut Vec<Option<Entry<'x>>>,
+        at_least_one_cell: &mut bool,
+        child: ResolvableGridChild<T, I>,
+    ) -> SourceResult<()>
+    where
+        T: ResolvableCell + Default,
+        I: Iterator<Item = ResolvableGridItem<T>>,
+    {
+        // Data for the row group in this iteration.
+        //
+        // Note that cells outside headers and footers are grid children
+        // with a single cell inside, and thus not considered row groups,
+        // in which case this variable remains 'None'.
+        let mut row_group_data: Option<RowGroupData> = None;
+
+        // The normal auto index should only be stepped (upon placing an
+        // automatically-positioned cell, to indicate the position of the
+        // next) outside of headers or footers, in which case the auto
+        // index will be updated with the local auto index. Inside headers
+        // and footers, however, cells can only start after the first empty
+        // row (as determined by 'first_available_row' below), meaning that
+        // the next automatically-positioned cell will be in a different
+        // position than it would usually be if it would be in a non-empty
+        // row, so we must step a local index inside headers and footers
+        // instead, and use a separate counter outside them.
+        let local_auto_index = if matches!(child, ResolvableGridChild::Item(_)) {
+            auto_index
+        } else {
+            // Although 'usize' is Copy, we need to be explicit here that we
+            // aren't reborrowing the original auto index but rather making a
+            // mutable copy of it using 'clone'.
+            &mut (*auto_index).clone()
+        };
+
+        // NOTE: usually, if 'next_header' were to be updated inside a row
+        // group (indicating a header was skipped by a cell), that would
+        // indicate a collision between the row group and that header, which
+        // is an error. However, the exception is for the first auto cell of
+        // the row group, which may skip headers while searching for a position
+        // where to begin the row group in the first place.
+        //
+        // Therefore, we cannot safely share the counter in the row group with
+        // the counter used by auto cells outside, as it might update it in a
+        // valid situation, whereas it must not, since its auto cells use a
+        // different auto index counter and will have seen different headers,
+        // so we copy the next header counter while inside a row group.
+        let local_next_header = if matches!(child, ResolvableGridChild::Item(_)) {
+            next_header
+        } else {
+            &mut (*next_header).clone()
+        };
+
+        // The first row in which this table group can fit.
+        //
+        // Within headers and footers, this will correspond to the first
+        // fully empty row available in the grid. This is because headers
+        // and footers always occupy entire rows, so they cannot occupy
+        // a non-empty row.
+        let mut first_available_row = 0;
+
+        let (header_footer_items, simple_item) = match child {
+            ResolvableGridChild::Header { repeat, level, span, items, .. } => {
+                row_group_data = Some(RowGroupData {
+                    range: None,
+                    span,
+                    kind: RowGroupKind::Header,
+                    repeat,
+                    repeatable_level: level,
+                    top_hlines_start: pending_hlines.len(),
+                    top_hlines_end: None,
+                });
+
+                first_available_row =
+                    find_next_empty_row(resolved_cells, *local_auto_index, columns);
+
+                // If any cell in the header is automatically positioned,
+                // have it skip to the next empty row. This is to avoid
+                // having a header after a partially filled row just add
+                // cells to that row instead of starting a new one.
+                //
+                // Note that the first fully empty row is always after the
+                // latest auto-position cell, since each auto-position cell
+                // always occupies the first available position after the
+                // previous one. Therefore, this will be >= auto_index.
+                *local_auto_index = first_available_row * columns;
+
+                (Some(items), None)
+            }
+            ResolvableGridChild::Footer { repeat, span, items, .. } => {
+                if footer.is_some() {
+                    bail!(span, "cannot have more than one footer");
+                }
+
+                row_group_data = Some(RowGroupData {
+                    range: None,
+                    span,
+                    repeat,
+                    kind: RowGroupKind::Footer,
+                    repeatable_level: NonZeroU32::ONE,
+                    top_hlines_start: pending_hlines.len(),
+                    top_hlines_end: None,
+                });
+
+                first_available_row =
+                    find_next_empty_row(resolved_cells, *local_auto_index, columns);
+
+                *local_auto_index = first_available_row * columns;
+
+                (Some(items), None)
+            }
+            ResolvableGridChild::Item(item) => {
+                if matches!(item, ResolvableGridItem::Cell(_)) {
+                    *at_least_one_cell = true;
+                }
+
+                (None, Some(item))
+            }
+        };
+
+        let items = header_footer_items.into_iter().flatten().chain(simple_item);
+        for item in items {
+            let cell = match item {
+                ResolvableGridItem::HLine { y, start, end, stroke, span, position } => {
+                    let has_auto_y = y.is_auto();
+                    let y = y.unwrap_or_else(|| {
+                        // Avoid placing the hline inside consecutive
+                        // rowspans occupying all columns, as it'd just
+                        // disappear, at least when there's no column
+                        // gutter.
+                        skip_auto_index_through_fully_merged_rows(
+                            resolved_cells,
+                            local_auto_index,
+                            columns,
+                        );
+
+                        // When no 'y' is specified for the hline, we place
+                        // it under the latest automatically positioned
+                        // cell.
+                        // The current value of the auto index is always
+                        // the index of the latest automatically positioned
+                        // cell placed plus one (that's what we do in
+                        // 'resolve_cell_position'), so we subtract 1 to
+                        // get that cell's index, and place the hline below
+                        // its row. The exception is when the auto_index is
+                        // 0, meaning no automatically positioned cell was
+                        // placed yet. In that case, we place the hline at
+                        // the top of the table.
+                        //
+                        // Exceptionally, the hline will be placed before
+                        // the minimum auto index if the current auto index
+                        // from previous iterations is smaller than the
+                        // minimum it should have for the current grid
+                        // child. Effectively, this means that a hline at
+                        // the start of a header will always appear above
+                        // that header's first row. Similarly for footers.
+                        local_auto_index
+                            .checked_sub(1)
+                            .map_or(0, |last_auto_index| last_auto_index / columns + 1)
+                    });
+                    if end.is_some_and(|end| end.get() < start) {
+                        bail!(span, "line cannot end before it starts");
+                    }
+                    let line = Line { index: y, start, end, stroke, position };
+
+                    // Since the amount of rows is dynamic, delay placing
+                    // hlines until after all cells were placed so we can
+                    // properly verify if they are valid. Note that we
+                    // can't place hlines even if we already know they
+                    // would be in a valid row, since it's possible that we
+                    // pushed pending hlines in the same row as this one in
+                    // previous iterations, and we need to ensure that
+                    // hlines from previous iterations are pushed to the
+                    // final vector of hlines first - the order of hlines
+                    // must be kept, as this matters when determining which
+                    // one "wins" in case of conflict. Pushing the current
+                    // hline before we push pending hlines later would
+                    // change their order!
+                    pending_hlines.push((span, line, has_auto_y));
+                    continue;
+                }
+                ResolvableGridItem::VLine { x, start, end, stroke, span, position } => {
+                    let x = x.unwrap_or_else(|| {
+                        // When no 'x' is specified for the vline, we place
+                        // it after the latest automatically positioned
+                        // cell.
+                        // The current value of the auto index is always
+                        // the index of the latest automatically positioned
+                        // cell placed plus one (that's what we do in
+                        // 'resolve_cell_position'), so we subtract 1 to
+                        // get that cell's index, and place the vline after
+                        // its column. The exception is when the auto_index
+                        // is 0, meaning no automatically positioned cell
+                        // was placed yet. In that case, we place the vline
+                        // to the left of the table.
+                        //
+                        // Exceptionally, a vline is also placed to the
+                        // left of the table when specified at the start
+                        // of a row group, such as a header or footer, that
+                        // is, when no automatically-positioned cells have
+                        // been specified for that group yet.
+                        // For example, this means that a vline at
+                        // the beginning of a header will be placed to its
+                        // left rather than after the previous
+                        // automatically positioned cell. Same for footers.
+                        local_auto_index
+                            .checked_sub(1)
+                            .filter(|_| *local_auto_index > first_available_row * columns)
+                            .map_or(0, |last_auto_index| last_auto_index % columns + 1)
+                    });
+                    if end.is_some_and(|end| end.get() < start) {
+                        bail!(span, "line cannot end before it starts");
+                    }
+                    let line = Line { index: x, start, end, stroke, position };
+
+                    // For consistency with hlines, we only push vlines to
+                    // the final vector of vlines after processing every
+                    // cell.
+                    pending_vlines.push((span, line));
+                    continue;
+                }
+                ResolvableGridItem::Cell(cell) => cell,
+            };
+            let cell_span = cell.span();
+            let colspan = cell.colspan(self.styles).get();
+            let rowspan = cell.rowspan(self.styles).get();
+            // Let's calculate the cell's final position based on its
+            // requested position.
+            let resolved_index = {
+                let cell_x = cell.x(self.styles);
+                let cell_y = cell.y(self.styles);
+                resolve_cell_position(
+                    cell_x,
+                    cell_y,
+                    colspan,
+                    rowspan,
+                    headers,
+                    footer.as_ref(),
+                    resolved_cells,
+                    local_auto_index,
+                    local_next_header,
+                    first_available_row,
+                    columns,
+                    row_group_data.is_some(),
+                )
+                .at(cell_span)?
+            };
+            let x = resolved_index % columns;
+            let y = resolved_index / columns;
+
+            if colspan > columns - x {
+                bail!(
+                    cell_span,
+                    "cell's colspan would cause it to exceed the available column(s)";
+                    hint: "try placing the cell in another position or reducing its colspan"
+                )
+            }
+
+            let Some(largest_index) = columns
+                .checked_mul(rowspan - 1)
+                .and_then(|full_rowspan_offset| {
+                    resolved_index.checked_add(full_rowspan_offset)
+                })
+                .and_then(|last_row_pos| last_row_pos.checked_add(colspan - 1))
+            else {
+                bail!(
+                    cell_span,
+                    "cell would span an exceedingly large position";
+                    hint: "try reducing the cell's rowspan or colspan"
+                )
+            };
+
+            // Cell's header or footer must expand to include the cell's
+            // occupied positions, if possible.
+            if let Some(RowGroupData {
+                range: group_range, kind, top_hlines_end, ..
+            }) = &mut row_group_data
+            {
+                *group_range = Some(
+                    expand_row_group(
+                        resolved_cells,
+                        group_range.as_ref(),
+                        *kind,
+                        first_available_row,
+                        y,
+                        rowspan,
+                        columns,
+                    )
+                    .at(cell_span)?,
+                );
+
+                if top_hlines_end.is_none()
+                    && *local_auto_index > first_available_row * columns
+                {
+                    // Auto index was moved, so upcoming auto-pos hlines should
+                    // no longer appear at the top.
+                    *top_hlines_end = Some(pending_hlines.len());
+                }
+            }
+
+            // Let's resolve the cell so it can determine its own fields
+            // based on its final position.
+            let cell = self.resolve_cell(cell, x, y, rowspan, cell_span)?;
+
+            if largest_index >= resolved_cells.len() {
+                // Ensure the length of the vector of resolved cells is
+                // always a multiple of 'columns' by pushing full rows every
+                // time. Here, we add enough absent positions (later
+                // converted to empty cells) to ensure the last row in the
+                // new vector length is completely filled. This is
+                // necessary so that those positions, even if not
+                // explicitly used at the end, are eventually susceptible
+                // to show rules and receive grid styling, as they will be
+                // resolved as empty cells in a second loop below.
+                let Some(new_len) = largest_index
+                    .checked_add(1)
+                    .and_then(|new_len| new_len.checked_next_multiple_of(columns))
+                else {
+                    bail!(cell_span, "cell position too large")
+                };
+
+                // Here, the cell needs to be placed in a position which
+                // doesn't exist yet in the grid (out of bounds). We will
+                // add enough absent positions for this to be possible.
+                // They must be absent as no cells actually occupy them
+                // (they can be overridden later); however, if no cells
+                // occupy them as we finish building the grid, then such
+                // positions will be replaced by empty cells.
+                resolved_cells.resize_with(new_len, || None);
+            }
+
+            // The vector is large enough to contain the cell, so we can
+            // just index it directly to access the position it will be
+            // placed in. However, we still need to ensure we won't try to
+            // place a cell where there already is one.
+            let slot = &mut resolved_cells[resolved_index];
+            if slot.is_some() {
+                bail!(
+                    cell_span,
+                    "attempted to place a second cell at column {x}, row {y}";
+                    hint: "try specifying your cells in a different order"
+                );
+            }
+
+            *slot = Some(Entry::Cell(cell));
+
+            // Now, if the cell spans more than one row or column, we fill
+            // the spanned positions in the grid with Entry::Merged
+            // pointing to the original cell as its parent.
+            for rowspan_offset in 0..rowspan {
+                let spanned_y = y + rowspan_offset;
+                let first_row_index = resolved_index + columns * rowspan_offset;
+                for (colspan_offset, slot) in
+                    resolved_cells[first_row_index..][..colspan].iter_mut().enumerate()
+                {
+                    let spanned_x = x + colspan_offset;
+                    if spanned_x == x && spanned_y == y {
+                        // This is the parent cell.
+                        continue;
+                    }
+                    if slot.is_some() {
+                        bail!(
+                            cell_span,
+                            "cell would span a previously placed cell at column {spanned_x}, row {spanned_y}";
+                            hint: "try specifying your cells in a different order or reducing the cell's rowspan or colspan"
+                        )
+                    }
+                    *slot = Some(Entry::Merged { parent: resolved_index });
+                }
+            }
+        }
+
+        if let Some(row_group) = row_group_data {
+            let group_range = match row_group.range {
+                Some(group_range) => group_range,
+
+                None => {
+                    // Empty header/footer: consider the header/footer to be
+                    // at the next empty row after the latest auto index.
+                    *local_auto_index = first_available_row * columns;
+                    let group_start = first_available_row;
+                    let group_end = group_start + 1;
+
+                    if resolved_cells.len() <= columns * group_start {
+                        // Ensure the automatically chosen row actually exists.
+                        resolved_cells.resize_with(columns * (group_start + 1), || None);
+                    }
+
+                    // Even though this header or footer is fully empty, we add one
+                    // default cell to maintain the invariant that each header and
+                    // footer has at least one 'Some(...)' cell at its first row
+                    // and at least one at its last row (here they are the same
+                    // row, of course). This invariant is important to ensure
+                    // 'find_next_empty_row' will skip through any existing headers
+                    // and footers without having to loop through them each time.
+                    // Cells themselves, unfortunately, still have to.
+                    assert!(resolved_cells[*local_auto_index].is_none());
+                    resolved_cells[*local_auto_index] =
+                        Some(Entry::Cell(self.resolve_cell(
+                            T::default(),
+                            0,
+                            first_available_row,
+                            1,
+                            Span::detached(),
+                        )?));
+
+                    group_start..group_end
+                }
+            };
+
+            let top_hlines_end = row_group.top_hlines_end.unwrap_or(pending_hlines.len());
+            for (_, top_hline, has_auto_y) in pending_hlines
+                .get_mut(row_group.top_hlines_start..top_hlines_end)
+                .unwrap_or(&mut [])
+            {
+                if *has_auto_y {
+                    // Move this hline to the top of the child, as it was
+                    // placed before the first automatically positioned cell
+                    // and had an automatic index.
+                    top_hline.index = group_range.start;
+                }
+            }
+
+            match row_group.kind {
+                RowGroupKind::Header => {
+                    let data = Header {
+                        // Later on, we have to correct this range in case there
+                        // is gutter. But only once all cells have been analyzed
+                        // and the header has fully expanded in the fixup loop
+                        // below.
+                        range: group_range,
+
+                        level: row_group.repeatable_level.get(),
+
+                        // This can only change at a later iteration, if we
+                        // find a conflicting header or footer right away.
+                        short_lived: false,
+                    };
+
+                    // Mark consecutive headers right before this one as short
+                    // lived if they would have a higher or equal level, as
+                    // then they would immediately stop repeating during
+                    // layout.
+                    let mut consecutive_header_start = data.range.start;
+                    for conflicting_header in
+                        headers.iter_mut().rev().take_while(move |h| {
+                            let conflicts = h.range.end == consecutive_header_start
+                                && h.level >= data.level;
+
+                            consecutive_header_start = h.range.start;
+                            conflicts
+                        })
+                    {
+                        conflicting_header.short_lived = true;
+                    }
+
+                    headers.push(Repeatable { inner: data, repeated: row_group.repeat });
+                }
+
+                RowGroupKind::Footer => {
+                    // Only check if the footer is at the end later, once we know
+                    // the final amount of rows.
+                    *footer = Some((
+                        group_range.end,
+                        row_group.span,
+                        Footer {
+                            // Later on, we have to correct this number in case there
+                            // is gutter, but only once all cells have been analyzed
+                            // and the header's and footer's exact boundaries are
+                            // known. That is because the gutter row immediately
+                            // before the footer might not be included as part of
+                            // the footer if it is contained within the header.
+                            start: group_range.start,
+                            end: group_range.end,
+                            level: 1,
+                        },
+                    ));
+
+                    *repeat_footer = row_group.repeat;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Fixup phase (final step in cell grid generation):
+    ///
+    /// 1. Replace absent entries by resolved empty cells, producing a vector
+    ///    of `Entry` from `Option<Entry>`.
+    ///
+    /// 2. Add enough empty cells to the end of the grid such that it has at
+    ///    least the given amount of rows (must be a multiple of `columns`,
+    ///    and all rows before the last cell must have cells, empty or not,
+    ///    even if the user didn't specify those cells).
+    ///
+    ///    That is necessary, for example, to ensure even unspecified cells
+    ///    can be affected by show rules and grid-wide styling.
+    fn fixup_cells<T>(
+        &mut self,
+        resolved_cells: Vec<Option<Entry<'x>>>,
+        columns: usize,
+    ) -> SourceResult<Vec<Entry<'x>>>
+    where
+        T: ResolvableCell + Default,
+    {
+        let Some(expected_total_cells) = columns.checked_mul(self.tracks.y.len()) else {
+            bail!(self.span, "too many rows were specified");
+        };
+        let missing_cells = expected_total_cells.saturating_sub(resolved_cells.len());
+
+        resolved_cells
+            .into_iter()
+            .chain(std::iter::repeat_with(|| None).take(missing_cells))
+            .enumerate()
+            .map(|(i, cell)| {
+                if let Some(cell) = cell {
+                    Ok(cell)
+                } else {
+                    let x = i % columns;
+                    let y = i / columns;
+
+                    Ok(Entry::Cell(self.resolve_cell(
+                        T::default(),
+                        x,
+                        y,
+                        1,
+                        Span::detached(),
+                    )?))
+                }
+            })
+            .collect::<SourceResult<Vec<Entry>>>()
+    }
+
+    /// Takes the list of pending lines and evaluates a final list of hlines
+    /// and vlines (in that order in the returned tuple), detecting invalid
+    /// line positions in the process.
+    ///
+    /// For each line type (horizontal and vertical respectively), returns a
+    /// vector containing one inner vector for every group of lines with the
+    /// same index.
+    ///
+    /// For example, an hline above the second row (y = 1) is inside the inner
+    /// vector at position 1 of the first vector (hlines) returned by this
+    /// function.
+    #[allow(clippy::type_complexity)]
+    fn collect_lines(
+        &self,
+        pending_hlines: Vec<(Span, Line, bool)>,
+        pending_vlines: Vec<(Span, Line)>,
+        has_gutter: bool,
+        columns: usize,
+        row_amount: usize,
+    ) -> SourceResult<(Vec<Vec<Line>>, Vec<Vec<Line>>)> {
+        let mut hlines: Vec<Vec<Line>> = vec![];
+        let mut vlines: Vec<Vec<Line>> = vec![];
+
+        for (line_span, line, _) in pending_hlines {
+            let y = line.index;
+            if y > row_amount {
+                bail!(line_span, "cannot place horizontal line at invalid row {y}");
+            }
+            if y == row_amount && line.position == LinePosition::After {
+                bail!(
+                    line_span,
+                    "cannot place horizontal line at the 'bottom' position of the bottom border (y = {y})";
+                    hint: "set the line's position to 'top' or place it at a smaller 'y' index"
+                );
+            }
+            let line = if line.position == LinePosition::After
+                && (!has_gutter || y + 1 == row_amount)
+            {
+                // Just place the line on top of the next row if
+                // there's no gutter and the line should be placed
+                // after the one with given index.
+                //
+                // Note that placing after the last row is also the same as
+                // just placing on the grid's bottom border, even with
+                // gutter.
+                Line {
+                    index: y + 1,
+                    position: LinePosition::Before,
+                    ..line
+                }
+            } else {
+                line
+            };
+            let y = line.index;
+
+            if hlines.len() <= y {
+                hlines.resize_with(y + 1, Vec::new);
+            }
+            hlines[y].push(line);
+        }
+
+        for (line_span, line) in pending_vlines {
+            let x = line.index;
+            if x > columns {
+                bail!(line_span, "cannot place vertical line at invalid column {x}");
+            }
+            if x == columns && line.position == LinePosition::After {
+                bail!(
+                    line_span,
+                    "cannot place vertical line at the 'end' position of the end border (x = {columns})";
+                    hint: "set the line's position to 'start' or place it at a smaller 'x' index"
+                );
+            }
+            let line = if line.position == LinePosition::After
+                && (!has_gutter || x + 1 == columns)
+            {
+                // Just place the line before the next column if
+                // there's no gutter and the line should be placed
+                // after the one with given index.
+                //
+                // Note that placing after the last column is also the
+                // same as just placing on the grid's end border, even
+                // with gutter.
+                Line {
+                    index: x + 1,
+                    position: LinePosition::Before,
+                    ..line
+                }
+            } else {
+                line
+            };
+            let x = line.index;
+
+            if vlines.len() <= x {
+                vlines.resize_with(x + 1, Vec::new);
+            }
+            vlines[x].push(line);
+        }
+
+        Ok((hlines, vlines))
+    }
+
+    /// Generate the final headers and footers:
+    ///
+    /// 1. Convert gutter-ignorant to gutter-aware indices if necessary;
+    /// 2. Expand the header downwards (or footer upwards) to also include
+    ///    an adjacent gutter row to be repeated alongside that header or
+    ///    footer, if there is gutter;
+    /// 3. Wrap headers and footers in the correct [`Repeatable`] variant.
+    #[allow(clippy::type_complexity)]
+    fn finalize_headers_and_footers(
+        &self,
+        has_gutter: bool,
+        headers: &mut [Repeatable<Header>],
+        footer: Option<(usize, Span, Footer)>,
+        repeat_footer: bool,
+        row_amount: usize,
+        at_least_one_cell: bool,
+    ) -> SourceResult<Option<Repeatable<Footer>>> {
+        // Mark consecutive headers right before the end of the table, or the
+        // final footer, as short lived, given that there are no normal rows
+        // after them, so repeating them is pointless.
+        //
+        // It is important to do this BEFORE we update header and footer ranges
+        // due to gutter below as 'row_amount' doesn't consider gutter.
+        //
+        // TODO(subfooters): take the last footer if it is at the end and
+        // backtrack through consecutive footers until the first one in the
+        // sequence is found. If there is no footer at the end, there are no
+        // haeders to turn short-lived.
+        let mut consecutive_header_start =
+            footer.as_ref().map(|(_, _, f)| f.start).unwrap_or(row_amount);
+        for header_at_the_end in headers.iter_mut().rev().take_while(move |h| {
+            let at_the_end = h.range.end == consecutive_header_start;
+
+            consecutive_header_start = h.range.start;
+            at_the_end
+        }) {
+            header_at_the_end.short_lived = true;
+        }
+
+        // Repeat the gutter below a header (hence why we don't
+        // subtract 1 from the gutter case).
+        // Don't do this if there are no rows under the header.
+        if has_gutter {
+            for header in &mut *headers {
+                // Index of first y is doubled, as each row before it
+                // receives a gutter row below.
+                header.range.start *= 2;
+
+                // - 'header.end' is always 'last y + 1'. The header stops
+                // before that row.
+                // - Therefore, '2 * header.end' will be 2 * (last y + 1),
+                // which is the adjusted index of the row before which the
+                // header stops, meaning it will still stop right before it
+                // even with gutter thanks to the multiplication below.
+                // - This means that it will span all rows up to
+                // '2 * (last y + 1) - 1 = 2 * last y + 1', which equates
+                // to the index of the gutter row right below the header,
+                // which is what we want (that gutter spacing should be
+                // repeated across pages to maintain uniformity).
+                header.range.end *= 2;
+
+                // If the header occupies the entire grid, ensure we don't
+                // include an extra gutter row when it doesn't exist, since
+                // the last row of the header is at the very bottom,
+                // therefore '2 * last y + 1' is not a valid index.
+                let row_amount = (2 * row_amount).saturating_sub(1);
+                header.range.end = header.range.end.min(row_amount);
+            }
+        }
+
+        let footer = footer
+            .map(|(footer_end, footer_span, mut footer)| {
+                if footer_end != row_amount {
+                    bail!(footer_span, "footer must end at the last row");
+                }
+
+                // TODO(subfooters): will need a global slice of headers and
+                // footers for when we have multiple footers
+                // Alternatively, never include the gutter in the footer's
+                // range and manually add it later on layout. This would allow
+                // laying out the gutter as part of both the header and footer,
+                // and, if the page only has headers, the gutter row below the
+                // header is automatically removed (as it becomes the last), so
+                // only the gutter above the footer is kept, ensuring the same
+                // gutter row isn't laid out two times in a row. When laying
+                // out the footer for real, the mechanism can be disabled.
+                let last_header_end = headers.last().map(|header| header.range.end);
+
+                if has_gutter {
+                    // Convert the footer's start index to post-gutter coordinates.
+                    footer.start *= 2;
+
+                    // Include the gutter right before the footer, unless there is
+                    // none, or the gutter is already included in the header (no
+                    // rows between the header and the footer).
+                    if last_header_end != Some(footer.start) {
+                        footer.start = footer.start.saturating_sub(1);
+                    }
+
+                    // Adapt footer end but DO NOT include the gutter below it,
+                    // if it exists. Calculation:
+                    // - Starts as 'last y + 1'.
+                    // - The result will be
+                    // 2 * (last_y + 1) - 1 = 2 * last_y + 1,
+                    // which is the new index of the last footer row plus one,
+                    // meaning we do exclude any gutter below this way.
+                    //
+                    // It also keeps us within the total amount of rows, so we
+                    // don't need to '.min()' later.
+                    footer.end = (2 * footer.end).saturating_sub(1);
+                }
+
+                Ok(footer)
+            })
+            .transpose()?
+            .map(|footer| {
+                // Don't repeat footers when the table only has headers and
+                // footers.
+                // TODO(subfooters): Switch this to marking the last N
+                // consecutive footers as short lived.
+                Repeatable {
+                    inner: footer,
+                    repeated: repeat_footer && at_least_one_cell,
+                }
+            });
+
+        Ok(footer)
+    }
+
+    /// Resolves the cell's fields based on grid-wide properties.
+    fn resolve_cell<T>(
+        &mut self,
+        cell: T,
+        x: usize,
+        y: usize,
+        rowspan: usize,
+        cell_span: Span,
+    ) -> SourceResult<Cell<'x>>
+    where
+        T: ResolvableCell + Default,
+    {
+        // Resolve the breakability of a cell. Cells that span at least one
+        // auto-sized row or gutter are considered breakable.
+        let breakable = {
+            let auto = Sizing::Auto;
+            let zero = Sizing::Rel(Rel::zero());
+            self.tracks
+                .y
+                .iter()
+                .chain(std::iter::repeat(self.tracks.y.last().unwrap_or(&auto)))
+                .skip(y)
+                .take(rowspan)
+                .any(|row| row == &Sizing::Auto)
+                || self
+                    .gutter
+                    .y
+                    .iter()
+                    .chain(std::iter::repeat(self.gutter.y.last().unwrap_or(&zero)))
+                    .skip(y)
+                    .take(rowspan - 1)
+                    .any(|row_gutter| row_gutter == &Sizing::Auto)
+        };
+
+        Ok(cell.resolve_cell(
+            x,
+            y,
+            &self.fill.resolve(self.engine, self.styles, x, y)?,
+            self.align.resolve(self.engine, self.styles, x, y)?,
+            self.inset.resolve(self.engine, self.styles, x, y)?,
+            self.stroke.resolve(self.engine, self.styles, x, y)?,
+            breakable,
+            self.locator.next(&cell_span),
+            self.styles,
+        ))
+    }
+}
+
+/// Given the existing range of a row group (header or footer), tries to expand
+/// it to fit the new cell placed inside it. If the newly-expanded row group
+/// would conflict with existing cells or other row groups, an error is
+/// returned. Otherwise, the new `start..end` range of rows in the row group is
+/// returned.
+fn expand_row_group(
+    resolved_cells: &[Option<Entry<'_>>],
+    group_range: Option<&Range<usize>>,
+    group_kind: RowGroupKind,
+    first_available_row: usize,
+    cell_y: usize,
+    rowspan: usize,
+    columns: usize,
+) -> HintedStrResult<Range<usize>> {
+    // Ensure each cell in a header or footer is fully contained within it by
+    // expanding the header or footer towards this new cell.
+    let (new_group_start, new_group_end) = group_range
+        .map_or((cell_y, cell_y + rowspan), |r| {
+            (r.start.min(cell_y), r.end.max(cell_y + rowspan))
+        });
+
+    // This check might be unnecessary with the loop below, but let's keep it
+    // here for full correctness.
+    //
+    // Quickly detect the case:
+    // y = 0 => occupied
+    // y = 1 => empty
+    // y = 2 => header
+    // and header tries to expand to y = 0 - invalid, as
+    // 'y = 1' is the earliest row it can occupy.
+    if new_group_start < first_available_row {
+        bail!(
+            "cell would cause {} to expand to non-empty row {}",
+            group_kind.name(),
+            first_available_row.saturating_sub(1);
+            hint: "try moving its cells to available rows"
+        );
+    }
+
+    let new_rows =
+        group_range.map_or((new_group_start..new_group_end).chain(0..0), |r| {
+            // NOTE: 'r.end' is one row AFTER the row group's last row, so it
+            // makes sense to check it if 'new_group_end > r.end', that is, if
+            // the row group is going to expand. It is NOT a duplicate check,
+            // as we hadn't checked it before (in a previous run, it was
+            // 'new_group_end' at the exclusive end of the range)!
+            //
+            // NOTE: To keep types the same, we have to always return
+            // '(range).chain(range)', which justifies chaining an empty
+            // range above.
+            (new_group_start..r.start).chain(r.end..new_group_end)
+        });
+
+    // The check above isn't enough, however, even when the header is expanding
+    // upwards, as it might expand upwards towards an occupied row after the
+    // first empty row, e.g.
+    //
+    // y = 0 => occupied
+    // y = 1 => empty (first_available_row = 1)
+    // y = 2 => occupied
+    // y = 3 => header
+    //
+    // Here, we should bail if the header tries to expand upwards, regardless
+    // of the fact that the conflicting row (y = 2) comes after the first
+    // available row.
+    //
+    // Note that expanding upwards is only possible when row-positioned cells
+    // are specified, in one of the following cases:
+    //
+    // 1. We place e.g. 'table.cell(y: 3)' followed by 'table.cell(y: 2)'
+    // (earlier row => upwards);
+    //
+    // 2. We place e.g. 'table.cell(y: 3)' followed by '[a]' (auto-pos cell
+    // favors 'first_available_row', so the header tries to expand upwards to
+    // place the cell at 'y = 1' and conflicts at 'y = 2') or
+    // 'table.cell(x: 1)' (same deal).
+    //
+    // Of course, we also need to check for downward expansion as usual as
+    // there could be a non-empty row below the header, but the upward case is
+    // highlighted as it was checked separately before (and also to explain
+    // what kind of situation we are preventing with this check).
+    //
+    // Note that simply checking for non-empty rows like below not only
+    // prevents conflicts with top-level cells (outside of headers and
+    // footers), but also prevents conflicts with other headers or footers,
+    // since we have an invariant that even empty headers and footers must
+    // contain at least one 'Some(...)' position in 'resolved_cells'. More
+    // precisely, each header and footer has at least one 'Some(...)' cell at
+    // 'group_range.start' and at 'group_range.end - 1' - non-empty headers and
+    // footers don't span any unnecessary rows. Therefore, we don't have to
+    // loop over headers and footers, only check if the new rows are empty.
+    for new_y in new_rows {
+        if let Some(new_row @ [_non_empty, ..]) = resolved_cells
+            .get(new_y * columns..)
+            .map(|cells| &cells[..columns.min(cells.len())])
+        {
+            if new_row.iter().any(Option::is_some) {
+                bail!(
+                    "cell would cause {} to expand to non-empty row {new_y}",
+                    group_kind.name();
+                    hint: "try moving its cells to available rows",
+                )
+            }
+        } else {
+            // Received 'None' or an empty slice, so we are expanding the
+            // header or footer into new rows, which is always valid and cannot
+            // conflict with existing cells. (Note that we only resize
+            // 'resolved_cells' after this function is called, so, if this
+            // header or footer is at the bottom of the table so far, this loop
+            // will end quite early, regardless of where this cell was placed
+            // or of its rowspan value.)
+            break;
+        }
+    }
+
+    Ok(new_group_start..new_group_end)
+}
+
+/// Check if a cell's fixed row would conflict with a header or footer.
+fn check_for_conflicting_cell_row(
+    headers: &[Repeatable<Header>],
+    footer: Option<&(usize, Span, Footer)>,
+    cell_y: usize,
+    rowspan: usize,
+) -> HintedStrResult<()> {
+    // NOTE: y + rowspan >, not >=, header.start, to check if the rowspan
+    // enters the header. For example, consider a rowspan of 1: if
+    // `y + 1 = header.start` holds, that means `y < header.start`, and it
+    // only occupies one row (`y`), so the cell is actually not in
+    // conflict.
+    if headers
+        .iter()
+        .any(|header| cell_y < header.range.end && cell_y + rowspan > header.range.start)
+    {
+        bail!(
+            "cell would conflict with header spanning the same position";
+            hint: "try moving the cell or the header"
+        );
+    }
+
+    if let Some((_, _, footer)) = footer {
+        if cell_y < footer.end && cell_y + rowspan > footer.start {
+            bail!(
+                "cell would conflict with footer spanning the same position";
+                hint: "try reducing the cell's rowspan or moving the footer"
+            );
+        }
+    }
+
+    Ok(())
 }
 
 /// Given a cell's requested x and y, the vector with the resolved cell
@@ -1620,20 +2115,24 @@ impl<'a> CellGrid<'a> {
 /// `(auto, auto)` cell) and the amount of columns in the grid, returns the
 /// final index of this cell in the vector of resolved cells.
 ///
-/// The `start_new_row` parameter is used to ensure that, if this cell is
-/// fully automatically positioned, it should start a new, empty row. This is
-/// useful for headers and footers, which must start at their own rows, without
-/// interference from previous cells.
+/// The `first_available_row` parameter is used by headers and footers to
+/// indicate the first empty row available. Any rows before those should
+/// not be picked by cells with `auto` row positioning, since headers and
+/// footers occupy entire rows, and may not conflict with cells outside them.
 #[allow(clippy::too_many_arguments)]
 fn resolve_cell_position(
     cell_x: Smart<usize>,
     cell_y: Smart<usize>,
     colspan: usize,
     rowspan: usize,
+    headers: &[Repeatable<Header>],
+    footer: Option<&(usize, Span, Footer)>,
     resolved_cells: &[Option<Entry>],
     auto_index: &mut usize,
-    start_new_row: &mut bool,
+    next_header: &mut usize,
+    first_available_row: usize,
     columns: usize,
+    in_row_group: bool,
 ) -> HintedStrResult<usize> {
     // Translates a (x, y) position to the equivalent index in the final cell vector.
     // Errors if the position would be too large.
@@ -1648,29 +2147,26 @@ fn resolve_cell_position(
         (Smart::Auto, Smart::Auto) => {
             // Let's find the first available position starting from the
             // automatic position counter, searching in row-major order.
-            let mut resolved_index = *auto_index;
-            if *start_new_row {
-                resolved_index =
-                    find_next_empty_row(resolved_cells, resolved_index, columns);
-
-                // Next cell won't have to start a new row if we just did that,
-                // in principle.
-                *start_new_row = false;
-            } else {
-                while let Some(Some(_)) = resolved_cells.get(resolved_index) {
-                    // Skip any non-absent cell positions (`Some(None)`) to
-                    // determine where this cell will be placed. An out of
-                    // bounds position (thus `None`) is also a valid new
-                    // position (only requires expanding the vector).
-                    resolved_index += 1;
-                }
-            }
+            // Note that the counter ignores any cells with fixed positions,
+            // but automatically-positioned cells will avoid conflicts by
+            // simply skipping existing cells, headers and footers.
+            let resolved_index = find_next_available_position(
+                headers,
+                footer,
+                resolved_cells,
+                columns,
+                *auto_index,
+                next_header,
+                false,
+            )?;
 
             // Ensure the next cell with automatic position will be
             // placed after this one (maybe not immediately after).
             //
             // The calculation below also affects the position of the upcoming
-            // automatically-positioned lines.
+            // automatically-positioned lines, as they are placed below
+            // (horizontal lines) or to the right (vertical lines) of the cell
+            // that would be placed at 'auto_index'.
             *auto_index = if colspan == columns {
                 // The cell occupies all columns, so no cells can be placed
                 // after it until all of its rows have been spanned.
@@ -1692,24 +2188,62 @@ fn resolve_cell_position(
             }
             if let Smart::Custom(cell_y) = cell_y {
                 // Cell has chosen its exact position.
+                //
+                // Ensure it doesn't conflict with an existing header or
+                // footer (but only if it isn't already in one, otherwise there
+                // will already be a separate check).
+                if !in_row_group {
+                    check_for_conflicting_cell_row(headers, footer, cell_y, rowspan)?;
+                }
+
                 cell_index(cell_x, cell_y)
             } else {
                 // Cell has only chosen its column.
                 // Let's find the first row which has that column available.
-                let mut resolved_y = 0;
-                while let Some(Some(_)) =
-                    resolved_cells.get(cell_index(cell_x, resolved_y)?)
-                {
-                    // Try each row until either we reach an absent position
-                    // (`Some(None)`) or an out of bounds position (`None`),
-                    // in which case we'd create a new row to place this cell in.
-                    resolved_y += 1;
-                }
-                cell_index(cell_x, resolved_y)
+                // If in a header or footer, start searching by the first empty
+                // row / the header or footer's first row (specified through
+                // 'first_available_row'). Otherwise, start searching at the
+                // first row.
+                let initial_index = cell_index(cell_x, first_available_row)?;
+
+                // Try each row until either we reach an absent position at the
+                // requested column ('Some(None)') or an out of bounds position
+                // ('None'), in which case we'd create a new row to place this
+                // cell in.
+                find_next_available_position(
+                    headers,
+                    footer,
+                    resolved_cells,
+                    columns,
+                    initial_index,
+                    // Make our own copy of the 'next_header' counter, since it
+                    // should only be updated by auto cells. However, we cannot
+                    // start with the same value as we are searching from the
+                    // start, and not from 'auto_index', so auto cells might
+                    // have skipped some headers already which this cell will
+                    // also need to skip.
+                    //
+                    // We could, in theory, keep a separate 'next_header'
+                    // counter for cells with fixed columns. But then we would
+                    // need one for every column, and much like how there isn't
+                    // an index counter for each column either, the potential
+                    // speed gain seems less relevant for a less used feature.
+                    // Still, it is something to consider for the future if
+                    // this turns out to be a bottleneck in important cases.
+                    &mut 0,
+                    true,
+                )
             }
         }
         // Cell has only chosen its row, not its column.
         (Smart::Auto, Smart::Custom(cell_y)) => {
+            // Ensure it doesn't conflict with an existing header or
+            // footer (but only if it isn't already in one, otherwise there
+            // will already be a separate check).
+            if !in_row_group {
+                check_for_conflicting_cell_row(headers, footer, cell_y, rowspan)?;
+            }
+
             // Let's find the first column which has that row available.
             let first_row_pos = cell_index(0, cell_y)?;
             let last_row_pos = first_row_pos
@@ -1736,14 +2270,87 @@ fn resolve_cell_position(
     }
 }
 
-/// Computes the index of the first cell in the next empty row in the grid,
-/// starting with the given initial index.
+/// Finds the first available position after the initial index in the resolved
+/// grid of cells. Skips any non-absent positions (positions which already
+/// have cells specified by the user) as well as any headers and footers.
+///
+/// When `skip_rows` is true, one row is skipped on each iteration, preserving
+/// the column. That is used to find a position for a fixed column cell.
+#[inline]
+fn find_next_available_position(
+    headers: &[Repeatable<Header>],
+    footer: Option<&(usize, Span, Footer)>,
+    resolved_cells: &[Option<Entry<'_>>],
+    columns: usize,
+    initial_index: usize,
+    next_header: &mut usize,
+    skip_rows: bool,
+) -> HintedStrResult<usize> {
+    let mut resolved_index = initial_index;
+
+    loop {
+        if let Some(Some(_)) = resolved_cells.get(resolved_index) {
+            // Skip any non-absent cell positions (`Some(None)`) to
+            // determine where this cell will be placed. An out of
+            // bounds position (thus `None`) is also a valid new
+            // position (only requires expanding the vector).
+            if skip_rows {
+                // Skip one row at a time (cell chose its column, so we don't
+                // change it).
+                resolved_index =
+                    resolved_index.checked_add(columns).ok_or_else(|| {
+                        HintedString::from(eco_format!("cell position too large"))
+                    })?;
+            } else {
+                // Ensure we don't run unnecessary checks in the hot path
+                // (for fully automatically-positioned cells). Memory usage
+                // would become impractically large before this overflows.
+                resolved_index += 1;
+            }
+        } else if let Some(header) = headers
+            .get(*next_header)
+            .filter(|header| resolved_index >= header.range.start * columns)
+        {
+            // Skip header (can't place a cell inside it from outside it).
+            // No changes needed if we already passed this header (which
+            // also triggers this branch) - in that case, we only update the
+            // counter.
+            if resolved_index < header.range.end * columns {
+                resolved_index = header.range.end * columns;
+
+                if skip_rows {
+                    // Ensure the cell's chosen column is kept after the
+                    // header.
+                    resolved_index += initial_index % columns;
+                }
+            }
+
+            // From now on, only check the headers afterwards.
+            *next_header += 1;
+        } else if let Some((footer_end, _, _)) = footer.filter(|(end, _, footer)| {
+            resolved_index >= footer.start * columns && resolved_index < *end * columns
+        }) {
+            // Skip footer, for the same reason.
+            resolved_index = *footer_end * columns;
+
+            if skip_rows {
+                resolved_index += initial_index % columns;
+            }
+        } else {
+            return Ok(resolved_index);
+        }
+    }
+}
+
+/// Computes the `y` of the next available empty row, given the auto index as
+/// an initial index for search, since we know that there are no empty rows
+/// before automatically-positioned cells, as they are placed sequentially.
 fn find_next_empty_row(
     resolved_cells: &[Option<Entry>],
-    initial_index: usize,
+    auto_index: usize,
     columns: usize,
 ) -> usize {
-    let mut resolved_index = initial_index.next_multiple_of(columns);
+    let mut resolved_index = auto_index.next_multiple_of(columns);
     while resolved_cells
         .get(resolved_index..resolved_index + columns)
         .is_some_and(|row| row.iter().any(Option::is_some))
@@ -1752,7 +2359,7 @@ fn find_next_empty_row(
         resolved_index += columns;
     }
 
-    resolved_index
+    resolved_index / columns
 }
 
 /// Fully merged rows under the cell of latest auto index indicate rowspans
diff --git a/crates/typst-library/src/layout/layout.rs b/crates/typst-library/src/layout/layout.rs
index cde3187d3..46271ff22 100644
--- a/crates/typst-library/src/layout/layout.rs
+++ b/crates/typst-library/src/layout/layout.rs
@@ -22,7 +22,8 @@ use crate::layout::{BlockElem, Size};
 /// #let text = lorem(30)
 /// #layout(size => [
 ///   #let (height,) = measure(
-///     block(width: size.width, text),
+///     width: size.width,
+///     text,
 ///   )
 ///   This text is #height high with
 ///   the current page width: \
@@ -40,8 +41,23 @@ use crate::layout::{BlockElem, Size};
 /// receives the page's dimensions minus its margins. This is mostly useful in
 /// combination with [measurement]($measure).
 ///
-/// You can also use this function to resolve [`ratio`] to fixed lengths. This
-/// might come in handy if you're building your own layout abstractions.
+/// To retrieve the _remaining_ height of the page rather than its full size,
+/// you can wrap your `layout` call in a `{block(height: 1fr)}`. This works
+/// because the block automatically grows to fill the remaining space (see the
+/// [fraction] documentation for more details).
+///
+/// ```example
+/// #set page(height: 150pt)
+///
+/// #lorem(20)
+///
+/// #block(height: 1fr, layout(size => [
+///   Remaining height: #size.height
+/// ]))
+/// ```
+///
+/// You can also use this function to resolve a [`ratio`] to a fixed length.
+/// This might come in handy if you're building your own layout abstractions.
 ///
 /// ```example
 /// #layout(size => {
diff --git a/crates/typst-library/src/layout/page.rs b/crates/typst-library/src/layout/page.rs
index 0964dccd2..98afbd06f 100644
--- a/crates/typst-library/src/layout/page.rs
+++ b/crates/typst-library/src/layout/page.rs
@@ -1,16 +1,14 @@
-use std::borrow::Cow;
 use std::num::NonZeroUsize;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 
-use comemo::Track;
 use typst_utils::{singleton, NonZeroExt, Scalar};
 
 use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Args, AutoValue, Cast, Construct, Content, Context, Dict, Fold, Func,
-    NativeElement, Set, Smart, StyleChain, Value,
+    cast, elem, Args, AutoValue, Cast, Construct, Content, Dict, Fold, NativeElement,
+    Set, Smart, Value,
 };
 use crate::introspection::Introspector;
 use crate::layout::{
@@ -75,9 +73,10 @@ pub struct PageElem {
     /// The height of the page.
     ///
     /// If this is set to `{auto}`, page breaks can only be triggered manually
-    /// by inserting a [page break]($pagebreak). Most examples throughout this
-    /// documentation use `{auto}` for the height of the page to dynamically
-    /// grow and shrink to fit their content.
+    /// by inserting a [page break]($pagebreak) or by adding another non-empty
+    /// page set rule. Most examples throughout this documentation use `{auto}`
+    /// for the height of the page to dynamically grow and shrink to fit their
+    /// content.
     #[resolve]
     #[parse(
         args.named("height")?
@@ -483,7 +482,7 @@ pub struct Page {
     pub supplement: Content,
     /// The logical page number (controlled by `counter(page)` and may thus not
     /// match the physical number).
-    pub number: usize,
+    pub number: u64,
 }
 
 impl Page {
@@ -648,43 +647,6 @@ cast! {
     },
 }
 
-/// A header, footer, foreground or background definition.
-#[derive(Debug, Clone, Hash)]
-pub enum Marginal {
-    /// Bare content.
-    Content(Content),
-    /// A closure mapping from a page number to content.
-    Func(Func),
-}
-
-impl Marginal {
-    /// Resolve the marginal based on the page number.
-    pub fn resolve(
-        &self,
-        engine: &mut Engine,
-        styles: StyleChain,
-        page: usize,
-    ) -> SourceResult<Cow<'_, Content>> {
-        Ok(match self {
-            Self::Content(content) => Cow::Borrowed(content),
-            Self::Func(func) => Cow::Owned(
-                func.call(engine, Context::new(None, Some(styles)).track(), [page])?
-                    .display(),
-            ),
-        })
-    }
-}
-
-cast! {
-    Marginal,
-    self => match self {
-        Self::Content(v) => v.into_value(),
-        Self::Func(v) => v.into_value(),
-    },
-    v: Content => Self::Content(v),
-    v: Func => Self::Func(v),
-}
-
 /// A list of page ranges to be exported.
 #[derive(Debug, Clone)]
 pub struct PageRanges(Vec<PageRange>);
diff --git a/crates/typst-library/src/layout/ratio.rs b/crates/typst-library/src/layout/ratio.rs
index 1c0dcd298..cf826c2b5 100644
--- a/crates/typst-library/src/layout/ratio.rs
+++ b/crates/typst-library/src/layout/ratio.rs
@@ -8,15 +8,35 @@ use crate::foundations::{repr, ty, Repr};
 
 /// A ratio of a whole.
 ///
-/// Written as a number, followed by a percent sign.
+/// A ratio is written as a number, followed by a percent sign. Ratios most
+/// often appear as part of a [relative length]($relative), to specify the size
+/// of some layout element relative to the page or some container.
 ///
-/// # Example
 /// ```example
-/// #set align(center)
-/// #scale(x: 150%)[
-///   Scaled apart.
-/// ]
+/// #rect(width: 25%)
 /// ```
+///
+/// However, they can also describe any other property that is relative to some
+/// base, e.g. an amount of [horizontal scaling]($scale.x) or the
+/// [height of parentheses]($math.lr.size) relative to the height of the content
+/// they enclose.
+///
+/// # Scripting
+/// Within your own code, you can use ratios as you like. You can multiply them
+/// with various other types as shown below:
+///
+/// |  Multiply by    |  Example                | Result          |
+/// |-----------------|-------------------------|-----------------|
+/// | [`ratio`]       | `{27% * 10%}`           | `{2.7%}`        |
+/// | [`length`]      | `{27% * 100pt}`         | `{27pt}`        |
+/// | [`relative`]    | `{27% * (10% + 100pt)}` | `{2.7% + 27pt}` |
+/// | [`angle`]       | `{27% * 100deg}`        | `{27deg}`       |
+/// | [`int`]         | `{27% * 2}`             | `{54%}`         |
+/// | [`float`]       | `{27% * 0.37037}`       | `{10%}`         |
+/// | [`fraction`]    | `{27% * 3fr}`           | `{0.81fr}`      |
+///
+/// When ratios are displayed in the document, they are rounded to two
+/// significant digits for readability.
 #[ty(cast)]
 #[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct Ratio(Scalar);
diff --git a/crates/typst-library/src/layout/rel.rs b/crates/typst-library/src/layout/rel.rs
index 76d736785..7fe5d9c05 100644
--- a/crates/typst-library/src/layout/rel.rs
+++ b/crates/typst-library/src/layout/rel.rs
@@ -14,17 +14,58 @@ use crate::layout::{Abs, Em, Length, Ratio};
 /// addition and subtraction of a length and a ratio. Wherever a relative length
 /// is expected, you can also use a bare length or ratio.
 ///
-/// # Example
-/// ```example
-/// #rect(width: 100% - 50pt)
+/// # Relative to the page
+/// A common use case is setting the width or height of a layout element (e.g.,
+/// [block], [rect], etc.) as a certain percentage of the width of the page.
+/// Here, the rectangle's width is set to `{25%}`, so it takes up one fourth of
+/// the page's _inner_ width (the width minus margins).
 ///
-/// #(100% - 50pt).length \
-/// #(100% - 50pt).ratio
+/// ```example
+/// #rect(width: 25%)
 /// ```
 ///
+/// Bare lengths or ratios are always valid where relative lengths are expected,
+/// but the two can also be freely mixed:
+/// ```example
+/// #rect(width: 25% + 1cm)
+/// ```
+///
+/// If you're trying to size an element so that it takes up the page's _full_
+/// width, you have a few options (this highly depends on your exact use case):
+///
+/// 1. Set page margins to `{0pt}` (`[#set page(margin: 0pt)]`)
+/// 2. Multiply the ratio by the known full page width (`{21cm * 69%}`)
+/// 3. Use padding which will negate the margins (`[#pad(x: -2.5cm, ...)]`)
+/// 4. Use the page [background](page.background) or
+///    [foreground](page.foreground) field as those don't take margins into
+///    account (note that it will render the content outside of the document
+///    flow, see [place] to control the content position)
+///
+/// # Relative to a container
+/// When a layout element (e.g. a [rect]) is nested in another layout container
+/// (e.g. a [block]) instead of being a direct descendant of the page, relative
+/// widths become relative to the container:
+///
+/// ```example
+/// #block(
+///   width: 100pt,
+///   fill: aqua,
+///   rect(width: 50%),
+/// )
+/// ```
+///
+/// # Scripting
+/// You can multiply relative lengths by [ratios]($ratio), [integers]($int), and
+/// [floats]($float).
+///
 /// A relative length has the following fields:
 /// - `length`: Its length component.
 /// - `ratio`: Its ratio component.
+///
+/// ```example
+/// #(100% - 50pt).length \
+/// #(100% - 50pt).ratio
+/// ```
 #[ty(cast, name = "relative", title = "Relative Length")]
 #[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Rel<T: Numeric = Length> {
diff --git a/crates/typst-library/src/layout/transform.rs b/crates/typst-library/src/layout/transform.rs
index 183df6098..d153d97db 100644
--- a/crates/typst-library/src/layout/transform.rs
+++ b/crates/typst-library/src/layout/transform.rs
@@ -307,6 +307,20 @@ impl Transform {
         Self { sx, sy, ..Self::identity() }
     }
 
+    /// A scale transform at a specific position.
+    pub fn scale_at(sx: Ratio, sy: Ratio, px: Abs, py: Abs) -> Self {
+        Self::translate(px, py)
+            .pre_concat(Self::scale(sx, sy))
+            .pre_concat(Self::translate(-px, -py))
+    }
+
+    /// A rotate transform at a specific position.
+    pub fn rotate_at(angle: Angle, px: Abs, py: Abs) -> Self {
+        Self::translate(px, py)
+            .pre_concat(Self::rotate(angle))
+            .pre_concat(Self::translate(-px, -py))
+    }
+
     /// A rotate transform.
     pub fn rotate(angle: Angle) -> Self {
         let cos = Ratio::new(angle.cos());
diff --git a/crates/typst-library/src/loading/cbor.rs b/crates/typst-library/src/loading/cbor.rs
index aa14c5c77..d95f73844 100644
--- a/crates/typst-library/src/loading/cbor.rs
+++ b/crates/typst-library/src/loading/cbor.rs
@@ -23,8 +23,8 @@ pub fn cbor(
     /// A [path]($syntax/#paths) to a CBOR file or raw CBOR bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
-    let data = source.load(engine.world)?;
-    ciborium::from_reader(data.as_slice())
+    let loaded = source.load(engine.world)?;
+    ciborium::from_reader(loaded.data.as_slice())
         .map_err(|err| eco_format!("failed to parse CBOR ({err})"))
         .at(source.span)
 }
diff --git a/crates/typst-library/src/loading/csv.rs b/crates/typst-library/src/loading/csv.rs
index 6afb5baeb..d5b54a06c 100644
--- a/crates/typst-library/src/loading/csv.rs
+++ b/crates/typst-library/src/loading/csv.rs
@@ -1,7 +1,7 @@
-use ecow::{eco_format, EcoString};
+use az::SaturatingAs;
 use typst_syntax::Spanned;
 
-use crate::diag::{bail, At, SourceResult};
+use crate::diag::{bail, LineCol, LoadError, LoadedWithin, ReportPos, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{cast, func, scope, Array, Dict, IntoValue, Type, Value};
 use crate::loading::{DataSource, Load, Readable};
@@ -44,7 +44,7 @@ pub fn csv(
     #[default(RowType::Array)]
     row_type: RowType,
 ) -> SourceResult<Array> {
-    let data = source.load(engine.world)?;
+    let loaded = source.load(engine.world)?;
 
     let mut builder = ::csv::ReaderBuilder::new();
     let has_headers = row_type == RowType::Dict;
@@ -53,7 +53,7 @@ pub fn csv(
 
     // Counting lines from 1 by default.
     let mut line_offset: usize = 1;
-    let mut reader = builder.from_reader(data.as_slice());
+    let mut reader = builder.from_reader(loaded.data.as_slice());
     let mut headers: Option<::csv::StringRecord> = None;
 
     if has_headers {
@@ -62,9 +62,9 @@ pub fn csv(
         headers = Some(
             reader
                 .headers()
+                .cloned()
                 .map_err(|err| format_csv_error(err, 1))
-                .at(source.span)?
-                .clone(),
+                .within(&loaded)?,
         );
     }
 
@@ -74,7 +74,7 @@ pub fn csv(
         // incorrect with `has_headers` set to `false`. See issue:
         // https://github.com/BurntSushi/rust-csv/issues/184
         let line = line + line_offset;
-        let row = result.map_err(|err| format_csv_error(err, line)).at(source.span)?;
+        let row = result.map_err(|err| format_csv_error(err, line)).within(&loaded)?;
         let item = if let Some(headers) = &headers {
             let mut dict = Dict::new();
             for (field, value) in headers.iter().zip(&row) {
@@ -164,15 +164,23 @@ cast! {
 }
 
 /// Format the user-facing CSV error message.
-fn format_csv_error(err: ::csv::Error, line: usize) -> EcoString {
+fn format_csv_error(err: ::csv::Error, line: usize) -> LoadError {
+    let msg = "failed to parse CSV";
+    let pos = (err.kind().position())
+        .map(|pos| {
+            let start = pos.byte().saturating_as();
+            ReportPos::from(start..start)
+        })
+        .unwrap_or(LineCol::one_based(line, 1).into());
     match err.kind() {
-        ::csv::ErrorKind::Utf8 { .. } => "file is not valid utf-8".into(),
-        ::csv::ErrorKind::UnequalLengths { expected_len, len, .. } => {
-            eco_format!(
-                "failed to parse CSV (found {len} instead of \
-                 {expected_len} fields in line {line})"
-            )
+        ::csv::ErrorKind::Utf8 { .. } => {
+            LoadError::new(pos, msg, "file is not valid utf-8")
         }
-        _ => eco_format!("failed to parse CSV ({err})"),
+        ::csv::ErrorKind::UnequalLengths { expected_len, len, .. } => {
+            let err =
+                format!("found {len} instead of {expected_len} fields in line {line}");
+            LoadError::new(pos, msg, err)
+        }
+        _ => LoadError::new(pos, "failed to parse CSV", err),
     }
 }
diff --git a/crates/typst-library/src/loading/json.rs b/crates/typst-library/src/loading/json.rs
index aa908cca4..7d0732ba0 100644
--- a/crates/typst-library/src/loading/json.rs
+++ b/crates/typst-library/src/loading/json.rs
@@ -1,7 +1,7 @@
 use ecow::eco_format;
 use typst_syntax::Spanned;
 
-use crate::diag::{At, SourceResult};
+use crate::diag::{At, LineCol, LoadError, LoadedWithin, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::{DataSource, Load, Readable};
@@ -54,10 +54,13 @@ pub fn json(
     /// A [path]($syntax/#paths) to a JSON file or raw JSON bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
-    let data = source.load(engine.world)?;
-    serde_json::from_slice(data.as_slice())
-        .map_err(|err| eco_format!("failed to parse JSON ({err})"))
-        .at(source.span)
+    let loaded = source.load(engine.world)?;
+    serde_json::from_slice(loaded.data.as_slice())
+        .map_err(|err| {
+            let pos = LineCol::one_based(err.line(), err.column());
+            LoadError::new(pos, "failed to parse JSON", err)
+        })
+        .within(&loaded)
 }
 
 #[scope]
diff --git a/crates/typst-library/src/loading/mod.rs b/crates/typst-library/src/loading/mod.rs
index c57e02888..67f4be834 100644
--- a/crates/typst-library/src/loading/mod.rs
+++ b/crates/typst-library/src/loading/mod.rs
@@ -17,7 +17,7 @@ mod yaml_;
 
 use comemo::Tracked;
 use ecow::EcoString;
-use typst_syntax::Spanned;
+use typst_syntax::{FileId, Spanned};
 
 pub use self::cbor_::*;
 pub use self::csv_::*;
@@ -74,39 +74,44 @@ pub trait Load {
 }
 
 impl Load for Spanned<DataSource> {
-    type Output = Bytes;
+    type Output = Loaded;
 
-    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Bytes> {
+    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Self::Output> {
         self.as_ref().load(world)
     }
 }
 
 impl Load for Spanned<&DataSource> {
-    type Output = Bytes;
+    type Output = Loaded;
 
-    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Bytes> {
+    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Self::Output> {
         match &self.v {
             DataSource::Path(path) => {
                 let file_id = self.span.resolve_path(path).at(self.span)?;
-                world.file(file_id).at(self.span)
+                let data = world.file(file_id).at(self.span)?;
+                let source = Spanned::new(LoadSource::Path(file_id), self.span);
+                Ok(Loaded::new(source, data))
+            }
+            DataSource::Bytes(data) => {
+                let source = Spanned::new(LoadSource::Bytes, self.span);
+                Ok(Loaded::new(source, data.clone()))
             }
-            DataSource::Bytes(bytes) => Ok(bytes.clone()),
         }
     }
 }
 
 impl Load for Spanned<OneOrMultiple<DataSource>> {
-    type Output = Vec<Bytes>;
+    type Output = Vec<Loaded>;
 
-    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Vec<Bytes>> {
+    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Self::Output> {
         self.as_ref().load(world)
     }
 }
 
 impl Load for Spanned<&OneOrMultiple<DataSource>> {
-    type Output = Vec<Bytes>;
+    type Output = Vec<Loaded>;
 
-    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Vec<Bytes>> {
+    fn load(&self, world: Tracked<dyn World + '_>) -> SourceResult<Self::Output> {
         self.v
             .0
             .iter()
@@ -115,6 +120,28 @@ impl Load for Spanned<&OneOrMultiple<DataSource>> {
     }
 }
 
+/// Data loaded from a [`DataSource`].
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Loaded {
+    /// Details about where `data` was loaded from.
+    pub source: Spanned<LoadSource>,
+    /// The loaded data.
+    pub data: Bytes,
+}
+
+impl Loaded {
+    pub fn new(source: Spanned<LoadSource>, bytes: Bytes) -> Self {
+        Self { source, data: bytes }
+    }
+}
+
+/// A loaded [`DataSource`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum LoadSource {
+    Path(FileId),
+    Bytes,
+}
+
 /// A value that can be read from a file.
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum Readable {
diff --git a/crates/typst-library/src/loading/read.rs b/crates/typst-library/src/loading/read.rs
index 32dadc799..91e6e4366 100644
--- a/crates/typst-library/src/loading/read.rs
+++ b/crates/typst-library/src/loading/read.rs
@@ -1,11 +1,10 @@
 use ecow::EcoString;
 use typst_syntax::Spanned;
 
-use crate::diag::{At, FileError, SourceResult};
+use crate::diag::{LoadedWithin, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{func, Cast};
-use crate::loading::Readable;
-use crate::World;
+use crate::loading::{DataSource, Load, Readable};
 
 /// Reads plain text or data from a file.
 ///
@@ -36,14 +35,10 @@ pub fn read(
     #[default(Some(Encoding::Utf8))]
     encoding: Option<Encoding>,
 ) -> SourceResult<Readable> {
-    let Spanned { v: path, span } = path;
-    let id = span.resolve_path(&path).at(span)?;
-    let data = engine.world.file(id).at(span)?;
+    let loaded = path.map(DataSource::Path).load(engine.world)?;
     Ok(match encoding {
-        None => Readable::Bytes(data),
-        Some(Encoding::Utf8) => {
-            Readable::Str(data.to_str().map_err(FileError::from).at(span)?)
-        }
+        None => Readable::Bytes(loaded.data),
+        Some(Encoding::Utf8) => Readable::Str(loaded.data.to_str().within(&loaded)?),
     })
 }
 
diff --git a/crates/typst-library/src/loading/toml.rs b/crates/typst-library/src/loading/toml.rs
index f04b2e746..a4252feca 100644
--- a/crates/typst-library/src/loading/toml.rs
+++ b/crates/typst-library/src/loading/toml.rs
@@ -1,7 +1,7 @@
-use ecow::{eco_format, EcoString};
-use typst_syntax::{is_newline, Spanned};
+use ecow::eco_format;
+use typst_syntax::Spanned;
 
-use crate::diag::{At, FileError, SourceResult};
+use crate::diag::{At, LoadError, LoadedWithin, ReportPos, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::{DataSource, Load, Readable};
@@ -32,11 +32,9 @@ pub fn toml(
     /// A [path]($syntax/#paths) to a TOML file or raw TOML bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
-    let data = source.load(engine.world)?;
-    let raw = data.as_str().map_err(FileError::from).at(source.span)?;
-    ::toml::from_str(raw)
-        .map_err(|err| format_toml_error(err, raw))
-        .at(source.span)
+    let loaded = source.load(engine.world)?;
+    let raw = loaded.data.as_str().within(&loaded)?;
+    ::toml::from_str(raw).map_err(format_toml_error).within(&loaded)
 }
 
 #[scope]
@@ -71,15 +69,7 @@ impl toml {
 }
 
 /// Format the user-facing TOML error message.
-fn format_toml_error(error: ::toml::de::Error, raw: &str) -> EcoString {
-    if let Some(head) = error.span().and_then(|range| raw.get(..range.start)) {
-        let line = head.lines().count();
-        let column = 1 + head.chars().rev().take_while(|&c| !is_newline(c)).count();
-        eco_format!(
-            "failed to parse TOML ({} at line {line} column {column})",
-            error.message(),
-        )
-    } else {
-        eco_format!("failed to parse TOML ({})", error.message())
-    }
+fn format_toml_error(error: ::toml::de::Error) -> LoadError {
+    let pos = error.span().map(ReportPos::from).unwrap_or_default();
+    LoadError::new(pos, "failed to parse TOML", error.message())
 }
diff --git a/crates/typst-library/src/loading/xml.rs b/crates/typst-library/src/loading/xml.rs
index e76c4e9cf..0023c5df5 100644
--- a/crates/typst-library/src/loading/xml.rs
+++ b/crates/typst-library/src/loading/xml.rs
@@ -1,8 +1,7 @@
-use ecow::EcoString;
 use roxmltree::ParsingOptions;
 use typst_syntax::Spanned;
 
-use crate::diag::{format_xml_like_error, At, FileError, SourceResult};
+use crate::diag::{format_xml_like_error, LoadError, LoadedWithin, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{dict, func, scope, Array, Dict, IntoValue, Str, Value};
 use crate::loading::{DataSource, Load, Readable};
@@ -61,14 +60,14 @@ pub fn xml(
     /// A [path]($syntax/#paths) to an XML file or raw XML bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
-    let data = source.load(engine.world)?;
-    let text = data.as_str().map_err(FileError::from).at(source.span)?;
+    let loaded = source.load(engine.world)?;
+    let text = loaded.data.as_str().within(&loaded)?;
     let document = roxmltree::Document::parse_with_options(
         text,
         ParsingOptions { allow_dtd: true, ..Default::default() },
     )
     .map_err(format_xml_error)
-    .at(source.span)?;
+    .within(&loaded)?;
     Ok(convert_xml(document.root()))
 }
 
@@ -111,6 +110,6 @@ fn convert_xml(node: roxmltree::Node) -> Value {
 }
 
 /// Format the user-facing XML error message.
-fn format_xml_error(error: roxmltree::Error) -> EcoString {
+fn format_xml_error(error: roxmltree::Error) -> LoadError {
     format_xml_like_error("XML", error)
 }
diff --git a/crates/typst-library/src/loading/yaml.rs b/crates/typst-library/src/loading/yaml.rs
index 3f48113e8..0edf1f901 100644
--- a/crates/typst-library/src/loading/yaml.rs
+++ b/crates/typst-library/src/loading/yaml.rs
@@ -1,7 +1,7 @@
 use ecow::eco_format;
 use typst_syntax::Spanned;
 
-use crate::diag::{At, SourceResult};
+use crate::diag::{At, LineCol, LoadError, LoadedWithin, ReportPos, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{func, scope, Str, Value};
 use crate::loading::{DataSource, Load, Readable};
@@ -44,10 +44,10 @@ pub fn yaml(
     /// A [path]($syntax/#paths) to a YAML file or raw YAML bytes.
     source: Spanned<DataSource>,
 ) -> SourceResult<Value> {
-    let data = source.load(engine.world)?;
-    serde_yaml::from_slice(data.as_slice())
-        .map_err(|err| eco_format!("failed to parse YAML ({err})"))
-        .at(source.span)
+    let loaded = source.load(engine.world)?;
+    serde_yaml::from_slice(loaded.data.as_slice())
+        .map_err(format_yaml_error)
+        .within(&loaded)
 }
 
 #[scope]
@@ -76,3 +76,16 @@ impl yaml {
             .at(span)
     }
 }
+
+/// Format the user-facing YAML error message.
+pub fn format_yaml_error(error: serde_yaml::Error) -> LoadError {
+    let pos = error
+        .location()
+        .map(|loc| {
+            let line_col = LineCol::one_based(loc.line(), loc.column());
+            let range = loc.index()..loc.index();
+            ReportPos::full(range, line_col)
+        })
+        .unwrap_or_default();
+    LoadError::new(pos, "failed to parse YAML", error)
+}
diff --git a/crates/typst-library/src/math/accent.rs b/crates/typst-library/src/math/accent.rs
index b162c52b1..f2c9168c2 100644
--- a/crates/typst-library/src/math/accent.rs
+++ b/crates/typst-library/src/math/accent.rs
@@ -13,8 +13,8 @@ use crate::math::Mathy;
 /// ```
 #[elem(Mathy)]
 pub struct AccentElem {
-    /// The base to which the accent is applied.
-    /// May consist of multiple letters.
+    /// The base to which the accent is applied. May consist of multiple
+    /// letters.
     ///
     /// ```example
     /// $arrow(A B C)$
@@ -51,9 +51,24 @@ pub struct AccentElem {
     pub accent: Accent,
 
     /// The size of the accent, relative to the width of the base.
+    ///
+    /// ```example
+    /// $dash(A, size: #150%)$
+    /// ```
     #[resolve]
     #[default(Rel::one())]
     pub size: Rel<Length>,
+
+    /// Whether to remove the dot on top of lowercase i and j when adding a top
+    /// accent.
+    ///
+    /// This enables the `dtls` OpenType feature.
+    ///
+    /// ```example
+    /// $hat(dotless: #false, i)$
+    /// ```
+    #[default(true)]
+    pub dotless: bool,
 }
 
 /// An accent character.
@@ -65,6 +80,19 @@ impl Accent {
     pub fn new(c: char) -> Self {
         Self(Self::combine(c).unwrap_or(c))
     }
+
+    /// List of bottom accents. Currently just a list of ones included in the
+    /// Unicode math class document.
+    const BOTTOM: &[char] = &[
+        '\u{0323}', '\u{032C}', '\u{032D}', '\u{032E}', '\u{032F}', '\u{0330}',
+        '\u{0331}', '\u{0332}', '\u{0333}', '\u{033A}', '\u{20E8}', '\u{20EC}',
+        '\u{20ED}', '\u{20EE}', '\u{20EF}',
+    ];
+
+    /// Whether this accent is a bottom accent or not.
+    pub fn is_bottom(&self) -> bool {
+        Self::BOTTOM.contains(&self.0)
+    }
 }
 
 /// This macro generates accent-related functions.
@@ -103,11 +131,18 @@ macro_rules! accents {
                 /// The size of the accent, relative to the width of the base.
                 #[named]
                 size: Option<Rel<Length>>,
+                /// Whether to remove the dot on top of lowercase i and j when
+                /// adding a top accent.
+                #[named]
+                dotless: Option<bool>,
             ) -> Content {
                 let mut accent = AccentElem::new(base, Accent::new($primary));
                 if let Some(size) = size {
                     accent = accent.with_size(size);
                 }
+                if let Some(dotless) = dotless {
+                    accent = accent.with_dotless(dotless);
+                }
                 accent.pack()
             }
         )+
diff --git a/crates/typst-library/src/math/frac.rs b/crates/typst-library/src/math/frac.rs
index f5c4514d6..dd5986b5f 100644
--- a/crates/typst-library/src/math/frac.rs
+++ b/crates/typst-library/src/math/frac.rs
@@ -15,7 +15,7 @@ use crate::math::Mathy;
 /// # Syntax
 /// This function also has dedicated syntax: Use a slash to turn neighbouring
 /// expressions into a fraction. Multiple atoms can be grouped into a single
-/// expression using round grouping parenthesis. Such parentheses are removed
+/// expression using round grouping parentheses. Such parentheses are removed
 /// from the output, but you can nest multiple to force them.
 #[elem(title = "Fraction", Mathy)]
 pub struct FracElem {
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index b11c61789..a85efc810 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -6,7 +6,7 @@ use std::num::NonZeroUsize;
 use std::path::Path;
 use std::sync::{Arc, LazyLock};
 
-use comemo::Tracked;
+use comemo::{Track, Tracked};
 use ecow::{eco_format, EcoString, EcoVec};
 use hayagriva::archive::ArchivedStyle;
 use hayagriva::io::BibLaTeXError;
@@ -19,8 +19,11 @@ use smallvec::{smallvec, SmallVec};
 use typst_syntax::{Span, Spanned};
 use typst_utils::{Get, ManuallyHash, NonZeroExt, PicoStr};
 
-use crate::diag::{bail, error, At, FileError, HintedStrResult, SourceResult, StrResult};
-use crate::engine::Engine;
+use crate::diag::{
+    bail, error, At, HintedStrResult, LoadError, LoadResult, LoadedWithin, ReportPos,
+    SourceResult, StrResult,
+};
+use crate::engine::{Engine, Sink};
 use crate::foundations::{
     elem, Bytes, CastInfo, Content, Derived, FromValue, IntoValue, Label, NativeElement,
     OneOrMultiple, Packed, Reflect, Scope, Show, ShowSet, Smart, StyleChain, Styles,
@@ -31,7 +34,7 @@ use crate::layout::{
     BlockBody, BlockElem, Em, GridCell, GridChild, GridElem, GridItem, HElem, PadElem,
     Sides, Sizing, TrackSizings,
 };
-use crate::loading::{DataSource, Load};
+use crate::loading::{format_yaml_error, DataSource, Load, LoadSource, Loaded};
 use crate::model::{
     CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, ParElem,
     Url,
@@ -48,8 +51,8 @@ use crate::World;
 /// You can create a new bibliography by calling this function with a path
 /// to a bibliography file in either one of two formats:
 ///
-/// - A Hayagriva `.yml` file. Hayagriva is a new bibliography file format
-///   designed for use with Typst. Visit its
+/// - A Hayagriva `.yaml`/`.yml` file. Hayagriva is a new bibliography
+///   file format designed for use with Typst. Visit its
 ///   [documentation](https://github.com/typst/hayagriva/blob/main/docs/file-format.md)
 ///   for more details.
 /// - A BibLaTeX `.bib` file.
@@ -224,7 +227,15 @@ impl Show for Packed<BibliographyElem> {
         let references = works
             .references
             .as_ref()
-            .ok_or("CSL style is not suitable for bibliographies")
+            .ok_or_else(|| match self.style(styles).source {
+                CslSource::Named(style) => eco_format!(
+                    "CSL style \"{}\" is not suitable for bibliographies",
+                    style.display_name()
+                ),
+                CslSource::Normal(..) => {
+                    "CSL style is not suitable for bibliographies".into()
+                }
+            })
             .at(span)?;
 
         if references.iter().any(|(prefix, _)| prefix.is_some()) {
@@ -294,24 +305,21 @@ impl Bibliography {
         world: Tracked<dyn World + '_>,
         sources: Spanned<OneOrMultiple<DataSource>>,
     ) -> SourceResult<Derived<OneOrMultiple<DataSource>, Self>> {
-        let data = sources.load(world)?;
-        let bibliography = Self::decode(&sources.v, &data).at(sources.span)?;
+        let loaded = sources.load(world)?;
+        let bibliography = Self::decode(&loaded)?;
         Ok(Derived::new(sources.v, bibliography))
     }
 
     /// Decode a bibliography from loaded data sources.
     #[comemo::memoize]
     #[typst_macros::time(name = "load bibliography")]
-    fn decode(
-        sources: &OneOrMultiple<DataSource>,
-        data: &[Bytes],
-    ) -> StrResult<Bibliography> {
+    fn decode(data: &[Loaded]) -> SourceResult<Bibliography> {
         let mut map = IndexMap::new();
         let mut duplicates = Vec::<EcoString>::new();
 
         // We might have multiple bib/yaml files
-        for (source, data) in sources.0.iter().zip(data) {
-            let library = decode_library(source, data)?;
+        for d in data.iter() {
+            let library = decode_library(d)?;
             for entry in library {
                 match map.entry(Label::new(PicoStr::intern(entry.key()))) {
                     indexmap::map::Entry::Vacant(vacant) => {
@@ -325,7 +333,11 @@ impl Bibliography {
         }
 
         if !duplicates.is_empty() {
-            bail!("duplicate bibliography keys: {}", duplicates.join(", "));
+            // TODO: Store spans of entries for duplicate key error messages.
+            // Requires hayagriva entries to store their location, which should
+            // be fine, since they are 1kb anyway.
+            let span = data.first().unwrap().source.span;
+            bail!(span, "duplicate bibliography keys: {}", duplicates.join(", "));
         }
 
         Ok(Bibliography(Arc::new(ManuallyHash::new(map, typst_utils::hash128(data)))))
@@ -351,36 +363,47 @@ impl Debug for Bibliography {
 }
 
 /// Decode on library from one data source.
-fn decode_library(source: &DataSource, data: &Bytes) -> StrResult<Library> {
-    let src = data.as_str().map_err(FileError::from)?;
+fn decode_library(loaded: &Loaded) -> SourceResult<Library> {
+    let data = loaded.data.as_str().within(loaded)?;
 
-    if let DataSource::Path(path) = source {
+    if let LoadSource::Path(file_id) = loaded.source.v {
         // If we got a path, use the extension to determine whether it is
         // YAML or BibLaTeX.
-        let ext = Path::new(path.as_str())
+        let ext = file_id
+            .vpath()
+            .as_rooted_path()
             .extension()
             .and_then(OsStr::to_str)
             .unwrap_or_default();
 
         match ext.to_lowercase().as_str() {
-            "yml" | "yaml" => hayagriva::io::from_yaml_str(src)
-                .map_err(|err| eco_format!("failed to parse YAML ({err})")),
-            "bib" => hayagriva::io::from_biblatex_str(src)
-                .map_err(|errors| format_biblatex_error(src, Some(path), errors)),
-            _ => bail!("unknown bibliography format (must be .yml/.yaml or .bib)"),
+            "yml" | "yaml" => hayagriva::io::from_yaml_str(data)
+                .map_err(format_yaml_error)
+                .within(loaded),
+            "bib" => hayagriva::io::from_biblatex_str(data)
+                .map_err(format_biblatex_error)
+                .within(loaded),
+            _ => bail!(
+                loaded.source.span,
+                "unknown bibliography format (must be .yml/.yaml or .bib)"
+            ),
         }
     } else {
         // If we just got bytes, we need to guess. If it can be decoded as
         // hayagriva YAML, we'll use that.
-        let haya_err = match hayagriva::io::from_yaml_str(src) {
+        let haya_err = match hayagriva::io::from_yaml_str(data) {
             Ok(library) => return Ok(library),
             Err(err) => err,
         };
 
         // If it can be decoded as BibLaTeX, we use that isntead.
-        let bib_errs = match hayagriva::io::from_biblatex_str(src) {
-            Ok(library) => return Ok(library),
-            Err(err) => err,
+        let bib_errs = match hayagriva::io::from_biblatex_str(data) {
+            // If the file is almost valid yaml, but contains no `@` character
+            // it will be successfully parsed as an empty BibLaTeX library,
+            // since BibLaTeX does support arbitrary text outside of entries.
+            Ok(library) if !library.is_empty() => return Ok(library),
+            Ok(_) => None,
+            Err(err) => Some(err),
         };
 
         // If neither decoded correctly, check whether `:` or `{` appears
@@ -388,7 +411,7 @@ fn decode_library(source: &DataSource, data: &Bytes) -> StrResult<Library> {
         // and emit the more appropriate error.
         let mut yaml = 0;
         let mut biblatex = 0;
-        for c in src.chars() {
+        for c in data.chars() {
             match c {
                 ':' => yaml += 1,
                 '{' => biblatex += 1,
@@ -396,37 +419,33 @@ fn decode_library(source: &DataSource, data: &Bytes) -> StrResult<Library> {
             }
         }
 
-        if yaml > biblatex {
-            bail!("failed to parse YAML ({haya_err})")
-        } else {
-            Err(format_biblatex_error(src, None, bib_errs))
+        match bib_errs {
+            Some(bib_errs) if biblatex >= yaml => {
+                Err(format_biblatex_error(bib_errs)).within(loaded)
+            }
+            _ => Err(format_yaml_error(haya_err)).within(loaded),
         }
     }
 }
 
 /// Format a BibLaTeX loading error.
-fn format_biblatex_error(
-    src: &str,
-    path: Option<&str>,
-    errors: Vec<BibLaTeXError>,
-) -> EcoString {
-    let Some(error) = errors.first() else {
-        return match path {
-            Some(path) => eco_format!("failed to parse BibLaTeX file ({path})"),
-            None => eco_format!("failed to parse BibLaTeX"),
-        };
+fn format_biblatex_error(errors: Vec<BibLaTeXError>) -> LoadError {
+    // TODO: return multiple errors?
+    let Some(error) = errors.into_iter().next() else {
+        // TODO: can this even happen, should we just unwrap?
+        return LoadError::new(
+            ReportPos::None,
+            "failed to parse BibLaTeX",
+            "something went wrong",
+        );
     };
 
-    let (span, msg) = match error {
-        BibLaTeXError::Parse(error) => (&error.span, error.kind.to_string()),
-        BibLaTeXError::Type(error) => (&error.span, error.kind.to_string()),
+    let (range, msg) = match error {
+        BibLaTeXError::Parse(error) => (error.span, error.kind.to_string()),
+        BibLaTeXError::Type(error) => (error.span, error.kind.to_string()),
     };
 
-    let line = src.get(..span.start).unwrap_or_default().lines().count();
-    match path {
-        Some(path) => eco_format!("failed to parse BibLaTeX file ({path}:{line}: {msg})"),
-        None => eco_format!("failed to parse BibLaTeX ({line}: {msg})"),
-    }
+    LoadError::new(range, "failed to parse BibLaTeX", msg)
 }
 
 /// A loaded CSL style.
@@ -442,8 +461,8 @@ impl CslStyle {
         let style = match &source {
             CslSource::Named(style) => Self::from_archived(*style),
             CslSource::Normal(source) => {
-                let data = Spanned::new(source, span).load(world)?;
-                Self::from_data(data).at(span)?
+                let loaded = Spanned::new(source, span).load(world)?;
+                Self::from_data(&loaded.data).within(&loaded)?
             }
         };
         Ok(Derived::new(source, style))
@@ -464,16 +483,18 @@ impl CslStyle {
 
     /// Load a CSL style from file contents.
     #[comemo::memoize]
-    pub fn from_data(data: Bytes) -> StrResult<CslStyle> {
-        let text = data.as_str().map_err(FileError::from)?;
+    pub fn from_data(bytes: &Bytes) -> LoadResult<CslStyle> {
+        let text = bytes.as_str()?;
         citationberg::IndependentStyle::from_xml(text)
             .map(|style| {
                 Self(Arc::new(ManuallyHash::new(
                     style,
-                    typst_utils::hash128(&(TypeId::of::<Bytes>(), data)),
+                    typst_utils::hash128(&(TypeId::of::<Bytes>(), bytes)),
                 )))
             })
-            .map_err(|err| eco_format!("failed to load CSL style ({err})"))
+            .map_err(|err| {
+                LoadError::new(ReportPos::None, "failed to load CSL style", err)
+            })
     }
 
     /// Get the underlying independent style.
@@ -999,6 +1020,8 @@ impl ElemRenderer<'_> {
         (self.routines.eval_string)(
             self.routines,
             self.world,
+            // TODO: propagate warnings
+            Sink::new().track_mut(),
             math,
             self.span,
             EvalMode::Math,
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index a4126e72c..f1f93702b 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -129,7 +129,7 @@ pub struct EnumElem {
     ///   [Ahead],
     /// )
     /// ```
-    pub start: Smart<usize>,
+    pub start: Smart<u64>,
 
     /// Whether to display the full numbering, including the numbers of
     /// all parent enumerations.
@@ -217,7 +217,7 @@ pub struct EnumElem {
     #[internal]
     #[fold]
     #[ghost]
-    pub parents: SmallVec<[usize; 4]>,
+    pub parents: SmallVec<[u64; 4]>,
 }
 
 #[scope]
@@ -259,10 +259,11 @@ impl Show for Packed<EnumElem> {
                 .spanned(self.span());
 
         if tight {
-            let leading = ParElem::leading_in(styles);
-            let spacing =
-                VElem::new(leading.into()).with_weak(true).with_attach(true).pack();
-            realized = spacing + realized;
+            let spacing = self
+                .spacing(styles)
+                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+            let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
+            realized = v + realized;
         }
 
         Ok(realized)
@@ -274,7 +275,7 @@ impl Show for Packed<EnumElem> {
 pub struct EnumItem {
     /// The item's number.
     #[positional]
-    pub number: Option<usize>,
+    pub number: Option<u64>,
 
     /// The item's body.
     #[required]
diff --git a/crates/typst-library/src/model/figure.rs b/crates/typst-library/src/model/figure.rs
index 78a79a8e2..bec667d6e 100644
--- a/crates/typst-library/src/model/figure.rs
+++ b/crates/typst-library/src/model/figure.rs
@@ -125,6 +125,9 @@ pub struct FigureElem {
     ///
     /// ```example
     /// #set page(height: 200pt)
+    /// #show figure: set place(
+    ///   clearance: 1em,
+    /// )
     ///
     /// = Introduction
     /// #figure(
@@ -457,7 +460,7 @@ impl Outlinable for Packed<FigureElem> {
 /// customize the appearance of captions for all figures or figures of a
 /// specific kind.
 ///
-/// In addition to its `pos` and `body`, the `caption` also provides the
+/// In addition to its `position` and `body`, the `caption` also provides the
 /// figure's `kind`, `supplement`, `counter`, and `numbering` as fields. These
 /// parts can be used in [`where`]($function.where) selectors and show rules to
 /// build a completely custom caption.
diff --git a/crates/typst-library/src/model/list.rs b/crates/typst-library/src/model/list.rs
index d93ec9172..3c3afd338 100644
--- a/crates/typst-library/src/model/list.rs
+++ b/crates/typst-library/src/model/list.rs
@@ -166,10 +166,11 @@ impl Show for Packed<ListElem> {
                 .spanned(self.span());
 
         if tight {
-            let leading = ParElem::leading_in(styles);
-            let spacing =
-                VElem::new(leading.into()).with_weak(true).with_attach(true).pack();
-            realized = spacing + realized;
+            let spacing = self
+                .spacing(styles)
+                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+            let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
+            realized = v + realized;
         }
 
         Ok(realized)
diff --git a/crates/typst-library/src/model/numbering.rs b/crates/typst-library/src/model/numbering.rs
index ada8a3965..236ced361 100644
--- a/crates/typst-library/src/model/numbering.rs
+++ b/crates/typst-library/src/model/numbering.rs
@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use chinese_number::{
-    from_usize_to_chinese_ten_thousand as usize_to_chinese, ChineseCase, ChineseVariant,
+    from_u64_to_chinese_ten_thousand as u64_to_chinese, ChineseCase, ChineseVariant,
 };
 use comemo::Tracked;
 use ecow::{eco_format, EcoString, EcoVec};
@@ -9,7 +9,6 @@ use ecow::{eco_format, EcoString, EcoVec};
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{cast, func, Context, Func, Str, Value};
-use crate::text::Case;
 
 /// Applies a numbering to a sequence of numbers.
 ///
@@ -85,7 +84,7 @@ pub fn numbering(
     /// If `numbering` is a pattern and more numbers than counting symbols are
     /// given, the last counting symbol with its prefix is repeated.
     #[variadic]
-    numbers: Vec<usize>,
+    numbers: Vec<u64>,
 ) -> SourceResult<Value> {
     numbering.apply(engine, context, &numbers)
 }
@@ -105,7 +104,7 @@ impl Numbering {
         &self,
         engine: &mut Engine,
         context: Tracked<Context>,
-        numbers: &[usize],
+        numbers: &[u64],
     ) -> SourceResult<Value> {
         Ok(match self {
             Self::Pattern(pattern) => Value::Str(pattern.apply(numbers).into()),
@@ -156,7 +155,7 @@ pub struct NumberingPattern {
 
 impl NumberingPattern {
     /// Apply the pattern to the given number.
-    pub fn apply(&self, numbers: &[usize]) -> EcoString {
+    pub fn apply(&self, numbers: &[u64]) -> EcoString {
         let mut fmt = EcoString::new();
         let mut numbers = numbers.iter();
 
@@ -185,7 +184,7 @@ impl NumberingPattern {
     }
 
     /// Apply only the k-th segment of the pattern to a number.
-    pub fn apply_kth(&self, k: usize, number: usize) -> EcoString {
+    pub fn apply_kth(&self, k: usize, number: u64) -> EcoString {
         let mut fmt = EcoString::new();
         if let Some((prefix, _)) = self.pieces.first() {
             fmt.push_str(prefix);
@@ -261,9 +260,9 @@ pub enum NumberingKind {
     LowerRoman,
     /// Uppercase Roman numerals (I, II, III, etc.).
     UpperRoman,
-    /// Lowercase Greek numerals (Α, Β, Γ, etc.).
+    /// Lowercase Greek letters (α, β, γ, etc.).
     LowerGreek,
-    /// Uppercase Greek numerals (α, β, γ, etc.).
+    /// Uppercase Greek letters (Α, Β, Γ, etc.).
     UpperGreek,
     /// Paragraph/note-like symbols: *, †, ‡, §, ¶, and ‖. Further items use
     /// repeated symbols.
@@ -379,41 +378,196 @@ impl NumberingKind {
     }
 
     /// Apply the numbering to the given number.
-    pub fn apply(self, n: usize) -> EcoString {
+    pub fn apply(self, n: u64) -> EcoString {
         match self {
-            Self::Arabic => eco_format!("{n}"),
-            Self::LowerRoman => roman_numeral(n, Case::Lower),
-            Self::UpperRoman => roman_numeral(n, Case::Upper),
-            Self::LowerGreek => greek_numeral(n, Case::Lower),
-            Self::UpperGreek => greek_numeral(n, Case::Upper),
-            Self::Symbol => {
-                if n == 0 {
-                    return '-'.into();
-                }
-
-                const SYMBOLS: &[char] = &['*', '†', '‡', '§', '¶', '‖'];
-                let symbol = SYMBOLS[(n - 1) % SYMBOLS.len()];
-                let amount = ((n - 1) / SYMBOLS.len()) + 1;
-                std::iter::repeat_n(symbol, amount).collect()
+            Self::Arabic => {
+                numeric(&['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], n)
             }
-            Self::Hebrew => hebrew_numeral(n),
-
-            Self::LowerLatin => zeroless(
-                [
+            Self::LowerRoman => additive(
+                &[
+                    ("m̅", 1000000),
+                    ("d̅", 500000),
+                    ("c̅", 100000),
+                    ("l̅", 50000),
+                    ("x̅", 10000),
+                    ("v̅", 5000),
+                    ("i̅v̅", 4000),
+                    ("m", 1000),
+                    ("cm", 900),
+                    ("d", 500),
+                    ("cd", 400),
+                    ("c", 100),
+                    ("xc", 90),
+                    ("l", 50),
+                    ("xl", 40),
+                    ("x", 10),
+                    ("ix", 9),
+                    ("v", 5),
+                    ("iv", 4),
+                    ("i", 1),
+                    ("n", 0),
+                ],
+                n,
+            ),
+            Self::UpperRoman => additive(
+                &[
+                    ("M̅", 1000000),
+                    ("D̅", 500000),
+                    ("C̅", 100000),
+                    ("L̅", 50000),
+                    ("X̅", 10000),
+                    ("V̅", 5000),
+                    ("I̅V̅", 4000),
+                    ("M", 1000),
+                    ("CM", 900),
+                    ("D", 500),
+                    ("CD", 400),
+                    ("C", 100),
+                    ("XC", 90),
+                    ("L", 50),
+                    ("XL", 40),
+                    ("X", 10),
+                    ("IX", 9),
+                    ("V", 5),
+                    ("IV", 4),
+                    ("I", 1),
+                    ("N", 0),
+                ],
+                n,
+            ),
+            Self::LowerGreek => additive(
+                &[
+                    ("͵θ", 9000),
+                    ("͵η", 8000),
+                    ("͵ζ", 7000),
+                    ("͵ϛ", 6000),
+                    ("͵ε", 5000),
+                    ("͵δ", 4000),
+                    ("͵γ", 3000),
+                    ("͵β", 2000),
+                    ("͵α", 1000),
+                    ("ϡ", 900),
+                    ("ω", 800),
+                    ("ψ", 700),
+                    ("χ", 600),
+                    ("φ", 500),
+                    ("υ", 400),
+                    ("τ", 300),
+                    ("σ", 200),
+                    ("ρ", 100),
+                    ("ϟ", 90),
+                    ("π", 80),
+                    ("ο", 70),
+                    ("ξ", 60),
+                    ("ν", 50),
+                    ("μ", 40),
+                    ("λ", 30),
+                    ("κ", 20),
+                    ("ι", 10),
+                    ("θ", 9),
+                    ("η", 8),
+                    ("ζ", 7),
+                    ("ϛ", 6),
+                    ("ε", 5),
+                    ("δ", 4),
+                    ("γ", 3),
+                    ("β", 2),
+                    ("α", 1),
+                    ("𐆊", 0),
+                ],
+                n,
+            ),
+            Self::UpperGreek => additive(
+                &[
+                    ("͵Θ", 9000),
+                    ("͵Η", 8000),
+                    ("͵Ζ", 7000),
+                    ("͵Ϛ", 6000),
+                    ("͵Ε", 5000),
+                    ("͵Δ", 4000),
+                    ("͵Γ", 3000),
+                    ("͵Β", 2000),
+                    ("͵Α", 1000),
+                    ("Ϡ", 900),
+                    ("Ω", 800),
+                    ("Ψ", 700),
+                    ("Χ", 600),
+                    ("Φ", 500),
+                    ("Υ", 400),
+                    ("Τ", 300),
+                    ("Σ", 200),
+                    ("Ρ", 100),
+                    ("Ϟ", 90),
+                    ("Π", 80),
+                    ("Ο", 70),
+                    ("Ξ", 60),
+                    ("Ν", 50),
+                    ("Μ", 40),
+                    ("Λ", 30),
+                    ("Κ", 20),
+                    ("Ι", 10),
+                    ("Θ", 9),
+                    ("Η", 8),
+                    ("Ζ", 7),
+                    ("Ϛ", 6),
+                    ("Ε", 5),
+                    ("Δ", 4),
+                    ("Γ", 3),
+                    ("Β", 2),
+                    ("Α", 1),
+                    ("𐆊", 0),
+                ],
+                n,
+            ),
+            Self::Hebrew => additive(
+                &[
+                    ("ת", 400),
+                    ("ש", 300),
+                    ("ר", 200),
+                    ("ק", 100),
+                    ("צ", 90),
+                    ("פ", 80),
+                    ("ע", 70),
+                    ("ס", 60),
+                    ("נ", 50),
+                    ("מ", 40),
+                    ("ל", 30),
+                    ("כ", 20),
+                    ("יט", 19),
+                    ("יח", 18),
+                    ("יז", 17),
+                    ("טז", 16),
+                    ("טו", 15),
+                    ("י", 10),
+                    ("ט", 9),
+                    ("ח", 8),
+                    ("ז", 7),
+                    ("ו", 6),
+                    ("ה", 5),
+                    ("ד", 4),
+                    ("ג", 3),
+                    ("ב", 2),
+                    ("א", 1),
+                    ("-", 0),
+                ],
+                n,
+            ),
+            Self::LowerLatin => alphabetic(
+                &[
                     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
                     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
                 ],
                 n,
             ),
-            Self::UpperLatin => zeroless(
-                [
+            Self::UpperLatin => alphabetic(
+                &[
                     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
                     'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
                 ],
                 n,
             ),
-            Self::HiraganaAiueo => zeroless(
-                [
+            Self::HiraganaAiueo => alphabetic(
+                &[
                     'あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ', 'さ',
                     'し', 'す', 'せ', 'そ', 'た', 'ち', 'つ', 'て', 'と', 'な', 'に',
                     'ぬ', 'ね', 'の', 'は', 'ひ', 'ふ', 'へ', 'ほ', 'ま', 'み', 'む',
@@ -422,8 +576,8 @@ impl NumberingKind {
                 ],
                 n,
             ),
-            Self::HiraganaIroha => zeroless(
-                [
+            Self::HiraganaIroha => alphabetic(
+                &[
                     'い', 'ろ', 'は', 'に', 'ほ', 'へ', 'と', 'ち', 'り', 'ぬ', 'る',
                     'を', 'わ', 'か', 'よ', 'た', 'れ', 'そ', 'つ', 'ね', 'な', 'ら',
                     'む', 'う', 'ゐ', 'の', 'お', 'く', 'や', 'ま', 'け', 'ふ', 'こ',
@@ -432,8 +586,8 @@ impl NumberingKind {
                 ],
                 n,
             ),
-            Self::KatakanaAiueo => zeroless(
-                [
+            Self::KatakanaAiueo => alphabetic(
+                &[
                     'ア', 'イ', 'ウ', 'エ', 'オ', 'カ', 'キ', 'ク', 'ケ', 'コ', 'サ',
                     'シ', 'ス', 'セ', 'ソ', 'タ', 'チ', 'ツ', 'テ', 'ト', 'ナ', 'ニ',
                     'ヌ', 'ネ', 'ノ', 'ハ', 'ヒ', 'フ', 'ヘ', 'ホ', 'マ', 'ミ', 'ム',
@@ -442,8 +596,8 @@ impl NumberingKind {
                 ],
                 n,
             ),
-            Self::KatakanaIroha => zeroless(
-                [
+            Self::KatakanaIroha => alphabetic(
+                &[
                     'イ', 'ロ', 'ハ', 'ニ', 'ホ', 'ヘ', 'ト', 'チ', 'リ', 'ヌ', 'ル',
                     'ヲ', 'ワ', 'カ', 'ヨ', 'タ', 'レ', 'ソ', 'ツ', 'ネ', 'ナ', 'ラ',
                     'ム', 'ウ', 'ヰ', 'ノ', 'オ', 'ク', 'ヤ', 'マ', 'ケ', 'フ', 'コ',
@@ -452,359 +606,219 @@ impl NumberingKind {
                 ],
                 n,
             ),
-            Self::KoreanJamo => zeroless(
-                [
+            Self::KoreanJamo => alphabetic(
+                &[
                     'ㄱ', 'ㄴ', 'ㄷ', 'ㄹ', 'ㅁ', 'ㅂ', 'ㅅ', 'ㅇ', 'ㅈ', 'ㅊ', 'ㅋ',
                     'ㅌ', 'ㅍ', 'ㅎ',
                 ],
                 n,
             ),
-            Self::KoreanSyllable => zeroless(
-                [
+            Self::KoreanSyllable => alphabetic(
+                &[
                     '가', '나', '다', '라', '마', '바', '사', '아', '자', '차', '카',
                     '타', '파', '하',
                 ],
                 n,
             ),
-            Self::BengaliLetter => zeroless(
-                [
+            Self::BengaliLetter => alphabetic(
+                &[
                     'ক', 'খ', 'গ', 'ঘ', 'ঙ', 'চ', 'ছ', 'জ', 'ঝ', 'ঞ', 'ট', 'ঠ', 'ড', 'ঢ',
                     'ণ', 'ত', 'থ', 'দ', 'ধ', 'ন', 'প', 'ফ', 'ব', 'ভ', 'ম', 'য', 'র', 'ল',
                     'শ', 'ষ', 'স', 'হ',
                 ],
                 n,
             ),
-            Self::CircledNumber => zeroless(
-                [
-                    '①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨', '⑩', '⑪', '⑫', '⑬', '⑭',
-                    '⑮', '⑯', '⑰', '⑱', '⑲', '⑳', '㉑', '㉒', '㉓', '㉔', '㉕', '㉖',
-                    '㉗', '㉘', '㉙', '㉚', '㉛', '㉜', '㉝', '㉞', '㉟', '㊱', '㊲',
-                    '㊳', '㊴', '㊵', '㊶', '㊷', '㊸', '㊹', '㊺', '㊻', '㊼', '㊽',
-                    '㊾', '㊿',
+            Self::CircledNumber => fixed(
+                &[
+                    '⓪', '①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨', '⑩', '⑪', '⑫', '⑬',
+                    '⑭', '⑮', '⑯', '⑰', '⑱', '⑲', '⑳', '㉑', '㉒', '㉓', '㉔', '㉕',
+                    '㉖', '㉗', '㉘', '㉙', '㉚', '㉛', '㉜', '㉝', '㉞', '㉟', '㊱',
+                    '㊲', '㊳', '㊴', '㊵', '㊶', '㊷', '㊸', '㊹', '㊺', '㊻', '㊼',
+                    '㊽', '㊾', '㊿',
                 ],
                 n,
             ),
             Self::DoubleCircledNumber => {
-                zeroless(['⓵', '⓶', '⓷', '⓸', '⓹', '⓺', '⓻', '⓼', '⓽', '⓾'], n)
+                fixed(&['0', '⓵', '⓶', '⓷', '⓸', '⓹', '⓺', '⓻', '⓼', '⓽', '⓾'], n)
             }
 
             Self::LowerSimplifiedChinese => {
-                usize_to_chinese(ChineseVariant::Simple, ChineseCase::Lower, n).into()
+                u64_to_chinese(ChineseVariant::Simple, ChineseCase::Lower, n).into()
             }
             Self::UpperSimplifiedChinese => {
-                usize_to_chinese(ChineseVariant::Simple, ChineseCase::Upper, n).into()
+                u64_to_chinese(ChineseVariant::Simple, ChineseCase::Upper, n).into()
             }
             Self::LowerTraditionalChinese => {
-                usize_to_chinese(ChineseVariant::Traditional, ChineseCase::Lower, n)
-                    .into()
+                u64_to_chinese(ChineseVariant::Traditional, ChineseCase::Lower, n).into()
             }
             Self::UpperTraditionalChinese => {
-                usize_to_chinese(ChineseVariant::Traditional, ChineseCase::Upper, n)
-                    .into()
+                u64_to_chinese(ChineseVariant::Traditional, ChineseCase::Upper, n).into()
             }
 
-            Self::EasternArabic => decimal('\u{0660}', n),
-            Self::EasternArabicPersian => decimal('\u{06F0}', n),
-            Self::DevanagariNumber => decimal('\u{0966}', n),
-            Self::BengaliNumber => decimal('\u{09E6}', n),
-        }
-    }
-}
-
-/// Stringify an integer to a Hebrew number.
-fn hebrew_numeral(mut n: usize) -> EcoString {
-    if n == 0 {
-        return '-'.into();
-    }
-    let mut fmt = EcoString::new();
-    'outer: for (name, value) in [
-        ('ת', 400),
-        ('ש', 300),
-        ('ר', 200),
-        ('ק', 100),
-        ('צ', 90),
-        ('פ', 80),
-        ('ע', 70),
-        ('ס', 60),
-        ('נ', 50),
-        ('מ', 40),
-        ('ל', 30),
-        ('כ', 20),
-        ('י', 10),
-        ('ט', 9),
-        ('ח', 8),
-        ('ז', 7),
-        ('ו', 6),
-        ('ה', 5),
-        ('ד', 4),
-        ('ג', 3),
-        ('ב', 2),
-        ('א', 1),
-    ] {
-        while n >= value {
-            match n {
-                15 => fmt.push_str("ט״ו"),
-                16 => fmt.push_str("ט״ז"),
-                _ => {
-                    let append_geresh = n == value && fmt.is_empty();
-                    if n == value && !fmt.is_empty() {
-                        fmt.push('״');
-                    }
-                    fmt.push(name);
-                    if append_geresh {
-                        fmt.push('׳');
-                    }
-
-                    n -= value;
-                    continue;
-                }
+            Self::EasternArabic => {
+                numeric(&['٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'], n)
             }
-            break 'outer;
-        }
-    }
-    fmt
-}
-
-/// Stringify an integer to a Roman numeral.
-fn roman_numeral(mut n: usize, case: Case) -> EcoString {
-    if n == 0 {
-        return match case {
-            Case::Lower => 'n'.into(),
-            Case::Upper => 'N'.into(),
-        };
-    }
-
-    // Adapted from Yann Villessuzanne's roman.rs under the
-    // Unlicense, at https://github.com/linfir/roman.rs/
-    let mut fmt = EcoString::new();
-    for &(name, value) in &[
-        ("M̅", 1000000),
-        ("D̅", 500000),
-        ("C̅", 100000),
-        ("L̅", 50000),
-        ("X̅", 10000),
-        ("V̅", 5000),
-        ("I̅V̅", 4000),
-        ("M", 1000),
-        ("CM", 900),
-        ("D", 500),
-        ("CD", 400),
-        ("C", 100),
-        ("XC", 90),
-        ("L", 50),
-        ("XL", 40),
-        ("X", 10),
-        ("IX", 9),
-        ("V", 5),
-        ("IV", 4),
-        ("I", 1),
-    ] {
-        while n >= value {
-            n -= value;
-            for c in name.chars() {
-                match case {
-                    Case::Lower => fmt.extend(c.to_lowercase()),
-                    Case::Upper => fmt.push(c),
-                }
+            Self::EasternArabicPersian => {
+                numeric(&['۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹'], n)
             }
+            Self::DevanagariNumber => {
+                numeric(&['०', '१', '२', '३', '४', '५', '६', '७', '८', '९'], n)
+            }
+            Self::BengaliNumber => {
+                numeric(&['০', '১', '২', '৩', '৪', '৫', '৬', '৭', '৮', '৯'], n)
+            }
+            Self::Symbol => symbolic(&['*', '†', '‡', '§', '¶', '‖'], n),
         }
     }
-
-    fmt
 }
 
-/// Stringify an integer to Greek numbers.
+/// Stringify a number using symbols representing values. The decimal
+/// representation of the number is recovered by summing over the values of the
+/// symbols present.
 ///
-/// Greek numbers use the Greek Alphabet to represent numbers; it is based on 10
-/// (decimal). Here we implement the single digit M power representation from
-/// [The Greek Number Converter][convert] and also described in
-/// [Greek Numbers][numbers].
-///
-/// [converter]: https://www.russellcottrell.com/greek/utilities/GreekNumberConverter.htm
-/// [numbers]: https://mathshistory.st-andrews.ac.uk/HistTopics/Greek_numbers/
-fn greek_numeral(n: usize, case: Case) -> EcoString {
-    let thousands = [
-        ["͵α", "͵Α"],
-        ["͵β", "͵Β"],
-        ["͵γ", "͵Γ"],
-        ["͵δ", "͵Δ"],
-        ["͵ε", "͵Ε"],
-        ["͵ϛ", "͵Ϛ"],
-        ["͵ζ", "͵Ζ"],
-        ["͵η", "͵Η"],
-        ["͵θ", "͵Θ"],
-    ];
-    let hundreds = [
-        ["ρ", "Ρ"],
-        ["σ", "Σ"],
-        ["τ", "Τ"],
-        ["υ", "Υ"],
-        ["φ", "Φ"],
-        ["χ", "Χ"],
-        ["ψ", "Ψ"],
-        ["ω", "Ω"],
-        ["ϡ", "Ϡ"],
-    ];
-    let tens = [
-        ["ι", "Ι"],
-        ["κ", "Κ"],
-        ["λ", "Λ"],
-        ["μ", "Μ"],
-        ["ν", "Ν"],
-        ["ξ", "Ξ"],
-        ["ο", "Ο"],
-        ["π", "Π"],
-        ["ϙ", "Ϟ"],
-    ];
-    let ones = [
-        ["α", "Α"],
-        ["β", "Β"],
-        ["γ", "Γ"],
-        ["δ", "Δ"],
-        ["ε", "Ε"],
-        ["ϛ", "Ϛ"],
-        ["ζ", "Ζ"],
-        ["η", "Η"],
-        ["θ", "Θ"],
-    ];
-
-    if n == 0 {
-        // Greek Zero Sign
-        return '𐆊'.into();
-    }
-
-    let mut fmt = EcoString::new();
-    let case = match case {
-        Case::Lower => 0,
-        Case::Upper => 1,
-    };
-
-    // Extract a list of decimal digits from the number
-    let mut decimal_digits: Vec<usize> = Vec::new();
-    let mut n = n;
-    while n > 0 {
-        decimal_digits.push(n % 10);
-        n /= 10;
-    }
-
-    // Pad the digits with leading zeros to ensure we can form groups of 4
-    while decimal_digits.len() % 4 != 0 {
-        decimal_digits.push(0);
-    }
-    decimal_digits.reverse();
-
-    let mut m_power = decimal_digits.len() / 4;
-
-    // M are used to represent 10000, M_power = 2 means 10000^2 = 10000 0000
-    // The prefix of M is also made of Greek numerals but only be single digits, so it is 9 at max. This enables us
-    // to represent up to (10000)^(9 + 1) - 1 = 10^40 -1  (9,999,999,999,999,999,999,999,999,999,999,999,999,999)
-    let get_m_prefix = |m_power: usize| {
-        if m_power == 0 {
-            None
-        } else {
-            assert!(m_power <= 9);
-            // the prefix of M is a single digit lowercase
-            Some(ones[m_power - 1][0])
-        }
-    };
-
-    let mut previous_has_number = false;
-    for chunk in decimal_digits.chunks_exact(4) {
-        // chunk must be exact 4 item
-        assert_eq!(chunk.len(), 4);
-
-        m_power = m_power.saturating_sub(1);
-
-        // `th`ousan, `h`undred, `t`en and `o`ne
-        let (th, h, t, o) = (chunk[0], chunk[1], chunk[2], chunk[3]);
-        if th + h + t + o == 0 {
-            continue;
-        }
-
-        if previous_has_number {
-            fmt.push_str(", ");
-        }
-
-        if let Some(m_prefix) = get_m_prefix(m_power) {
-            fmt.push_str(m_prefix);
-            fmt.push_str("Μ");
-        }
-        if th != 0 {
-            let thousand_digit = thousands[th - 1][case];
-            fmt.push_str(thousand_digit);
-        }
-        if h != 0 {
-            let hundred_digit = hundreds[h - 1][case];
-            fmt.push_str(hundred_digit);
-        }
-        if t != 0 {
-            let ten_digit = tens[t - 1][case];
-            fmt.push_str(ten_digit);
-        }
-        if o != 0 {
-            let one_digit = ones[o - 1][case];
-            fmt.push_str(one_digit);
-        }
-        // if we do not have thousan, we need to append 'ʹ' at the end.
-        if th == 0 {
-            fmt.push_str("ʹ");
-        }
-        previous_has_number = true;
-    }
-    fmt
-}
-
-/// Stringify a number using a base-N counting system with no zero digit.
-///
-/// This is best explained by example. Suppose our digits are 'A', 'B', and 'C'.
-/// We would get the following:
+/// Consider the situation where ['I': 1, 'IV': 4, 'V': 5],
 ///
 /// ```text
-///  1 =>   "A"
-///  2 =>   "B"
-///  3 =>   "C"
-///  4 =>  "AA"
-///  5 =>  "AB"
-///  6 =>  "AC"
-///  7 =>  "BA"
-///  8 =>  "BB"
-///  9 =>  "BC"
-/// 10 =>  "CA"
-/// 11 =>  "CB"
-/// 12 =>  "CC"
-/// 13 => "AAA"
-///    etc.
+/// 1 => 'I'
+/// 2 => 'II'
+/// 3 => 'III'
+/// 4 => 'IV'
+/// 5 => 'V'
+/// 6 => 'VI'
+/// 7 => 'VII'
+/// 8 => 'VIII'
 /// ```
 ///
-/// You might be familiar with this scheme from the way spreadsheet software
-/// tends to label its columns.
-fn zeroless<const N_DIGITS: usize>(
-    alphabet: [char; N_DIGITS],
-    mut n: usize,
-) -> EcoString {
+/// where this is the start of the familiar Roman numeral system.
+fn additive(symbols: &[(&str, u64)], mut n: u64) -> EcoString {
+    if n == 0 {
+        if let Some(&(symbol, 0)) = symbols.last() {
+            return symbol.into();
+        }
+        return '0'.into();
+    }
+
+    let mut s = EcoString::new();
+    for (symbol, weight) in symbols {
+        if *weight == 0 || *weight > n {
+            continue;
+        }
+        let reps = n / weight;
+        for _ in 0..reps {
+            s.push_str(symbol);
+        }
+
+        n -= weight * reps;
+        if n == 0 {
+            return s;
+        }
+    }
+    s
+}
+
+/// Stringify a number using a base-n (where n is the number of provided
+/// symbols) system without a zero symbol.
+///
+/// Consider the situation where ['A', 'B', 'C'] are the provided symbols,
+///
+/// ```text
+/// 1 => 'A'
+/// 2 => 'B'
+/// 3 => 'C'
+/// 4 => 'AA
+/// 5 => 'AB'
+/// 6 => 'AC'
+/// 7 => 'BA'
+/// ...
+/// ```
+///
+/// This system is commonly used in spreadsheet software.
+fn alphabetic(symbols: &[char], mut n: u64) -> EcoString {
+    let n_digits = symbols.len() as u64;
     if n == 0 {
         return '-'.into();
     }
-    let mut cs = EcoString::new();
-    while n > 0 {
+    let mut s = EcoString::new();
+    while n != 0 {
         n -= 1;
-        cs.push(alphabet[n % N_DIGITS]);
-        n /= N_DIGITS;
+        s.push(symbols[(n % n_digits) as usize]);
+        n /= n_digits;
     }
-    cs.chars().rev().collect()
+    s.chars().rev().collect()
 }
 
-/// Stringify a number using a base-10 counting system with a zero digit.
+/// Stringify a number using the symbols provided, defaulting to the arabic
+/// representation when the number is greater than the number of symbols.
 ///
-/// This function assumes that the digits occupy contiguous codepoints.
-fn decimal(start: char, mut n: usize) -> EcoString {
-    if n == 0 {
-        return start.into();
+/// Consider the situation where ['0', 'A', 'B', 'C'] are the provided symbols,
+///
+/// ```text
+/// 0 => '0'
+/// 1 => 'A'
+/// 2 => 'B'
+/// 3 => 'C'
+/// 4 => '4'
+/// ...
+/// n => 'n'
+/// ```
+fn fixed(symbols: &[char], n: u64) -> EcoString {
+    let n_digits = symbols.len() as u64;
+    if n < n_digits {
+        return symbols[(n) as usize].into();
     }
-    let mut cs = EcoString::new();
-    while n > 0 {
-        cs.push(char::from_u32((start as u32) + ((n % 10) as u32)).unwrap());
-        n /= 10;
-    }
-    cs.chars().rev().collect()
+    eco_format!("{n}")
+}
+
+/// Stringify a number using a base-n (where n is the number of provided
+/// symbols) system with a zero symbol.
+///
+/// Consider the situation where ['0', '1', '2'] are the provided symbols,
+///
+/// ```text
+/// 0 => '0'
+/// 1 => '1'
+/// 2 => '2'
+/// 3 => '10'
+/// 4 => '11'
+/// 5 => '12'
+/// 6 => '20'
+/// ...
+/// ```
+///
+/// which is the familiar trinary counting system.
+fn numeric(symbols: &[char], mut n: u64) -> EcoString {
+    let n_digits = symbols.len() as u64;
+    if n == 0 {
+        return symbols[0].into();
+    }
+    let mut s = EcoString::new();
+    while n != 0 {
+        s.push(symbols[(n % n_digits) as usize]);
+        n /= n_digits;
+    }
+    s.chars().rev().collect()
+}
+
+/// Stringify a number using repeating symbols.
+///
+/// Consider the situation where ['A', 'B', 'C'] are the provided symbols,
+///
+/// ```text
+/// 0 => '-'
+/// 1 => 'A'
+/// 2 => 'B'
+/// 3 => 'C'
+/// 4 => 'AA'
+/// 5 => 'BB'
+/// 6 => 'CC'
+/// 7 => 'AAA'
+/// ...
+/// ```
+fn symbolic(symbols: &[char], n: u64) -> EcoString {
+    let n_digits = symbols.len() as u64;
+    if n == 0 {
+        return '-'.into();
+    }
+    EcoString::from(symbols[((n - 1) % n_digits) as usize])
+        .repeat((n.div_ceil(n_digits)) as usize)
 }
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 316617688..7d44cccc0 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -21,9 +21,10 @@ use crate::text::TextElem;
 ///
 /// The default, a `{"normal"}` reference, produces a textual reference to a
 /// label. For example, a reference to a heading will yield an appropriate
-/// string such as "Section 1" for a reference to the first heading. The
-/// references are also links to the respective element. Reference syntax can
-/// also be used to [cite] from a bibliography.
+/// string such as "Section 1" for a reference to the first heading. The word
+/// "Section" depends on the [`lang`]($text.lang) setting and is localized
+/// accordingly. The references are also links to the respective element.
+/// Reference syntax can also be used to [cite] from a bibliography.
 ///
 /// As the default form requires a supplement and numbering, the label must be
 /// attached to a _referenceable element_. Referenceable elements include
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index 6f4461bd4..dcc77b0dc 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -1,4 +1,4 @@
-use std::num::NonZeroUsize;
+use std::num::{NonZeroU32, NonZeroUsize};
 use std::sync::Arc;
 
 use typst_utils::NonZeroExt;
@@ -292,16 +292,61 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
         elem(tag::tr, Content::sequence(row))
     };
 
+    // TODO(subfooters): similarly to headers, take consecutive footers from
+    // the end for 'tfoot'.
     let footer = grid.footer.map(|ft| {
-        let rows = rows.drain(ft.unwrap().start..);
+        let rows = rows.drain(ft.start..);
         elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row))))
     });
-    let header = grid.header.map(|hd| {
-        let rows = rows.drain(..hd.unwrap().end);
-        elem(tag::thead, Content::sequence(rows.map(|row| tr(tag::th, row))))
-    });
 
-    let mut body = Content::sequence(rows.into_iter().map(|row| tr(tag::td, row)));
+    // Store all consecutive headers at the start in 'thead'. All remaining
+    // headers are just 'th' rows across the table body.
+    let mut consecutive_header_end = 0;
+    let first_mid_table_header = grid
+        .headers
+        .iter()
+        .take_while(|hd| {
+            let is_consecutive = hd.range.start == consecutive_header_end;
+            consecutive_header_end = hd.range.end;
+
+            is_consecutive
+        })
+        .count();
+
+    let (y_offset, header) = if first_mid_table_header > 0 {
+        let removed_header_rows =
+            grid.headers.get(first_mid_table_header - 1).unwrap().range.end;
+        let rows = rows.drain(..removed_header_rows);
+
+        (
+            removed_header_rows,
+            Some(elem(tag::thead, Content::sequence(rows.map(|row| tr(tag::th, row))))),
+        )
+    } else {
+        (0, None)
+    };
+
+    // TODO: Consider improving accessibility properties of multi-level headers
+    // inside tables in the future, e.g. indicating which columns they are
+    // relative to and so on. See also:
+    // https://www.w3.org/WAI/tutorials/tables/multi-level/
+    let mut next_header = first_mid_table_header;
+    let mut body =
+        Content::sequence(rows.into_iter().enumerate().map(|(relative_y, row)| {
+            let y = relative_y + y_offset;
+            if let Some(current_header) =
+                grid.headers.get(next_header).filter(|h| h.range.contains(&y))
+            {
+                if y + 1 == current_header.range.end {
+                    next_header += 1;
+                }
+
+                tr(tag::th, row)
+            } else {
+                tr(tag::td, row)
+            }
+        }));
+
     if header.is_some() || footer.is_some() {
         body = elem(tag::tbody, body);
     }
@@ -492,6 +537,17 @@ pub struct TableHeader {
     #[default(true)]
     pub repeat: bool,
 
+    /// The level of the header. Must not be zero.
+    ///
+    /// This allows repeating multiple headers at once. Headers with different
+    /// levels can repeat together, as long as they have ascending levels.
+    ///
+    /// Notably, when a header with a lower level starts repeating, all higher
+    /// or equal level headers stop repeating (they are "replaced" by the new
+    /// header).
+    #[default(NonZeroU32::ONE)]
+    pub level: NonZeroU32,
+
     /// The cells and lines within the header.
     #[variadic]
     pub children: Vec<TableItem>,
@@ -770,7 +826,14 @@ impl Show for Packed<TableCell> {
 
 impl Default for Packed<TableCell> {
     fn default() -> Self {
-        Packed::new(TableCell::new(Content::default()))
+        Packed::new(
+            // Explicitly set colspan and rowspan to ensure they won't be
+            // overridden by set rules (default cells are created after
+            // colspans and rowspans are processed in the resolver)
+            TableCell::new(Content::default())
+                .with_colspan(NonZeroUsize::ONE)
+                .with_rowspan(NonZeroUsize::ONE),
+        )
     }
 }
 
diff --git a/crates/typst-library/src/model/terms.rs b/crates/typst-library/src/model/terms.rs
index e197ff318..3df74cd9e 100644
--- a/crates/typst-library/src/model/terms.rs
+++ b/crates/typst-library/src/model/terms.rs
@@ -189,13 +189,15 @@ impl Show for Packed<TermsElem> {
             .styled(TermsElem::set_within(true));
 
         if tight {
-            let leading = ParElem::leading_in(styles);
-            let spacing = VElem::new(leading.into())
+            let spacing = self
+                .spacing(styles)
+                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+            let v = VElem::new(spacing.into())
                 .with_weak(true)
                 .with_attach(true)
                 .pack()
                 .spanned(span);
-            realized = spacing + realized;
+            realized = v + realized;
         }
 
         Ok(realized)
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index b283052a4..6f0cb32b1 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -55,6 +55,7 @@ routines! {
     fn eval_string(
         routines: &Routines,
         world: Tracked<dyn World + '_>,
+        sink: TrackedMut<Sink>,
         string: &str,
         span: Span,
         mode: EvalMode,
diff --git a/crates/typst-library/src/text/deco.rs b/crates/typst-library/src/text/deco.rs
index 485d0edcf..7aa06e815 100644
--- a/crates/typst-library/src/text/deco.rs
+++ b/crates/typst-library/src/text/deco.rs
@@ -373,6 +373,7 @@ pub struct Decoration {
 
 /// A kind of decorative line.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
+#[allow(clippy::large_enum_variant)]
 pub enum DecoLine {
     Underline {
         stroke: Stroke<Abs>,
diff --git a/crates/typst-library/src/text/font/book.rs b/crates/typst-library/src/text/font/book.rs
index 9f8acce87..cd90a08fe 100644
--- a/crates/typst-library/src/text/font/book.rs
+++ b/crates/typst-library/src/text/font/book.rs
@@ -194,6 +194,8 @@ bitflags::bitflags! {
         const MONOSPACE = 1 << 0;
         /// Glyphs have short strokes at their stems.
         const SERIF = 1 << 1;
+        /// Font face has a MATH table
+        const MATH = 1 << 2;
     }
 }
 
@@ -272,6 +274,7 @@ impl FontInfo {
 
         let mut flags = FontFlags::empty();
         flags.set(FontFlags::MONOSPACE, ttf.is_monospaced());
+        flags.set(FontFlags::MATH, ttf.tables().math.is_some());
 
         // Determine whether this is a serif or sans-serif font.
         if let Some(panose) = ttf
diff --git a/crates/typst-library/src/text/font/mod.rs b/crates/typst-library/src/text/font/mod.rs
index afa92e778..0383bfe15 100644
--- a/crates/typst-library/src/text/font/mod.rs
+++ b/crates/typst-library/src/text/font/mod.rs
@@ -106,13 +106,26 @@ impl Font {
     }
 
     /// Look up the horizontal advance width of a glyph.
-    pub fn advance(&self, glyph: u16) -> Option<Em> {
+    pub fn x_advance(&self, glyph: u16) -> Option<Em> {
         self.0
             .ttf
             .glyph_hor_advance(GlyphId(glyph))
             .map(|units| self.to_em(units))
     }
 
+    /// Look up the vertical advance width of a glyph.
+    pub fn y_advance(&self, glyph: u16) -> Option<Em> {
+        self.0
+            .ttf
+            .glyph_ver_advance(GlyphId(glyph))
+            .map(|units| self.to_em(units))
+    }
+
+    /// Look up the width of a space.
+    pub fn space_width(&self) -> Option<Em> {
+        self.0.ttf.glyph_index(' ').and_then(|id| self.x_advance(id.0))
+    }
+
     /// Lookup a name by id.
     pub fn find_name(&self, id: u16) -> Option<String> {
         find_name(&self.0.ttf, id)
diff --git a/crates/typst-library/src/text/item.rs b/crates/typst-library/src/text/item.rs
index ed559aec8..518b082b9 100644
--- a/crates/typst-library/src/text/item.rs
+++ b/crates/typst-library/src/text/item.rs
@@ -35,6 +35,11 @@ impl TextItem {
     pub fn width(&self) -> Abs {
         self.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size)
     }
+
+    /// The height of the text run.
+    pub fn height(&self) -> Abs {
+        self.glyphs.iter().map(|g| g.y_advance).sum::<Em>().at(self.size)
+    }
 }
 
 impl Debug for TextItem {
@@ -54,6 +59,10 @@ pub struct Glyph {
     pub x_advance: Em,
     /// The horizontal offset of the glyph.
     pub x_offset: Em,
+    /// The advance height (Y-up) of the glyph.
+    pub y_advance: Em,
+    /// The vertical offset (Y-up) of the glyph.
+    pub y_offset: Em,
     /// The range of the glyph in its item's text. The range's length may
     /// be more than one due to multi-byte UTF-8 encoding or ligatures.
     pub range: Range<u16>,
@@ -115,4 +124,13 @@ impl<'a> TextItemView<'a> {
             .sum::<Em>()
             .at(self.item.size)
     }
+
+    /// The total height of this text slice
+    pub fn height(&self) -> Abs {
+        self.glyphs()
+            .iter()
+            .map(|g| g.y_advance)
+            .sum::<Em>()
+            .at(self.item.size)
+    }
 }
diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index c75e5225f..f9f13c783 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -14,7 +14,7 @@ macro_rules! translation {
     };
 }
 
-const TRANSLATIONS: [(&str, &str); 38] = [
+const TRANSLATIONS: [(&str, &str); 40] = [
     translation!("ar"),
     translation!("bg"),
     translation!("ca"),
@@ -31,10 +31,12 @@ const TRANSLATIONS: [(&str, &str); 38] = [
     translation!("el"),
     translation!("he"),
     translation!("hu"),
+    translation!("id"),
     translation!("is"),
     translation!("it"),
     translation!("ja"),
     translation!("la"),
+    translation!("lv"),
     translation!("nb"),
     translation!("nl"),
     translation!("nn"),
@@ -82,9 +84,11 @@ impl Lang {
     pub const HEBREW: Self = Self(*b"he ", 2);
     pub const HUNGARIAN: Self = Self(*b"hu ", 2);
     pub const ICELANDIC: Self = Self(*b"is ", 2);
+    pub const INDONESIAN: Self = Self(*b"id ", 2);
     pub const ITALIAN: Self = Self(*b"it ", 2);
     pub const JAPANESE: Self = Self(*b"ja ", 2);
     pub const LATIN: Self = Self(*b"la ", 2);
+    pub const LATVIAN: Self = Self(*b"lv ", 2);
     pub const LOWER_SORBIAN: Self = Self(*b"dsb", 3);
     pub const NYNORSK: Self = Self(*b"nn ", 2);
     pub const POLISH: Self = Self(*b"pl ", 2);
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 3aac15ba5..1c0696d1a 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -30,6 +30,7 @@ pub use self::space::*;
 
 use std::fmt::{self, Debug, Formatter};
 use std::hash::Hash;
+use std::str::FromStr;
 use std::sync::LazyLock;
 
 use ecow::{eco_format, EcoString};
@@ -42,7 +43,7 @@ use ttf_parser::Tag;
 use typst_syntax::Spanned;
 use typst_utils::singleton;
 
-use crate::diag::{bail, warning, HintedStrResult, SourceResult};
+use crate::diag::{bail, warning, HintedStrResult, SourceResult, StrResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, dict, elem, Args, Array, Cast, Construct, Content, Dict, Fold, IntoValue,
@@ -348,15 +349,17 @@ pub struct TextElem {
     /// This can make justification visually more pleasing.
     ///
     /// ```example
+    /// #set page(width: 220pt)
+    ///
     /// #set par(justify: true)
     /// This justified text has a hyphen in
-    /// the paragraph's first line. Hanging
+    /// the paragraph's second line. Hanging
     /// the hyphen slightly into the margin
     /// results in a clearer paragraph edge.
     ///
     /// #set text(overhang: false)
     /// This justified text has a hyphen in
-    /// the paragraph's first line. Hanging
+    /// the paragraph's second line. Hanging
     /// the hyphen slightly into the margin
     /// results in a clearer paragraph edge.
     /// ```
@@ -891,9 +894,21 @@ cast! {
 }
 
 /// Font family fallback list.
+///
+/// Must contain at least one font.
 #[derive(Debug, Default, Clone, PartialEq, Hash)]
 pub struct FontList(pub Vec<FontFamily>);
 
+impl FontList {
+    pub fn new(fonts: Vec<FontFamily>) -> StrResult<Self> {
+        if fonts.is_empty() {
+            bail!("font fallback list must not be empty")
+        } else {
+            Ok(Self(fonts))
+        }
+    }
+}
+
 impl<'a> IntoIterator for &'a FontList {
     type IntoIter = std::slice::Iter<'a, FontFamily>;
     type Item = &'a FontFamily;
@@ -911,7 +926,7 @@ cast! {
         self.0.into_value()
     },
     family: FontFamily => Self(vec![family]),
-    values: Array => Self(values.into_iter().map(|v| v.cast()).collect::<HintedStrResult<_>>()?),
+    values: Array => Self::new(values.into_iter().map(|v| v.cast()).collect::<HintedStrResult<_>>()?)?,
 }
 
 /// Resolve a prioritized iterator over the font families.
@@ -1269,6 +1284,12 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
         feat(b"frac", 1);
     }
 
+    match EquationElem::size_in(styles) {
+        MathSize::Script => feat(b"ssty", 1),
+        MathSize::ScriptScript => feat(b"ssty", 2),
+        _ => {}
+    }
+
     for (tag, value) in TextElem::features_in(styles).0 {
         tags.push(Feature::new(tag, value, ..))
     }
@@ -1276,6 +1297,17 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
     tags
 }
 
+/// Process the language and region of a style chain into a
+/// rustybuzz-compatible BCP 47 language.
+pub fn language(styles: StyleChain) -> rustybuzz::Language {
+    let mut bcp: EcoString = TextElem::lang_in(styles).as_str().into();
+    if let Some(region) = TextElem::region_in(styles) {
+        bcp.push('-');
+        bcp.push_str(region.as_str());
+    }
+    rustybuzz::Language::from_str(&bcp).unwrap()
+}
+
 /// A toggle that turns on and off alternatingly if folded.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct ItalicToggle(pub bool);
diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index d5c07424d..f2485e16b 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -3,15 +3,17 @@ use std::ops::Range;
 use std::sync::{Arc, LazyLock};
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString, EcoVec};
-use syntect::highlighting as synt;
-use syntect::parsing::{SyntaxDefinition, SyntaxSet, SyntaxSetBuilder};
+use ecow::{EcoString, EcoVec};
+use syntect::highlighting::{self as synt};
+use syntect::parsing::{ParseSyntaxError, SyntaxDefinition, SyntaxSet, SyntaxSetBuilder};
 use typst_syntax::{split_newlines, LinkedNode, Span, Spanned};
 use typst_utils::ManuallyHash;
 use unicode_segmentation::UnicodeSegmentation;
 
 use super::Lang;
-use crate::diag::{At, FileError, SourceResult, StrResult};
+use crate::diag::{
+    LineCol, LoadError, LoadResult, LoadedWithin, ReportPos, SourceResult,
+};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Bytes, Content, Derived, NativeElement, OneOrMultiple, Packed,
@@ -539,40 +541,29 @@ impl RawSyntax {
         world: Tracked<dyn World + '_>,
         sources: Spanned<OneOrMultiple<DataSource>>,
     ) -> SourceResult<Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>> {
-        let data = sources.load(world)?;
-        let list = sources
-            .v
-            .0
+        let loaded = sources.load(world)?;
+        let list = loaded
             .iter()
-            .zip(&data)
-            .map(|(source, data)| Self::decode(source, data))
-            .collect::<StrResult<_>>()
-            .at(sources.span)?;
+            .map(|data| Self::decode(&data.data).within(data))
+            .collect::<SourceResult<_>>()?;
         Ok(Derived::new(sources.v, list))
     }
 
     /// Decode a syntax from a loaded source.
     #[comemo::memoize]
     #[typst_macros::time(name = "load syntaxes")]
-    fn decode(source: &DataSource, data: &Bytes) -> StrResult<RawSyntax> {
-        let src = data.as_str().map_err(FileError::from)?;
-        let syntax = SyntaxDefinition::load_from_str(src, false, None).map_err(
-            |err| match source {
-                DataSource::Path(path) => {
-                    eco_format!("failed to parse syntax file `{path}` ({err})")
-                }
-                DataSource::Bytes(_) => {
-                    eco_format!("failed to parse syntax ({err})")
-                }
-            },
-        )?;
+    fn decode(bytes: &Bytes) -> LoadResult<RawSyntax> {
+        let str = bytes.as_str()?;
+
+        let syntax = SyntaxDefinition::load_from_str(str, false, None)
+            .map_err(format_syntax_error)?;
 
         let mut builder = SyntaxSetBuilder::new();
         builder.add(syntax);
 
         Ok(RawSyntax(Arc::new(ManuallyHash::new(
             builder.build(),
-            typst_utils::hash128(data),
+            typst_utils::hash128(bytes),
         ))))
     }
 
@@ -582,6 +573,24 @@ impl RawSyntax {
     }
 }
 
+fn format_syntax_error(error: ParseSyntaxError) -> LoadError {
+    let pos = syntax_error_pos(&error);
+    LoadError::new(pos, "failed to parse syntax", error)
+}
+
+fn syntax_error_pos(error: &ParseSyntaxError) -> ReportPos {
+    match error {
+        ParseSyntaxError::InvalidYaml(scan_error) => {
+            let m = scan_error.marker();
+            ReportPos::full(
+                m.index()..m.index(),
+                LineCol::one_based(m.line(), m.col() + 1),
+            )
+        }
+        _ => ReportPos::None,
+    }
+}
+
 /// A loaded syntect theme.
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub struct RawTheme(Arc<ManuallyHash<synt::Theme>>);
@@ -592,18 +601,18 @@ impl RawTheme {
         world: Tracked<dyn World + '_>,
         source: Spanned<DataSource>,
     ) -> SourceResult<Derived<DataSource, Self>> {
-        let data = source.load(world)?;
-        let theme = Self::decode(&data).at(source.span)?;
+        let loaded = source.load(world)?;
+        let theme = Self::decode(&loaded.data).within(&loaded)?;
         Ok(Derived::new(source.v, theme))
     }
 
     /// Decode a theme from bytes.
     #[comemo::memoize]
-    fn decode(data: &Bytes) -> StrResult<RawTheme> {
-        let mut cursor = std::io::Cursor::new(data.as_slice());
-        let theme = synt::ThemeSet::load_from_reader(&mut cursor)
-            .map_err(|err| eco_format!("failed to parse theme ({err})"))?;
-        Ok(RawTheme(Arc::new(ManuallyHash::new(theme, typst_utils::hash128(data)))))
+    fn decode(bytes: &Bytes) -> LoadResult<RawTheme> {
+        let mut cursor = std::io::Cursor::new(bytes.as_slice());
+        let theme =
+            synt::ThemeSet::load_from_reader(&mut cursor).map_err(format_theme_error)?;
+        Ok(RawTheme(Arc::new(ManuallyHash::new(theme, typst_utils::hash128(bytes)))))
     }
 
     /// Get the underlying syntect theme.
@@ -612,6 +621,14 @@ impl RawTheme {
     }
 }
 
+fn format_theme_error(error: syntect::LoadingError) -> LoadError {
+    let pos = match &error {
+        syntect::LoadingError::ParseSyntax(err, _) => syntax_error_pos(err),
+        _ => ReportPos::None,
+    };
+    LoadError::new(pos, "failed to parse theme", error)
+}
+
 /// A highlighted line of raw text.
 ///
 /// This is a helper element that is synthesized by [`raw`] elements.
diff --git a/crates/typst-library/src/text/smartquote.rs b/crates/typst-library/src/text/smartquote.rs
index f457a6371..09cefd013 100644
--- a/crates/typst-library/src/text/smartquote.rs
+++ b/crates/typst-library/src/text/smartquote.rs
@@ -237,8 +237,8 @@ impl<'s> SmartQuotes<'s> {
             "cs" | "da" | "de" | "sk" | "sl" if alternative => ("›", "‹", "»", "«"),
             "cs" | "de" | "et" | "is" | "lt" | "lv" | "sk" | "sl" => low_high,
             "da" => ("‘", "’", "“", "”"),
-            "fr" | "ru" if alternative => default,
-            "fr" => ("‹\u{00A0}", "\u{00A0}›", "«\u{00A0}", "\u{00A0}»"),
+            "fr" if alternative => default,
+            "fr" => ("“", "”", "«\u{202F}", "\u{202F}»"),
             "fi" | "sv" if alternative => ("’", "’", "»", "»"),
             "bs" | "fi" | "sv" => ("’", "’", "”", "”"),
             "it" if alternative => default,
@@ -247,7 +247,9 @@ impl<'s> SmartQuotes<'s> {
             "es" if matches!(region, Some("ES") | None) => ("“", "”", "«", "»"),
             "hu" | "pl" | "ro" => ("’", "’", "„", "”"),
             "no" | "nb" | "nn" if alternative => low_high,
-            "ru" | "no" | "nb" | "nn" | "uk" => ("’", "’", "«", "»"),
+            "no" | "nb" | "nn" => ("’", "’", "«", "»"),
+            "ru" => ("„", "“", "«", "»"),
+            "uk" => ("“", "”", "«", "»"),
             "el" => ("‘", "’", "«", "»"),
             "he" => ("’", "’", "”", "”"),
             "hr" => ("‘", "’", "„", "”"),
diff --git a/crates/typst-library/src/visualize/color.rs b/crates/typst-library/src/visualize/color.rs
index 20b0f5719..24d8305cd 100644
--- a/crates/typst-library/src/visualize/color.rs
+++ b/crates/typst-library/src/visualize/color.rs
@@ -148,11 +148,11 @@ static TO_SRGB: LazyLock<qcms::Transform> = LazyLock::new(|| {
 /// | `magma`    | A black to purple to yellow color map.                      |
 /// | `plasma`   | A purple to pink to yellow color map.                       |
 /// | `rocket`   | A black to red to white color map.                          |
-/// | `mako`     | A black to teal to yellow color map.                        |
+/// | `mako`     | A black to teal to white color map.                         |
 /// | `vlag`     | A light blue to white to red color map.                     |
-/// | `icefire`  | A light teal to black to yellow color map.                  |
+/// | `icefire`  | A light teal to black to orange color map.                  |
 /// | `flare`    | A orange to purple color map that is perceptually uniform.  |
-/// | `crest`    | A blue to white to red color map.                           |
+/// | `crest`    | A light green to blue color map.                            |
 ///
 /// Some popular presets are not included because they are not available under a
 /// free licence. Others, like
diff --git a/crates/typst-library/src/visualize/curve.rs b/crates/typst-library/src/visualize/curve.rs
index fb5151e8f..50944a516 100644
--- a/crates/typst-library/src/visualize/curve.rs
+++ b/crates/typst-library/src/visualize/curve.rs
@@ -10,6 +10,8 @@ use crate::foundations::{
 use crate::layout::{Abs, Axes, BlockElem, Length, Point, Rel, Size};
 use crate::visualize::{FillRule, Paint, Stroke};
 
+use super::FixedStroke;
+
 /// A curve consisting of movements, lines, and Bézier segments.
 ///
 /// At any point in time, there is a conceptual pen or cursor.
@@ -530,3 +532,65 @@ impl Curve {
         Size::new(max_x - min_x, max_y - min_y)
     }
 }
+
+impl Curve {
+    fn to_kurbo(&self) -> impl Iterator<Item = kurbo::PathEl> + '_ {
+        use kurbo::PathEl;
+
+        self.0.iter().map(|item| match *item {
+            CurveItem::Move(point) => PathEl::MoveTo(point_to_kurbo(point)),
+            CurveItem::Line(point) => PathEl::LineTo(point_to_kurbo(point)),
+            CurveItem::Cubic(point, point1, point2) => PathEl::CurveTo(
+                point_to_kurbo(point),
+                point_to_kurbo(point1),
+                point_to_kurbo(point2),
+            ),
+            CurveItem::Close => PathEl::ClosePath,
+        })
+    }
+
+    /// When this curve is interpreted as a clip mask, would it contain `point`?
+    pub fn contains(&self, fill_rule: FillRule, needle: Point) -> bool {
+        let kurbo = kurbo::BezPath::from_vec(self.to_kurbo().collect());
+        let windings = kurbo::Shape::winding(&kurbo, point_to_kurbo(needle));
+        match fill_rule {
+            FillRule::NonZero => windings != 0,
+            FillRule::EvenOdd => windings % 2 != 0,
+        }
+    }
+
+    /// When this curve is stroked with `stroke`, would the stroke contain
+    /// `point`?
+    pub fn stroke_contains(&self, stroke: &FixedStroke, needle: Point) -> bool {
+        let width = stroke.thickness.to_raw();
+        let cap = match stroke.cap {
+            super::LineCap::Butt => kurbo::Cap::Butt,
+            super::LineCap::Round => kurbo::Cap::Round,
+            super::LineCap::Square => kurbo::Cap::Square,
+        };
+        let join = match stroke.join {
+            super::LineJoin::Miter => kurbo::Join::Miter,
+            super::LineJoin::Round => kurbo::Join::Round,
+            super::LineJoin::Bevel => kurbo::Join::Bevel,
+        };
+        let miter_limit = stroke.miter_limit.get();
+        let mut style = kurbo::Stroke::new(width)
+            .with_caps(cap)
+            .with_join(join)
+            .with_miter_limit(miter_limit);
+        if let Some(dash) = &stroke.dash {
+            style = style.with_dashes(
+                dash.phase.to_raw(),
+                dash.array.iter().copied().map(Abs::to_raw),
+            );
+        }
+        let opts = kurbo::StrokeOpts::default();
+        let tolerance = 0.01;
+        let expanded = kurbo::stroke(self.to_kurbo(), &style, &opts, tolerance);
+        kurbo::Shape::contains(&expanded, point_to_kurbo(needle))
+    }
+}
+
+fn point_to_kurbo(point: Point) -> kurbo::Point {
+    kurbo::Point::new(point.x.to_raw(), point.y.to_raw())
+}
diff --git a/crates/typst-library/src/visualize/gradient.rs b/crates/typst-library/src/visualize/gradient.rs
index d59175a4e..5d7859a37 100644
--- a/crates/typst-library/src/visualize/gradient.rs
+++ b/crates/typst-library/src/visualize/gradient.rs
@@ -120,12 +120,12 @@ use crate::visualize::{Color, ColorSpace, WeightedColor};
 /// #let spaces = (
 ///   ("Oklab", color.oklab),
 ///   ("Oklch", color.oklch),
-///   ("linear-RGB", color.linear-rgb),
 ///   ("sRGB", color.rgb),
+///   ("linear-RGB", color.linear-rgb),
 ///   ("CMYK", color.cmyk),
+///   ("Grayscale", color.luma),
 ///   ("HSL", color.hsl),
 ///   ("HSV", color.hsv),
-///   ("Grayscale", color.luma),
 /// )
 ///
 /// #for (name, space) in spaces {
@@ -549,7 +549,7 @@ impl Gradient {
     }
 
     /// Repeats this gradient a given number of times, optionally mirroring it
-    /// at each repetition.
+    /// at every second repetition.
     ///
     /// ```example
     /// #circle(
@@ -564,7 +564,17 @@ impl Gradient {
         &self,
         /// The number of times to repeat the gradient.
         repetitions: Spanned<usize>,
-        /// Whether to mirror the gradient at each repetition.
+        /// Whether to mirror the gradient at every second repetition, i.e.,
+        /// the first instance (and all odd ones) stays unchanged.
+        ///
+        /// ```example
+        /// #circle(
+        ///   radius: 40pt,
+        ///   fill: gradient
+        ///     .conic(green, black)
+        ///     .repeat(2, mirror: true)
+        /// )
+        /// ```
         #[named]
         #[default(false)]
         mirror: bool,
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index 258eb96f3..f5109798b 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -22,7 +22,7 @@ use crate::foundations::{
     Smart, StyleChain,
 };
 use crate::layout::{BlockElem, Length, Rel, Sizing};
-use crate::loading::{DataSource, Load, Readable};
+use crate::loading::{DataSource, Load, LoadSource, Loaded, Readable};
 use crate::model::Figurable;
 use crate::text::LocalName;
 
@@ -65,10 +65,10 @@ pub struct ImageElem {
     #[required]
     #[parse(
         let source = args.expect::<Spanned<DataSource>>("source")?;
-        let data = source.load(engine.world)?;
-        Derived::new(source.v, data)
+        let loaded = source.load(engine.world)?;
+        Derived::new(source.v, loaded)
     )]
-    pub source: Derived<DataSource, Bytes>,
+    pub source: Derived<DataSource, Loaded>,
 
     /// The image's format.
     ///
@@ -77,8 +77,8 @@ pub struct ImageElem {
     /// [`source`]($image.source) (even then, Typst will try to figure out the
     /// format automatically, but that's not always possible).
     ///
-    /// Supported formats are `{"png"}`, `{"jpg"}`, `{"gif"}`, `{"svg"}` as well
-    /// as raw pixel data. Embedding PDFs as images is
+    /// Supported formats are `{"png"}`, `{"jpg"}`, `{"gif"}`, `{"svg"}`,
+    /// `{"webp"}` as well as raw pixel data. Embedding PDFs as images is
     /// [not currently supported](https://github.com/typst/typst/issues/145).
     ///
     /// When providing raw pixel data as the `source`, you must specify a
@@ -154,8 +154,8 @@ pub struct ImageElem {
     /// to `{auto}`, Typst will try to extract an ICC profile from the image.
     #[parse(match args.named::<Spanned<Smart<DataSource>>>("icc")? {
         Some(Spanned { v: Smart::Custom(source), span }) => Some(Smart::Custom({
-            let data = Spanned::new(&source, span).load(engine.world)?;
-            Derived::new(source, data)
+            let loaded = Spanned::new(&source, span).load(engine.world)?;
+            Derived::new(source, loaded.data)
         })),
         Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
         None => None,
@@ -173,7 +173,7 @@ impl ImageElem {
     pub fn decode(
         span: Span,
         /// The data to decode as an image. Can be a string for SVGs.
-        data: Readable,
+        data: Spanned<Readable>,
         /// The image's format. Detected automatically by default.
         #[named]
         format: Option<Smart<ImageFormat>>,
@@ -193,8 +193,10 @@ impl ImageElem {
         #[named]
         scaling: Option<Smart<ImageScaling>>,
     ) -> StrResult<Content> {
-        let bytes = data.into_bytes();
-        let source = Derived::new(DataSource::Bytes(bytes.clone()), bytes);
+        let bytes = data.v.into_bytes();
+        let loaded =
+            Loaded::new(Spanned::new(LoadSource::Bytes, data.span), bytes.clone());
+        let source = Derived::new(DataSource::Bytes(bytes), loaded);
         let mut elem = ImageElem::new(source);
         if let Some(format) = format {
             elem.push_format(format);
diff --git a/crates/typst-library/src/visualize/image/raster.rs b/crates/typst-library/src/visualize/image/raster.rs
index 0883fe71d..54f832bae 100644
--- a/crates/typst-library/src/visualize/image/raster.rs
+++ b/crates/typst-library/src/visualize/image/raster.rs
@@ -3,17 +3,17 @@ use std::hash::{Hash, Hasher};
 use std::io;
 use std::sync::Arc;
 
+use crate::diag::{bail, StrResult};
+use crate::foundations::{cast, dict, Bytes, Cast, Dict, Smart, Value};
 use ecow::{eco_format, EcoString};
 use image::codecs::gif::GifDecoder;
 use image::codecs::jpeg::JpegDecoder;
 use image::codecs::png::PngDecoder;
+use image::codecs::webp::WebPDecoder;
 use image::{
     guess_format, DynamicImage, ImageBuffer, ImageDecoder, ImageResult, Limits, Pixel,
 };
 
-use crate::diag::{bail, StrResult};
-use crate::foundations::{cast, dict, Bytes, Cast, Dict, Smart, Value};
-
 /// A decoded raster image.
 #[derive(Clone, Hash)]
 pub struct RasterImage(Arc<Repr>);
@@ -22,7 +22,8 @@ pub struct RasterImage(Arc<Repr>);
 struct Repr {
     data: Bytes,
     format: RasterFormat,
-    dynamic: image::DynamicImage,
+    dynamic: Arc<DynamicImage>,
+    exif_rotation: Option<u32>,
     icc: Option<Bytes>,
     dpi: Option<f64>,
 }
@@ -50,6 +51,8 @@ impl RasterImage {
         format: RasterFormat,
         icc: Smart<Bytes>,
     ) -> StrResult<RasterImage> {
+        let mut exif_rot = None;
+
         let (dynamic, icc, dpi) = match format {
             RasterFormat::Exchange(format) => {
                 fn decode<T: ImageDecoder>(
@@ -75,6 +78,7 @@ impl RasterImage {
                     ExchangeFormat::Jpg => decode(JpegDecoder::new(cursor), icc),
                     ExchangeFormat::Png => decode(PngDecoder::new(cursor), icc),
                     ExchangeFormat::Gif => decode(GifDecoder::new(cursor), icc),
+                    ExchangeFormat::Webp => decode(WebPDecoder::new(cursor), icc),
                 }
                 .map_err(format_image_error)?;
 
@@ -85,6 +89,7 @@ impl RasterImage {
                 // Apply rotation from EXIF metadata.
                 if let Some(rotation) = exif.as_ref().and_then(exif_rotation) {
                     apply_rotation(&mut dynamic, rotation);
+                    exif_rot = Some(rotation);
                 }
 
                 // Extract pixel density.
@@ -136,7 +141,14 @@ impl RasterImage {
             }
         };
 
-        Ok(Self(Arc::new(Repr { data, format, dynamic, icc, dpi })))
+        Ok(Self(Arc::new(Repr {
+            data,
+            format,
+            exif_rotation: exif_rot,
+            dynamic: Arc::new(dynamic),
+            icc,
+            dpi,
+        })))
     }
 
     /// The raw image data.
@@ -159,6 +171,11 @@ impl RasterImage {
         self.dynamic().height()
     }
 
+    /// TODO.
+    pub fn exif_rotation(&self) -> Option<u32> {
+        self.0.exif_rotation
+    }
+
     /// The image's pixel density in pixels per inch, if known.
     ///
     /// This is guaranteed to be positive.
@@ -167,7 +184,7 @@ impl RasterImage {
     }
 
     /// Access the underlying dynamic image.
-    pub fn dynamic(&self) -> &image::DynamicImage {
+    pub fn dynamic(&self) -> &Arc<DynamicImage> {
         &self.0.dynamic
     }
 
@@ -227,6 +244,8 @@ pub enum ExchangeFormat {
     /// Raster format that is typically used for short animated clips. Typst can
     /// load GIFs, but they will become static.
     Gif,
+    /// Raster format that supports both lossy and lossless compression.
+    Webp,
 }
 
 impl ExchangeFormat {
@@ -242,6 +261,7 @@ impl From<ExchangeFormat> for image::ImageFormat {
             ExchangeFormat::Png => image::ImageFormat::Png,
             ExchangeFormat::Jpg => image::ImageFormat::Jpeg,
             ExchangeFormat::Gif => image::ImageFormat::Gif,
+            ExchangeFormat::Webp => image::ImageFormat::WebP,
         }
     }
 }
@@ -254,6 +274,7 @@ impl TryFrom<image::ImageFormat> for ExchangeFormat {
             image::ImageFormat::Png => ExchangeFormat::Png,
             image::ImageFormat::Jpeg => ExchangeFormat::Jpg,
             image::ImageFormat::Gif => ExchangeFormat::Gif,
+            image::ImageFormat::WebP => ExchangeFormat::Webp,
             _ => bail!("format not yet supported"),
         })
     }
@@ -325,12 +346,12 @@ fn apply_rotation(image: &mut DynamicImage, rotation: u32) {
             ops::flip_horizontal_in_place(image);
             *image = image.rotate270();
         }
-        6 => *image = image.rotate90(),
+        6 => *image = image.rotate270(),
         7 => {
             ops::flip_horizontal_in_place(image);
             *image = image.rotate90();
         }
-        8 => *image = image.rotate270(),
+        8 => *image = image.rotate90(),
         _ => {}
     }
 }
diff --git a/crates/typst-library/src/visualize/image/svg.rs b/crates/typst-library/src/visualize/image/svg.rs
index 9bf1ead0d..1a3f6d474 100644
--- a/crates/typst-library/src/visualize/image/svg.rs
+++ b/crates/typst-library/src/visualize/image/svg.rs
@@ -3,10 +3,9 @@ use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Mutex};
 
 use comemo::Tracked;
-use ecow::EcoString;
 use siphasher::sip128::{Hasher128, SipHasher13};
 
-use crate::diag::{format_xml_like_error, StrResult};
+use crate::diag::{format_xml_like_error, LoadError, LoadResult, ReportPos};
 use crate::foundations::Bytes;
 use crate::layout::Axes;
 use crate::text::{
@@ -30,7 +29,7 @@ impl SvgImage {
     /// Decode an SVG image without fonts.
     #[comemo::memoize]
     #[typst_macros::time(name = "load svg")]
-    pub fn new(data: Bytes) -> StrResult<SvgImage> {
+    pub fn new(data: Bytes) -> LoadResult<SvgImage> {
         let tree =
             usvg::Tree::from_data(&data, &base_options()).map_err(format_usvg_error)?;
         Ok(Self(Arc::new(Repr { data, size: tree_size(&tree), font_hash: 0, tree })))
@@ -43,7 +42,7 @@ impl SvgImage {
         data: Bytes,
         world: Tracked<dyn World + '_>,
         families: &[&str],
-    ) -> StrResult<SvgImage> {
+    ) -> LoadResult<SvgImage> {
         let book = world.book();
         let resolver = Mutex::new(FontResolver::new(world, book, families));
         let tree = usvg::Tree::from_data(
@@ -125,16 +124,15 @@ fn tree_size(tree: &usvg::Tree) -> Axes<f64> {
 }
 
 /// Format the user-facing SVG decoding error message.
-fn format_usvg_error(error: usvg::Error) -> EcoString {
-    match error {
-        usvg::Error::NotAnUtf8Str => "file is not valid utf-8".into(),
-        usvg::Error::MalformedGZip => "file is not compressed correctly".into(),
-        usvg::Error::ElementsLimitReached => "file is too large".into(),
-        usvg::Error::InvalidSize => {
-            "failed to parse SVG (width, height, or viewbox is invalid)".into()
-        }
-        usvg::Error::ParsingFailed(error) => format_xml_like_error("SVG", error),
-    }
+fn format_usvg_error(error: usvg::Error) -> LoadError {
+    let error = match error {
+        usvg::Error::NotAnUtf8Str => "file is not valid utf-8",
+        usvg::Error::MalformedGZip => "file is not compressed correctly",
+        usvg::Error::ElementsLimitReached => "file is too large",
+        usvg::Error::InvalidSize => "width, height, or viewbox is invalid",
+        usvg::Error::ParsingFailed(error) => return format_xml_like_error("SVG", error),
+    };
+    LoadError::new(ReportPos::None, "failed to parse SVG", error)
 }
 
 /// Provides Typst's fonts to usvg.
diff --git a/crates/typst-library/src/visualize/shape.rs b/crates/typst-library/src/visualize/shape.rs
index 439b4cd98..ff05be2be 100644
--- a/crates/typst-library/src/visualize/shape.rs
+++ b/crates/typst-library/src/visualize/shape.rs
@@ -106,7 +106,7 @@ pub struct RectElem {
     pub radius: Corners<Option<Rel<Length>>>,
 
     /// How much to pad the rectangle's content.
-    /// See the [box's documentation]($box.outset) for more details.
+    /// See the [box's documentation]($box.inset) for more details.
     #[resolve]
     #[fold]
     #[default(Sides::splat(Some(Abs::pt(5.0).into())))]
diff --git a/crates/typst-library/translations/cs.txt b/crates/typst-library/translations/cs.txt
index d4688ffee..e21ca3520 100644
--- a/crates/typst-library/translations/cs.txt
+++ b/crates/typst-library/translations/cs.txt
@@ -4,5 +4,5 @@ equation = Rovnice
 bibliography = Bibliografie
 heading = Kapitola
 outline = Obsah
-raw = Seznam
+raw = Výpis
 page = strana
\ No newline at end of file
diff --git a/crates/typst-library/translations/id.txt b/crates/typst-library/translations/id.txt
new file mode 100644
index 000000000..bea5ee18c
--- /dev/null
+++ b/crates/typst-library/translations/id.txt
@@ -0,0 +1,8 @@
+figure = Gambar
+table = Tabel
+equation = Persamaan
+bibliography = Daftar Pustaka
+heading = Bagian
+outline = Daftar Isi
+raw = Kode
+page = halaman
diff --git a/crates/typst-library/translations/lv.txt b/crates/typst-library/translations/lv.txt
new file mode 100644
index 000000000..4c6b86841
--- /dev/null
+++ b/crates/typst-library/translations/lv.txt
@@ -0,0 +1,8 @@
+figure = Attēls
+table = Tabula
+equation = Vienādojums
+bibliography = Literatūra
+heading = Sadaļa
+outline = Saturs
+raw = Saraksts
+page = lpp.
diff --git a/crates/typst-macros/src/cast.rs b/crates/typst-macros/src/cast.rs
index b90b78886..6f4b2b95c 100644
--- a/crates/typst-macros/src/cast.rs
+++ b/crates/typst-macros/src/cast.rs
@@ -185,6 +185,7 @@ struct Cast {
 }
 
 /// A pattern in a cast, e.g.`"ascender"` or `v: i64`.
+#[allow(clippy::large_enum_variant)]
 enum Pattern {
     Str(syn::LitStr),
     Ty(syn::Pat, syn::Type),
diff --git a/crates/typst-pdf/Cargo.toml b/crates/typst-pdf/Cargo.toml
index bc0da06c3..5745d0530 100644
--- a/crates/typst-pdf/Cargo.toml
+++ b/crates/typst-pdf/Cargo.toml
@@ -19,20 +19,14 @@ typst-macros = { workspace = true }
 typst-syntax = { workspace = true }
 typst-timing = { workspace = true }
 typst-utils = { workspace = true }
-arrayvec = { workspace = true }
-base64 = { workspace = true }
 bytemuck = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
 image = { workspace = true }
-indexmap = { workspace = true }
-miniz_oxide = { workspace = true }
-pdf-writer = { workspace = true }
+infer = { workspace = true }
+krilla = { workspace = true }
+krilla-svg = { workspace = true }
 serde = { workspace = true }
-subsetter = { workspace = true }
-svg2pdf = { workspace = true }
-ttf-parser = { workspace = true }
-xmp-writer = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/typst-pdf/src/catalog.rs b/crates/typst-pdf/src/catalog.rs
deleted file mode 100644
index 709b01553..000000000
--- a/crates/typst-pdf/src/catalog.rs
+++ /dev/null
@@ -1,385 +0,0 @@
-use std::num::NonZeroUsize;
-
-use ecow::eco_format;
-use pdf_writer::types::Direction;
-use pdf_writer::writers::PageLabel;
-use pdf_writer::{Finish, Name, Pdf, Ref, Str, TextStr};
-use typst_library::diag::{bail, SourceResult};
-use typst_library::foundations::{Datetime, Smart};
-use typst_library::layout::Dir;
-use typst_library::text::Lang;
-use typst_syntax::Span;
-use xmp_writer::{DateTime, LangId, RenditionClass, XmpWriter};
-
-use crate::page::PdfPageLabel;
-use crate::{hash_base64, outline, TextStrExt, Timestamp, Timezone, WithEverything};
-
-/// Write the document catalog.
-pub fn write_catalog(
-    ctx: WithEverything,
-    pdf: &mut Pdf,
-    alloc: &mut Ref,
-) -> SourceResult<()> {
-    let lang = ctx
-        .resources
-        .languages
-        .iter()
-        .max_by_key(|(_, &count)| count)
-        .map(|(&l, _)| l);
-
-    let dir = if lang.map(Lang::dir) == Some(Dir::RTL) {
-        Direction::R2L
-    } else {
-        Direction::L2R
-    };
-
-    // Write the outline tree.
-    let outline_root_id = outline::write_outline(pdf, alloc, &ctx);
-
-    // Write the page labels.
-    let page_labels = write_page_labels(pdf, alloc, &ctx);
-
-    // Write the document information.
-    let info_ref = alloc.bump();
-    let mut info = pdf.document_info(info_ref);
-    let mut xmp = XmpWriter::new();
-    if let Some(title) = &ctx.document.info.title {
-        info.title(TextStr::trimmed(title));
-        xmp.title([(None, title.as_str())]);
-    }
-
-    if let Some(description) = &ctx.document.info.description {
-        info.subject(TextStr::trimmed(description));
-        xmp.description([(None, description.as_str())]);
-    }
-
-    let authors = &ctx.document.info.author;
-    if !authors.is_empty() {
-        // Turns out that if the authors are given in both the document
-        // information dictionary and the XMP metadata, Acrobat takes a little
-        // bit of both: The first author from the document information
-        // dictionary and the remaining authors from the XMP metadata.
-        //
-        // To fix this for Acrobat, we could omit the remaining authors or all
-        // metadata from the document information catalog (it is optional) and
-        // only write XMP. However, not all other tools (including Apple
-        // Preview) read the XMP data. This means we do want to include all
-        // authors in the document information dictionary.
-        //
-        // Thus, the only alternative is to fold all authors into a single
-        // `<rdf:li>` in the XMP metadata. This is, in fact, exactly what the
-        // PDF/A spec Part 1 section 6.7.3 has to say about the matter. It's a
-        // bit weird to not use the array (and it makes Acrobat show the author
-        // list in quotes), but there's not much we can do about that.
-        let joined = authors.join(", ");
-        info.author(TextStr::trimmed(&joined));
-        xmp.creator([joined.as_str()]);
-    }
-
-    let creator = eco_format!("Typst {}", env!("CARGO_PKG_VERSION"));
-    info.creator(TextStr(&creator));
-    xmp.creator_tool(&creator);
-
-    let keywords = &ctx.document.info.keywords;
-    if !keywords.is_empty() {
-        let joined = keywords.join(", ");
-        info.keywords(TextStr::trimmed(&joined));
-        xmp.pdf_keywords(&joined);
-    }
-    let (date, tz) = document_date(ctx.document.info.date, ctx.options.timestamp);
-    if let Some(pdf_date) = date.and_then(|date| pdf_date(date, tz)) {
-        info.creation_date(pdf_date);
-        info.modified_date(pdf_date);
-    }
-
-    info.finish();
-
-    // A unique ID for this instance of the document. Changes if anything
-    // changes in the frames.
-    let instance_id = hash_base64(&pdf.as_bytes());
-
-    // Determine the document's ID. It should be as stable as possible.
-    const PDF_VERSION: &str = "PDF-1.7";
-    let doc_id = if let Smart::Custom(ident) = ctx.options.ident {
-        // We were provided with a stable ID. Yay!
-        hash_base64(&(PDF_VERSION, ident))
-    } else if ctx.document.info.title.is_some() && !ctx.document.info.author.is_empty() {
-        // If not provided from the outside, but title and author were given, we
-        // compute a hash of them, which should be reasonably stable and unique.
-        hash_base64(&(PDF_VERSION, &ctx.document.info.title, &ctx.document.info.author))
-    } else {
-        // The user provided no usable metadata which we can use as an `/ID`.
-        instance_id.clone()
-    };
-
-    xmp.document_id(&doc_id);
-    xmp.instance_id(&instance_id);
-    xmp.format("application/pdf");
-    xmp.pdf_version("1.7");
-    xmp.language(ctx.resources.languages.keys().map(|lang| LangId(lang.as_str())));
-    xmp.num_pages(ctx.document.pages.len() as u32);
-    xmp.rendition_class(RenditionClass::Proof);
-
-    if let Some(xmp_date) = date.and_then(|date| xmp_date(date, tz)) {
-        xmp.create_date(xmp_date);
-        xmp.modify_date(xmp_date);
-
-        if ctx.options.standards.pdfa {
-            let mut history = xmp.history();
-            history
-                .add_event()
-                .action(xmp_writer::ResourceEventAction::Saved)
-                .when(xmp_date)
-                .instance_id(&eco_format!("{instance_id}_source"));
-            history
-                .add_event()
-                .action(xmp_writer::ResourceEventAction::Converted)
-                .when(xmp_date)
-                .instance_id(&instance_id)
-                .software_agent(&creator);
-        }
-    }
-
-    // Assert dominance.
-    if let Some((part, conformance)) = ctx.options.standards.pdfa_part {
-        let mut extension_schemas = xmp.extension_schemas();
-        extension_schemas
-            .xmp_media_management()
-            .properties()
-            .describe_instance_id();
-        extension_schemas.pdf().properties().describe_all();
-        extension_schemas.finish();
-        xmp.pdfa_part(part);
-        xmp.pdfa_conformance(conformance);
-    }
-
-    let xmp_buf = xmp.finish(None);
-    let meta_ref = alloc.bump();
-    pdf.stream(meta_ref, xmp_buf.as_bytes())
-        .pair(Name(b"Type"), Name(b"Metadata"))
-        .pair(Name(b"Subtype"), Name(b"XML"));
-
-    // Set IDs only now, so that we don't need to clone them.
-    pdf.set_file_id((doc_id.into_bytes(), instance_id.into_bytes()));
-
-    // Write the document catalog.
-    let catalog_ref = alloc.bump();
-    let mut catalog = pdf.catalog(catalog_ref);
-    catalog.pages(ctx.page_tree_ref);
-    catalog.viewer_preferences().direction(dir);
-    catalog.metadata(meta_ref);
-
-    let has_dests = !ctx.references.named_destinations.dests.is_empty();
-    let has_embeddings = !ctx.references.embedded_files.is_empty();
-
-    // Write the `/Names` dictionary.
-    if has_dests || has_embeddings {
-        // Write the named destination tree if there are any entries.
-        let mut name_dict = catalog.names();
-        if has_dests {
-            let mut dests_name_tree = name_dict.destinations();
-            let mut names = dests_name_tree.names();
-            for &(name, dest_ref, ..) in &ctx.references.named_destinations.dests {
-                names.insert(Str(name.resolve().as_bytes()), dest_ref);
-            }
-        }
-
-        if has_embeddings {
-            let mut embedded_files = name_dict.embedded_files();
-            let mut names = embedded_files.names();
-            for (name, file_ref) in &ctx.references.embedded_files {
-                names.insert(Str(name.as_bytes()), *file_ref);
-            }
-        }
-    }
-
-    if has_embeddings && ctx.options.standards.pdfa {
-        // PDF 2.0, but ISO 19005-3 (PDF/A-3) Annex E allows it for PDF/A-3.
-        let mut associated_files = catalog.insert(Name(b"AF")).array().typed();
-        for (_, file_ref) in ctx.references.embedded_files {
-            associated_files.item(file_ref).finish();
-        }
-    }
-
-    // Insert the page labels.
-    if !page_labels.is_empty() {
-        let mut num_tree = catalog.page_labels();
-        let mut entries = num_tree.nums();
-        for (n, r) in &page_labels {
-            entries.insert(n.get() as i32 - 1, *r);
-        }
-    }
-
-    if let Some(outline_root_id) = outline_root_id {
-        catalog.outlines(outline_root_id);
-    }
-
-    if let Some(lang) = lang {
-        catalog.lang(TextStr(lang.as_str()));
-    }
-
-    if ctx.options.standards.pdfa {
-        catalog
-            .output_intents()
-            .push()
-            .subtype(pdf_writer::types::OutputIntentSubtype::PDFA)
-            .output_condition(TextStr("sRGB"))
-            .output_condition_identifier(TextStr("Custom"))
-            .info(TextStr("sRGB IEC61966-2.1"))
-            .dest_output_profile(ctx.globals.color_functions.srgb.unwrap());
-    }
-
-    catalog.finish();
-
-    if ctx.options.standards.pdfa && pdf.refs().count() > 8388607 {
-        bail!(Span::detached(), "too many PDF objects");
-    }
-
-    Ok(())
-}
-
-/// Write the page labels.
-pub(crate) fn write_page_labels(
-    chunk: &mut Pdf,
-    alloc: &mut Ref,
-    ctx: &WithEverything,
-) -> Vec<(NonZeroUsize, Ref)> {
-    // If there is no exported page labeled, we skip the writing
-    if !ctx.pages.iter().filter_map(Option::as_ref).any(|p| {
-        p.label
-            .as_ref()
-            .is_some_and(|l| l.prefix.is_some() || l.style.is_some())
-    }) {
-        return Vec::new();
-    }
-
-    let empty_label = PdfPageLabel::default();
-    let mut result = vec![];
-    let mut prev: Option<&PdfPageLabel> = None;
-
-    // Skip non-exported pages for numbering.
-    for (i, page) in ctx.pages.iter().filter_map(Option::as_ref).enumerate() {
-        let nr = NonZeroUsize::new(1 + i).unwrap();
-        // If there are pages with empty labels between labeled pages, we must
-        // write empty PageLabel entries.
-        let label = page.label.as_ref().unwrap_or(&empty_label);
-
-        if let Some(pre) = prev {
-            if label.prefix == pre.prefix
-                && label.style == pre.style
-                && label.offset == pre.offset.map(|n| n.saturating_add(1))
-            {
-                prev = Some(label);
-                continue;
-            }
-        }
-
-        let id = alloc.bump();
-        let mut entry = chunk.indirect(id).start::<PageLabel>();
-
-        // Only add what is actually provided. Don't add empty prefix string if
-        // it wasn't given for example.
-        if let Some(prefix) = &label.prefix {
-            entry.prefix(TextStr::trimmed(prefix));
-        }
-
-        if let Some(style) = label.style {
-            entry.style(style.to_pdf_numbering_style());
-        }
-
-        if let Some(offset) = label.offset {
-            entry.offset(offset.get() as i32);
-        }
-
-        result.push((nr, id));
-        prev = Some(label);
-    }
-
-    result
-}
-
-/// Resolve the document date.
-///
-/// (1) If the `document.date` is set to specific `datetime` or `none`, use it.
-/// (2) If the `document.date` is set to `auto` or not set, try to use the
-///     date from the options.
-/// (3) Otherwise, we don't write date metadata.
-pub fn document_date(
-    document_date: Smart<Option<Datetime>>,
-    timestamp: Option<Timestamp>,
-) -> (Option<Datetime>, Option<Timezone>) {
-    match (document_date, timestamp) {
-        (Smart::Custom(date), _) => (date, None),
-        (Smart::Auto, Some(timestamp)) => {
-            (Some(timestamp.datetime), Some(timestamp.timezone))
-        }
-        _ => (None, None),
-    }
-}
-
-/// Converts a datetime to a pdf-writer date.
-pub fn pdf_date(datetime: Datetime, tz: Option<Timezone>) -> Option<pdf_writer::Date> {
-    let year = datetime.year().filter(|&y| y >= 0)? as u16;
-
-    let mut pdf_date = pdf_writer::Date::new(year);
-
-    if let Some(month) = datetime.month() {
-        pdf_date = pdf_date.month(month);
-    }
-
-    if let Some(day) = datetime.day() {
-        pdf_date = pdf_date.day(day);
-    }
-
-    if let Some(h) = datetime.hour() {
-        pdf_date = pdf_date.hour(h);
-    }
-
-    if let Some(m) = datetime.minute() {
-        pdf_date = pdf_date.minute(m);
-    }
-
-    if let Some(s) = datetime.second() {
-        pdf_date = pdf_date.second(s);
-    }
-
-    match tz {
-        Some(Timezone::UTC) => {
-            pdf_date = pdf_date.utc_offset_hour(0).utc_offset_minute(0)
-        }
-        Some(Timezone::Local { hour_offset, minute_offset }) => {
-            pdf_date =
-                pdf_date.utc_offset_hour(hour_offset).utc_offset_minute(minute_offset)
-        }
-        None => {}
-    }
-
-    Some(pdf_date)
-}
-
-/// Converts a datetime to an xmp-writer datetime.
-fn xmp_date(
-    datetime: Datetime,
-    timezone: Option<Timezone>,
-) -> Option<xmp_writer::DateTime> {
-    let year = datetime.year().filter(|&y| y >= 0)? as u16;
-    let timezone = timezone.map(|tz| match tz {
-        Timezone::UTC => xmp_writer::Timezone::Utc,
-        Timezone::Local { hour_offset, minute_offset } => {
-            // The xmp-writer use signed integers for the minute offset, which
-            // can be buggy if the minute offset is negative. And because our
-            // minute_offset is ensured to be `0 <= minute_offset < 60`, we can
-            // safely cast it to a signed integer.
-            xmp_writer::Timezone::Local { hour: hour_offset, minute: minute_offset as i8 }
-        }
-    });
-    Some(DateTime {
-        year,
-        month: datetime.month(),
-        day: datetime.day(),
-        hour: datetime.hour(),
-        minute: datetime.minute(),
-        second: datetime.second(),
-        timezone,
-    })
-}
diff --git a/crates/typst-pdf/src/color.rs b/crates/typst-pdf/src/color.rs
deleted file mode 100644
index 412afca9a..000000000
--- a/crates/typst-pdf/src/color.rs
+++ /dev/null
@@ -1,394 +0,0 @@
-use std::sync::LazyLock;
-
-use arrayvec::ArrayVec;
-use pdf_writer::{writers, Chunk, Dict, Filter, Name, Ref};
-use typst_library::diag::{bail, SourceResult};
-use typst_library::visualize::{Color, ColorSpace, Paint};
-use typst_syntax::Span;
-
-use crate::{content, deflate, PdfChunk, PdfOptions, Renumber, WithResources};
-
-// The names of the color spaces.
-pub const SRGB: Name<'static> = Name(b"srgb");
-pub const D65_GRAY: Name<'static> = Name(b"d65gray");
-pub const LINEAR_SRGB: Name<'static> = Name(b"linearrgb");
-
-// The ICC profiles.
-static SRGB_ICC_DEFLATED: LazyLock<Vec<u8>> =
-    LazyLock::new(|| deflate(typst_assets::icc::S_RGB_V4));
-static GRAY_ICC_DEFLATED: LazyLock<Vec<u8>> =
-    LazyLock::new(|| deflate(typst_assets::icc::S_GREY_V4));
-
-/// The color spaces present in the PDF document
-#[derive(Default)]
-pub struct ColorSpaces {
-    use_srgb: bool,
-    use_d65_gray: bool,
-    use_linear_rgb: bool,
-}
-
-impl ColorSpaces {
-    /// Mark a color space as used.
-    pub fn mark_as_used(&mut self, color_space: ColorSpace) {
-        match color_space {
-            ColorSpace::Oklch
-            | ColorSpace::Oklab
-            | ColorSpace::Hsl
-            | ColorSpace::Hsv
-            | ColorSpace::Srgb => {
-                self.use_srgb = true;
-            }
-            ColorSpace::D65Gray => {
-                self.use_d65_gray = true;
-            }
-            ColorSpace::LinearRgb => {
-                self.use_linear_rgb = true;
-            }
-            ColorSpace::Cmyk => {}
-        }
-    }
-
-    /// Write the color spaces to the PDF file.
-    pub fn write_color_spaces(&self, mut spaces: Dict, refs: &ColorFunctionRefs) {
-        if self.use_srgb {
-            write(ColorSpace::Srgb, spaces.insert(SRGB).start(), refs);
-        }
-
-        if self.use_d65_gray {
-            write(ColorSpace::D65Gray, spaces.insert(D65_GRAY).start(), refs);
-        }
-
-        if self.use_linear_rgb {
-            write(ColorSpace::LinearRgb, spaces.insert(LINEAR_SRGB).start(), refs);
-        }
-    }
-
-    /// Write the necessary color spaces functions and ICC profiles to the
-    /// PDF file.
-    pub fn write_functions(&self, chunk: &mut Chunk, refs: &ColorFunctionRefs) {
-        // Write the sRGB color space.
-        if let Some(id) = refs.srgb {
-            chunk
-                .icc_profile(id, &SRGB_ICC_DEFLATED)
-                .n(3)
-                .range([0.0, 1.0, 0.0, 1.0, 0.0, 1.0])
-                .filter(Filter::FlateDecode);
-        }
-
-        // Write the gray color space.
-        if let Some(id) = refs.d65_gray {
-            chunk
-                .icc_profile(id, &GRAY_ICC_DEFLATED)
-                .n(1)
-                .range([0.0, 1.0])
-                .filter(Filter::FlateDecode);
-        }
-    }
-
-    /// Merge two color space usage information together: a given color space is
-    /// considered to be used if it is used on either side.
-    pub fn merge(&mut self, other: &Self) {
-        self.use_d65_gray |= other.use_d65_gray;
-        self.use_linear_rgb |= other.use_linear_rgb;
-        self.use_srgb |= other.use_srgb;
-    }
-}
-
-/// Write the color space.
-pub fn write(
-    color_space: ColorSpace,
-    writer: writers::ColorSpace,
-    refs: &ColorFunctionRefs,
-) {
-    match color_space {
-        ColorSpace::Srgb
-        | ColorSpace::Oklab
-        | ColorSpace::Hsl
-        | ColorSpace::Hsv
-        | ColorSpace::Oklch => writer.icc_based(refs.srgb.unwrap()),
-        ColorSpace::D65Gray => writer.icc_based(refs.d65_gray.unwrap()),
-        ColorSpace::LinearRgb => {
-            writer.cal_rgb(
-                [0.9505, 1.0, 1.0888],
-                None,
-                Some([1.0, 1.0, 1.0]),
-                Some([
-                    0.4124, 0.2126, 0.0193, 0.3576, 0.715, 0.1192, 0.1805, 0.0722, 0.9505,
-                ]),
-            );
-        }
-        ColorSpace::Cmyk => writer.device_cmyk(),
-    }
-}
-
-/// Global references for color conversion functions.
-///
-/// These functions are only written once (at most, they are not written if not
-/// needed) in the final document, and be shared by all color space
-/// dictionaries.
-pub struct ColorFunctionRefs {
-    pub srgb: Option<Ref>,
-    d65_gray: Option<Ref>,
-}
-
-impl Renumber for ColorFunctionRefs {
-    fn renumber(&mut self, offset: i32) {
-        if let Some(r) = &mut self.srgb {
-            r.renumber(offset);
-        }
-        if let Some(r) = &mut self.d65_gray {
-            r.renumber(offset);
-        }
-    }
-}
-
-/// Allocate all necessary [`ColorFunctionRefs`].
-pub fn alloc_color_functions_refs(
-    context: &WithResources,
-) -> SourceResult<(PdfChunk, ColorFunctionRefs)> {
-    let mut chunk = PdfChunk::new();
-    let mut used_color_spaces = ColorSpaces::default();
-
-    if context.options.standards.pdfa {
-        used_color_spaces.mark_as_used(ColorSpace::Srgb);
-    }
-
-    context.resources.traverse(&mut |r| {
-        used_color_spaces.merge(&r.colors);
-        Ok(())
-    })?;
-
-    let refs = ColorFunctionRefs {
-        srgb: if used_color_spaces.use_srgb { Some(chunk.alloc()) } else { None },
-        d65_gray: if used_color_spaces.use_d65_gray { Some(chunk.alloc()) } else { None },
-    };
-
-    Ok((chunk, refs))
-}
-
-/// Encodes the color into four f32s, which can be used in a PDF file.
-/// Ensures that the values are in the range [0.0, 1.0].
-///
-/// # Why?
-/// - Oklab: The a and b components are in the range [-0.5, 0.5] and the PDF
-///   specifies (and some readers enforce) that all color values be in the range
-///   [0.0, 1.0]. This means that the PostScript function and the encoded color
-///   must be offset by 0.5.
-/// - HSV/HSL: The hue component is in the range [0.0, 360.0] and the PDF format
-///   specifies that it must be in the range [0.0, 1.0]. This means that the
-///   PostScript function and the encoded color must be divided by 360.0.
-pub trait ColorEncode {
-    /// Performs the color to PDF f32 array conversion.
-    fn encode(&self, color: Color) -> [f32; 4];
-}
-
-impl ColorEncode for ColorSpace {
-    fn encode(&self, color: Color) -> [f32; 4] {
-        match self {
-            ColorSpace::Oklab | ColorSpace::Oklch | ColorSpace::Hsl | ColorSpace::Hsv => {
-                color.to_space(ColorSpace::Srgb).to_vec4()
-            }
-            _ => color.to_space(*self).to_vec4(),
-        }
-    }
-}
-
-/// Encodes a paint into either a fill or stroke color.
-pub(super) trait PaintEncode {
-    /// Set the paint as the fill color.
-    fn set_as_fill(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()>;
-
-    /// Set the paint as the stroke color.
-    fn set_as_stroke(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()>;
-}
-
-impl PaintEncode for Paint {
-    fn set_as_fill(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        match self {
-            Self::Solid(c) => c.set_as_fill(ctx, on_text, transforms),
-            Self::Gradient(gradient) => gradient.set_as_fill(ctx, on_text, transforms),
-            Self::Tiling(tiling) => tiling.set_as_fill(ctx, on_text, transforms),
-        }
-    }
-
-    fn set_as_stroke(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        match self {
-            Self::Solid(c) => c.set_as_stroke(ctx, on_text, transforms),
-            Self::Gradient(gradient) => gradient.set_as_stroke(ctx, on_text, transforms),
-            Self::Tiling(tiling) => tiling.set_as_stroke(ctx, on_text, transforms),
-        }
-    }
-}
-
-impl PaintEncode for Color {
-    fn set_as_fill(
-        &self,
-        ctx: &mut content::Builder,
-        _: bool,
-        _: content::Transforms,
-    ) -> SourceResult<()> {
-        match self {
-            Color::Luma(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::D65Gray);
-                ctx.set_fill_color_space(D65_GRAY);
-
-                let [l, _, _, _] = ColorSpace::D65Gray.encode(*self);
-                ctx.content.set_fill_color([l]);
-            }
-            Color::LinearRgb(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::LinearRgb);
-                ctx.set_fill_color_space(LINEAR_SRGB);
-
-                let [r, g, b, _] = ColorSpace::LinearRgb.encode(*self);
-                ctx.content.set_fill_color([r, g, b]);
-            }
-            // Oklab & friends are encoded as RGB.
-            Color::Rgb(_)
-            | Color::Oklab(_)
-            | Color::Oklch(_)
-            | Color::Hsl(_)
-            | Color::Hsv(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::Srgb);
-                ctx.set_fill_color_space(SRGB);
-
-                let [r, g, b, _] = ColorSpace::Srgb.encode(*self);
-                ctx.content.set_fill_color([r, g, b]);
-            }
-            Color::Cmyk(_) => {
-                check_cmyk_allowed(ctx.options)?;
-                ctx.reset_fill_color_space();
-
-                let [c, m, y, k] = ColorSpace::Cmyk.encode(*self);
-                ctx.content.set_fill_cmyk(c, m, y, k);
-            }
-        }
-        Ok(())
-    }
-
-    fn set_as_stroke(
-        &self,
-        ctx: &mut content::Builder,
-        _: bool,
-        _: content::Transforms,
-    ) -> SourceResult<()> {
-        match self {
-            Color::Luma(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::D65Gray);
-                ctx.set_stroke_color_space(D65_GRAY);
-
-                let [l, _, _, _] = ColorSpace::D65Gray.encode(*self);
-                ctx.content.set_stroke_color([l]);
-            }
-            Color::LinearRgb(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::LinearRgb);
-                ctx.set_stroke_color_space(LINEAR_SRGB);
-
-                let [r, g, b, _] = ColorSpace::LinearRgb.encode(*self);
-                ctx.content.set_stroke_color([r, g, b]);
-            }
-            // Oklab & friends are encoded as RGB.
-            Color::Rgb(_)
-            | Color::Oklab(_)
-            | Color::Oklch(_)
-            | Color::Hsl(_)
-            | Color::Hsv(_) => {
-                ctx.resources.colors.mark_as_used(ColorSpace::Srgb);
-                ctx.set_stroke_color_space(SRGB);
-
-                let [r, g, b, _] = ColorSpace::Srgb.encode(*self);
-                ctx.content.set_stroke_color([r, g, b]);
-            }
-            Color::Cmyk(_) => {
-                check_cmyk_allowed(ctx.options)?;
-                ctx.reset_stroke_color_space();
-
-                let [c, m, y, k] = ColorSpace::Cmyk.encode(*self);
-                ctx.content.set_stroke_cmyk(c, m, y, k);
-            }
-        }
-        Ok(())
-    }
-}
-
-/// Extra color space functions.
-pub(super) trait ColorSpaceExt {
-    /// Returns the range of the color space.
-    fn range(self) -> &'static [f32];
-
-    /// Converts a color to the color space.
-    fn convert<U: QuantizedColor>(self, color: Color) -> ArrayVec<U, 4>;
-}
-
-impl ColorSpaceExt for ColorSpace {
-    fn range(self) -> &'static [f32] {
-        match self {
-            ColorSpace::D65Gray => &[0.0, 1.0],
-            ColorSpace::Oklab => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::Oklch => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::LinearRgb => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::Srgb => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::Cmyk => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::Hsl => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-            ColorSpace::Hsv => &[0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-        }
-    }
-
-    fn convert<U: QuantizedColor>(self, color: Color) -> ArrayVec<U, 4> {
-        let components = self.encode(color);
-
-        self.range()
-            .chunks(2)
-            .zip(components)
-            .map(|(range, component)| U::quantize(component, [range[0], range[1]]))
-            .collect()
-    }
-}
-
-/// Quantizes a color component to a specific type.
-pub(super) trait QuantizedColor {
-    fn quantize(color: f32, range: [f32; 2]) -> Self;
-}
-
-impl QuantizedColor for u16 {
-    fn quantize(color: f32, [min, max]: [f32; 2]) -> Self {
-        let value = (color - min) / (max - min);
-        (value * Self::MAX as f32).round().clamp(0.0, Self::MAX as f32) as Self
-    }
-}
-
-impl QuantizedColor for f32 {
-    fn quantize(color: f32, [min, max]: [f32; 2]) -> Self {
-        color.clamp(min, max)
-    }
-}
-
-/// Fails with an error if PDF/A processing is enabled.
-pub(super) fn check_cmyk_allowed(options: &PdfOptions) -> SourceResult<()> {
-    if options.standards.pdfa {
-        bail!(
-            Span::detached(),
-            "cmyk colors are not currently supported by PDF/A export"
-        );
-    }
-    Ok(())
-}
diff --git a/crates/typst-pdf/src/color_font.rs b/crates/typst-pdf/src/color_font.rs
deleted file mode 100644
index 1183e966e..000000000
--- a/crates/typst-pdf/src/color_font.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-//! OpenType fonts generally define monochrome glyphs, but they can also define
-//! glyphs with colors. This is how emojis are generally implemented for
-//! example.
-//!
-//! There are various standards to represent color glyphs, but PDF readers don't
-//! support any of them natively, so Typst has to handle them manually.
-
-use std::collections::HashMap;
-
-use ecow::eco_format;
-use indexmap::IndexMap;
-use pdf_writer::types::UnicodeCmap;
-use pdf_writer::writers::WMode;
-use pdf_writer::{Filter, Finish, Name, Rect, Ref};
-use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
-use typst_library::foundations::Repr;
-use typst_library::layout::Em;
-use typst_library::text::color::glyph_frame;
-use typst_library::text::{Font, Glyph, TextItemView};
-
-use crate::font::{base_font_name, write_font_descriptor, CMAP_NAME, SYSTEM_INFO};
-use crate::resources::{Resources, ResourcesRefs};
-use crate::{content, EmExt, PdfChunk, PdfOptions, WithGlobalRefs};
-
-/// Write color fonts in the PDF document.
-///
-/// They are written as Type3 fonts, which map glyph IDs to arbitrary PDF
-/// instructions.
-pub fn write_color_fonts(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<ColorFontSlice, Ref>)> {
-    let mut out = HashMap::new();
-    let mut chunk = PdfChunk::new();
-    context.resources.traverse(&mut |resources: &Resources| {
-        let Some(color_fonts) = &resources.color_fonts else {
-            return Ok(());
-        };
-
-        for (color_font, font_slice) in color_fonts.iter() {
-            if out.contains_key(&font_slice) {
-                continue;
-            }
-
-            // Allocate some IDs.
-            let subfont_id = chunk.alloc();
-            let cmap_ref = chunk.alloc();
-            let descriptor_ref = chunk.alloc();
-            let widths_ref = chunk.alloc();
-
-            // And a map between glyph IDs and the instructions to draw this
-            // glyph.
-            let mut glyphs_to_instructions = Vec::new();
-
-            let start = font_slice.subfont * 256;
-            let end = (start + 256).min(color_font.glyphs.len());
-            let glyph_count = end - start;
-            let subset = &color_font.glyphs[start..end];
-            let mut widths = Vec::new();
-            let mut gids = Vec::new();
-
-            let scale_factor = font_slice.font.ttf().units_per_em() as f32;
-
-            // Write the instructions for each glyph.
-            for color_glyph in subset {
-                let instructions_stream_ref = chunk.alloc();
-                let width = font_slice
-                    .font
-                    .advance(color_glyph.gid)
-                    .unwrap_or(Em::new(0.0))
-                    .get() as f32
-                    * scale_factor;
-                widths.push(width);
-                chunk
-                    .stream(
-                        instructions_stream_ref,
-                        color_glyph.instructions.content.wait(),
-                    )
-                    .filter(Filter::FlateDecode);
-
-                // Use this stream as instructions to draw the glyph.
-                glyphs_to_instructions.push(instructions_stream_ref);
-                gids.push(color_glyph.gid);
-            }
-
-            // Determine the base font name.
-            gids.sort();
-            let base_font = base_font_name(&font_slice.font, &gids);
-
-            // Write the Type3 font object.
-            let mut pdf_font = chunk.type3_font(subfont_id);
-            pdf_font.name(Name(base_font.as_bytes()));
-            pdf_font.pair(Name(b"Resources"), color_fonts.resources.reference);
-            pdf_font.bbox(color_font.bbox);
-            pdf_font.matrix([1.0 / scale_factor, 0.0, 0.0, 1.0 / scale_factor, 0.0, 0.0]);
-            pdf_font.first_char(0);
-            pdf_font.last_char((glyph_count - 1) as u8);
-            pdf_font.pair(Name(b"Widths"), widths_ref);
-            pdf_font.to_unicode(cmap_ref);
-            pdf_font.font_descriptor(descriptor_ref);
-
-            // Write the /CharProcs dictionary, that maps glyph names to
-            // drawing instructions.
-            let mut char_procs = pdf_font.char_procs();
-            for (gid, instructions_ref) in glyphs_to_instructions.iter().enumerate() {
-                char_procs
-                    .pair(Name(eco_format!("glyph{gid}").as_bytes()), *instructions_ref);
-            }
-            char_procs.finish();
-
-            // Write the /Encoding dictionary.
-            let names = (0..glyph_count)
-                .map(|gid| eco_format!("glyph{gid}"))
-                .collect::<Vec<_>>();
-            pdf_font
-                .encoding_custom()
-                .differences()
-                .consecutive(0, names.iter().map(|name| Name(name.as_bytes())));
-            pdf_font.finish();
-
-            // Encode a CMAP to make it possible to search or copy glyphs.
-            let glyph_set = resources.color_glyph_sets.get(&font_slice.font).unwrap();
-            let mut cmap = UnicodeCmap::new(CMAP_NAME, SYSTEM_INFO);
-            for (index, glyph) in subset.iter().enumerate() {
-                let Some(text) = glyph_set.get(&glyph.gid) else {
-                    continue;
-                };
-
-                if !text.is_empty() {
-                    cmap.pair_with_multiple(index as u8, text.chars());
-                }
-            }
-            chunk.cmap(cmap_ref, &cmap.finish()).writing_mode(WMode::Horizontal);
-
-            // Write the font descriptor.
-            write_font_descriptor(
-                &mut chunk,
-                descriptor_ref,
-                &font_slice.font,
-                &base_font,
-            );
-
-            // Write the widths array
-            chunk.indirect(widths_ref).array().items(widths);
-
-            out.insert(font_slice, subfont_id);
-        }
-
-        Ok(())
-    })?;
-
-    Ok((chunk, out))
-}
-
-/// A mapping between `Font`s and all the corresponding `ColorFont`s.
-///
-/// This mapping is one-to-many because there can only be 256 glyphs in a Type 3
-/// font, and fonts generally have more color glyphs than that.
-pub struct ColorFontMap<R> {
-    /// The mapping itself.
-    map: IndexMap<Font, ColorFont>,
-    /// The resources required to render the fonts in this map.
-    ///
-    /// For example, this can be the images for glyphs based on bitmaps or SVG.
-    pub resources: Resources<R>,
-    /// The number of font slices (groups of 256 color glyphs), across all color
-    /// fonts.
-    total_slice_count: usize,
-}
-
-/// A collection of Type3 font, belonging to the same TTF font.
-pub struct ColorFont {
-    /// The IDs of each sub-slice of this font. They are the numbers after "Cf"
-    /// in the Resources dictionaries.
-    slice_ids: Vec<usize>,
-    /// The list of all color glyphs in this family.
-    ///
-    /// The index in this vector modulo 256 corresponds to the index in one of
-    /// the Type3 fonts in `refs` (the `n`-th in the vector, where `n` is the
-    /// quotient of the index divided by 256).
-    pub glyphs: Vec<ColorGlyph>,
-    /// The global bounding box of the font.
-    pub bbox: Rect,
-    /// A mapping between glyph IDs and character indices in the `glyphs`
-    /// vector.
-    glyph_indices: HashMap<u16, usize>,
-}
-
-/// A single color glyph.
-pub struct ColorGlyph {
-    /// The ID of the glyph.
-    pub gid: u16,
-    /// Instructions to draw the glyph.
-    pub instructions: content::Encoded,
-}
-
-impl ColorFontMap<()> {
-    /// Creates a new empty mapping
-    pub fn new() -> Self {
-        Self {
-            map: IndexMap::new(),
-            total_slice_count: 0,
-            resources: Resources::default(),
-        }
-    }
-
-    /// For a given glyph in a TTF font, give the ID of the Type3 font and the
-    /// index of the glyph inside of this Type3 font.
-    ///
-    /// If this is the first occurrence of this glyph in this font, it will
-    /// start its encoding and add it to the list of known glyphs.
-    pub fn get(
-        &mut self,
-        options: &PdfOptions,
-        text: &TextItemView,
-        glyph: &Glyph,
-    ) -> SourceResult<(usize, u8)> {
-        let font = &text.item.font;
-        let color_font = self.map.entry(font.clone()).or_insert_with(|| {
-            let global_bbox = font.ttf().global_bounding_box();
-            let bbox = Rect::new(
-                font.to_em(global_bbox.x_min).to_font_units(),
-                font.to_em(global_bbox.y_min).to_font_units(),
-                font.to_em(global_bbox.x_max).to_font_units(),
-                font.to_em(global_bbox.y_max).to_font_units(),
-            );
-            ColorFont {
-                bbox,
-                slice_ids: Vec::new(),
-                glyphs: Vec::new(),
-                glyph_indices: HashMap::new(),
-            }
-        });
-
-        Ok(if let Some(index_of_glyph) = color_font.glyph_indices.get(&glyph.id) {
-            // If we already know this glyph, return it.
-            (color_font.slice_ids[index_of_glyph / 256], *index_of_glyph as u8)
-        } else {
-            // Otherwise, allocate a new ColorGlyph in the font, and a new Type3 font
-            // if needed
-            let index = color_font.glyphs.len();
-            if index % 256 == 0 {
-                color_font.slice_ids.push(self.total_slice_count);
-                self.total_slice_count += 1;
-            }
-
-            let (frame, tofu) = glyph_frame(font, glyph.id);
-            if options.standards.pdfa && tofu {
-                bail!(failed_to_convert(text, glyph));
-            }
-
-            let width = font.advance(glyph.id).unwrap_or(Em::new(0.0)).get()
-                * font.units_per_em();
-            let instructions = content::build(
-                options,
-                &mut self.resources,
-                &frame,
-                None,
-                Some(width as f32),
-            )?;
-            color_font.glyphs.push(ColorGlyph { gid: glyph.id, instructions });
-            color_font.glyph_indices.insert(glyph.id, index);
-
-            (color_font.slice_ids[index / 256], index as u8)
-        })
-    }
-
-    /// Assign references to the resource dictionary used by this set of color
-    /// fonts.
-    pub fn with_refs(self, refs: &ResourcesRefs) -> ColorFontMap<Ref> {
-        ColorFontMap {
-            map: self.map,
-            resources: self.resources.with_refs(refs),
-            total_slice_count: self.total_slice_count,
-        }
-    }
-}
-
-impl<R> ColorFontMap<R> {
-    /// Iterate over all Type3 fonts.
-    ///
-    /// Each item of this iterator maps to a Type3 font: it contains
-    /// at most 256 glyphs. A same TTF font can yield multiple Type3 fonts.
-    pub fn iter(&self) -> ColorFontMapIter<'_, R> {
-        ColorFontMapIter { map: self, font_index: 0, slice_index: 0 }
-    }
-}
-
-/// Iterator over a [`ColorFontMap`].
-///
-/// See [`ColorFontMap::iter`].
-pub struct ColorFontMapIter<'a, R> {
-    /// The map over which to iterate
-    map: &'a ColorFontMap<R>,
-    /// The index of TTF font on which we currently iterate
-    font_index: usize,
-    /// The sub-font (slice of at most 256 glyphs) at which we currently are.
-    slice_index: usize,
-}
-
-impl<'a, R> Iterator for ColorFontMapIter<'a, R> {
-    type Item = (&'a ColorFont, ColorFontSlice);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let (font, color_font) = self.map.map.get_index(self.font_index)?;
-        let slice_count = (color_font.glyphs.len() / 256) + 1;
-
-        if self.slice_index >= slice_count {
-            self.font_index += 1;
-            self.slice_index = 0;
-            return self.next();
-        }
-
-        let slice = ColorFontSlice { font: font.clone(), subfont: self.slice_index };
-        self.slice_index += 1;
-        Some((color_font, slice))
-    }
-}
-
-/// A set of at most 256 glyphs (a limit imposed on Type3 fonts by the PDF
-/// specification) that represents a part of a TTF font.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ColorFontSlice {
-    /// The original TTF font.
-    pub font: Font,
-    /// The index of the Type3 font, among all those that are necessary to
-    /// represent the subset of the TTF font we are interested in.
-    pub subfont: usize,
-}
-
-/// The error when the glyph could not be converted.
-#[cold]
-fn failed_to_convert(text: &TextItemView, glyph: &Glyph) -> SourceDiagnostic {
-    let mut diag = error!(
-        glyph.span.0,
-        "the glyph for {} could not be exported",
-        text.glyph_text(glyph).repr()
-    );
-
-    if text.item.font.ttf().tables().cff2.is_some() {
-        diag.hint("CFF2 fonts are not currently supported");
-    }
-
-    diag
-}
diff --git a/crates/typst-pdf/src/content.rs b/crates/typst-pdf/src/content.rs
deleted file mode 100644
index 8b7517f51..000000000
--- a/crates/typst-pdf/src/content.rs
+++ /dev/null
@@ -1,823 +0,0 @@
-//! Generic writer for PDF content.
-//!
-//! It is used to write page contents, color glyph instructions, and tilings.
-//!
-//! See also [`pdf_writer::Content`].
-
-use ecow::eco_format;
-use pdf_writer::types::{
-    ColorSpaceOperand, LineCapStyle, LineJoinStyle, TextRenderingMode,
-};
-use pdf_writer::writers::PositionedItems;
-use pdf_writer::{Content, Finish, Name, Rect, Str};
-use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
-use typst_library::foundations::Repr;
-use typst_library::layout::{
-    Abs, Em, Frame, FrameItem, GroupItem, Point, Ratio, Size, Transform,
-};
-use typst_library::model::Destination;
-use typst_library::text::color::should_outline;
-use typst_library::text::{Font, Glyph, TextItem, TextItemView};
-use typst_library::visualize::{
-    Curve, CurveItem, FillRule, FixedStroke, Geometry, Image, LineCap, LineJoin, Paint,
-    Shape,
-};
-use typst_syntax::Span;
-use typst_utils::{Deferred, Numeric, SliceExt};
-
-use crate::color::PaintEncode;
-use crate::color_font::ColorFontMap;
-use crate::extg::ExtGState;
-use crate::image::deferred_image;
-use crate::resources::Resources;
-use crate::{deflate_deferred, AbsExt, ContentExt, EmExt, PdfOptions, StrExt};
-
-/// Encode a [`Frame`] into a content stream.
-///
-/// The resources that were used in the stream will be added to `resources`.
-///
-/// `color_glyph_width` should be `None` unless the `Frame` represents a [color
-/// glyph].
-///
-/// [color glyph]: `crate::color_font`
-pub fn build(
-    options: &PdfOptions,
-    resources: &mut Resources<()>,
-    frame: &Frame,
-    fill: Option<Paint>,
-    color_glyph_width: Option<f32>,
-) -> SourceResult<Encoded> {
-    let size = frame.size();
-    let mut ctx = Builder::new(options, resources, size);
-
-    if let Some(width) = color_glyph_width {
-        ctx.content.start_color_glyph(width);
-    }
-
-    // Make the coordinate system start at the top-left.
-    ctx.transform(
-        // Make the Y axis go upwards
-        Transform::scale(Ratio::one(), -Ratio::one())
-            // Also move the origin to the top left corner
-            .post_concat(Transform::translate(Abs::zero(), size.y)),
-    );
-
-    if let Some(fill) = fill {
-        let shape = Geometry::Rect(frame.size()).filled(fill);
-        write_shape(&mut ctx, Point::zero(), &shape)?;
-    }
-
-    // Encode the frame into the content stream.
-    write_frame(&mut ctx, frame)?;
-
-    Ok(Encoded {
-        size,
-        content: deflate_deferred(ctx.content.finish()),
-        uses_opacities: ctx.uses_opacities,
-        links: ctx.links,
-    })
-}
-
-/// An encoded content stream.
-pub struct Encoded {
-    /// The dimensions of the content.
-    pub size: Size,
-    /// The actual content stream.
-    pub content: Deferred<Vec<u8>>,
-    /// Whether the content opacities.
-    pub uses_opacities: bool,
-    /// Links in the PDF coordinate system.
-    pub links: Vec<(Destination, Rect)>,
-}
-
-/// An exporter for a single PDF content stream.
-///
-/// Content streams are a series of PDF commands. They can reference external
-/// objects only through resources.
-///
-/// Content streams can be used for page contents, but also to describe color
-/// glyphs and tilings.
-pub struct Builder<'a, R = ()> {
-    /// Settings for PDF export.
-    pub(crate) options: &'a PdfOptions<'a>,
-    /// A list of all resources that are used in the content stream.
-    pub(crate) resources: &'a mut Resources<R>,
-    /// The PDF content stream that is being built.
-    pub content: Content,
-    /// Current graphic state.
-    state: State,
-    /// Stack of saved graphic states.
-    saves: Vec<State>,
-    /// Whether any stroke or fill was not totally opaque.
-    uses_opacities: bool,
-    /// All clickable links that are present in this content.
-    links: Vec<(Destination, Rect)>,
-}
-
-impl<'a, R> Builder<'a, R> {
-    /// Create a new content builder.
-    pub fn new(
-        options: &'a PdfOptions<'a>,
-        resources: &'a mut Resources<R>,
-        size: Size,
-    ) -> Self {
-        Builder {
-            options,
-            resources,
-            uses_opacities: false,
-            content: Content::new(),
-            state: State::new(size),
-            saves: vec![],
-            links: vec![],
-        }
-    }
-}
-
-/// A simulated graphics state used to deduplicate graphics state changes and
-/// keep track of the current transformation matrix for link annotations.
-#[derive(Debug, Clone)]
-struct State {
-    /// The transform of the current item.
-    transform: Transform,
-    /// The transform of first hard frame in the hierarchy.
-    container_transform: Transform,
-    /// The size of the first hard frame in the hierarchy.
-    size: Size,
-    /// The current font.
-    font: Option<(Font, Abs)>,
-    /// The current fill paint.
-    fill: Option<Paint>,
-    /// The color space of the current fill paint.
-    fill_space: Option<Name<'static>>,
-    /// The current external graphic state.
-    external_graphics_state: ExtGState,
-    /// The current stroke paint.
-    stroke: Option<FixedStroke>,
-    /// The color space of the current stroke paint.
-    stroke_space: Option<Name<'static>>,
-    /// The current text rendering mode.
-    text_rendering_mode: TextRenderingMode,
-}
-
-impl State {
-    /// Creates a new, clean state for a given `size`.
-    pub fn new(size: Size) -> Self {
-        Self {
-            transform: Transform::identity(),
-            container_transform: Transform::identity(),
-            size,
-            font: None,
-            fill: None,
-            fill_space: None,
-            external_graphics_state: ExtGState::default(),
-            stroke: None,
-            stroke_space: None,
-            text_rendering_mode: TextRenderingMode::Fill,
-        }
-    }
-
-    /// Creates the [`Transforms`] structure for the current item.
-    pub fn transforms(&self, size: Size, pos: Point) -> Transforms {
-        Transforms {
-            transform: self.transform.pre_concat(Transform::translate(pos.x, pos.y)),
-            container_transform: self.container_transform,
-            container_size: self.size,
-            size,
-        }
-    }
-}
-
-/// Subset of the state used to calculate the transform of gradients and tilings.
-#[derive(Debug, Clone, Copy)]
-pub(super) struct Transforms {
-    /// The transform of the current item.
-    pub transform: Transform,
-    /// The transform of first hard frame in the hierarchy.
-    pub container_transform: Transform,
-    /// The size of the first hard frame in the hierarchy.
-    pub container_size: Size,
-    /// The size of the item.
-    pub size: Size,
-}
-
-impl Builder<'_, ()> {
-    fn save_state(&mut self) -> SourceResult<()> {
-        self.saves.push(self.state.clone());
-        self.content.save_state_checked()
-    }
-
-    fn restore_state(&mut self) {
-        self.content.restore_state();
-        self.state = self.saves.pop().expect("missing state save");
-    }
-
-    fn set_external_graphics_state(&mut self, graphics_state: &ExtGState) {
-        let current_state = &self.state.external_graphics_state;
-        if current_state != graphics_state {
-            let index = self.resources.ext_gs.insert(*graphics_state);
-            let name = eco_format!("Gs{index}");
-            self.content.set_parameters(Name(name.as_bytes()));
-
-            self.state.external_graphics_state = *graphics_state;
-            if graphics_state.uses_opacities() {
-                self.uses_opacities = true;
-            }
-        }
-    }
-
-    fn set_opacities(&mut self, stroke: Option<&FixedStroke>, fill: Option<&Paint>) {
-        let get_opacity = |paint: &Paint| {
-            let color = match paint {
-                Paint::Solid(color) => *color,
-                Paint::Gradient(_) | Paint::Tiling(_) => return 255,
-            };
-
-            color.alpha().map_or(255, |v| (v * 255.0).round() as u8)
-        };
-
-        let stroke_opacity = stroke.map_or(255, |stroke| get_opacity(&stroke.paint));
-        let fill_opacity = fill.map_or(255, get_opacity);
-        self.set_external_graphics_state(&ExtGState { stroke_opacity, fill_opacity });
-    }
-
-    fn reset_opacities(&mut self) {
-        self.set_external_graphics_state(&ExtGState {
-            stroke_opacity: 255,
-            fill_opacity: 255,
-        });
-    }
-
-    pub fn transform(&mut self, transform: Transform) {
-        let Transform { sx, ky, kx, sy, tx, ty } = transform;
-        self.state.transform = self.state.transform.pre_concat(transform);
-        if self.state.container_transform.is_identity() {
-            self.state.container_transform = self.state.transform;
-        }
-        self.content.transform([
-            sx.get() as _,
-            ky.get() as _,
-            kx.get() as _,
-            sy.get() as _,
-            tx.to_f32(),
-            ty.to_f32(),
-        ]);
-    }
-
-    fn group_transform(&mut self, transform: Transform) {
-        self.state.container_transform =
-            self.state.container_transform.pre_concat(transform);
-    }
-
-    fn set_font(&mut self, font: &Font, size: Abs) {
-        if self.state.font.as_ref().map(|(f, s)| (f, *s)) != Some((font, size)) {
-            let index = self.resources.fonts.insert(font.clone());
-            let name = eco_format!("F{index}");
-            self.content.set_font(Name(name.as_bytes()), size.to_f32());
-            self.state.font = Some((font.clone(), size));
-        }
-    }
-
-    fn size(&mut self, size: Size) {
-        self.state.size = size;
-    }
-
-    fn set_fill(
-        &mut self,
-        fill: &Paint,
-        on_text: bool,
-        transforms: Transforms,
-    ) -> SourceResult<()> {
-        if self.state.fill.as_ref() != Some(fill)
-            || matches!(self.state.fill, Some(Paint::Gradient(_)))
-        {
-            fill.set_as_fill(self, on_text, transforms)?;
-            self.state.fill = Some(fill.clone());
-        }
-        Ok(())
-    }
-
-    pub fn set_fill_color_space(&mut self, space: Name<'static>) {
-        if self.state.fill_space != Some(space) {
-            self.content.set_fill_color_space(ColorSpaceOperand::Named(space));
-            self.state.fill_space = Some(space);
-        }
-    }
-
-    pub fn reset_fill_color_space(&mut self) {
-        self.state.fill_space = None;
-    }
-
-    fn set_stroke(
-        &mut self,
-        stroke: &FixedStroke,
-        on_text: bool,
-        transforms: Transforms,
-    ) -> SourceResult<()> {
-        if self.state.stroke.as_ref() != Some(stroke)
-            || matches!(
-                self.state.stroke.as_ref().map(|s| &s.paint),
-                Some(Paint::Gradient(_))
-            )
-        {
-            let FixedStroke { paint, thickness, cap, join, dash, miter_limit } = stroke;
-            paint.set_as_stroke(self, on_text, transforms)?;
-
-            self.content.set_line_width(thickness.to_f32());
-            if self.state.stroke.as_ref().map(|s| &s.cap) != Some(cap) {
-                self.content.set_line_cap(to_pdf_line_cap(*cap));
-            }
-            if self.state.stroke.as_ref().map(|s| &s.join) != Some(join) {
-                self.content.set_line_join(to_pdf_line_join(*join));
-            }
-            if self.state.stroke.as_ref().map(|s| &s.dash) != Some(dash) {
-                if let Some(dash) = dash {
-                    self.content.set_dash_pattern(
-                        dash.array.iter().map(|l| l.to_f32()),
-                        dash.phase.to_f32(),
-                    );
-                } else {
-                    self.content.set_dash_pattern([], 0.0);
-                }
-            }
-            if self.state.stroke.as_ref().map(|s| &s.miter_limit) != Some(miter_limit) {
-                self.content.set_miter_limit(miter_limit.get() as f32);
-            }
-            self.state.stroke = Some(stroke.clone());
-        }
-
-        Ok(())
-    }
-
-    pub fn set_stroke_color_space(&mut self, space: Name<'static>) {
-        if self.state.stroke_space != Some(space) {
-            self.content.set_stroke_color_space(ColorSpaceOperand::Named(space));
-            self.state.stroke_space = Some(space);
-        }
-    }
-
-    pub fn reset_stroke_color_space(&mut self) {
-        self.state.stroke_space = None;
-    }
-
-    fn set_text_rendering_mode(&mut self, mode: TextRenderingMode) {
-        if self.state.text_rendering_mode != mode {
-            self.content.set_text_rendering_mode(mode);
-            self.state.text_rendering_mode = mode;
-        }
-    }
-}
-
-/// Encode a frame into the content stream.
-pub(crate) fn write_frame(ctx: &mut Builder, frame: &Frame) -> SourceResult<()> {
-    for &(pos, ref item) in frame.items() {
-        let x = pos.x.to_f32();
-        let y = pos.y.to_f32();
-        match item {
-            FrameItem::Group(group) => write_group(ctx, pos, group)?,
-            FrameItem::Text(text) => write_text(ctx, pos, text)?,
-            FrameItem::Shape(shape, _) => write_shape(ctx, pos, shape)?,
-            FrameItem::Image(image, size, span) => {
-                write_image(ctx, x, y, image, *size, *span)?
-            }
-            FrameItem::Link(dest, size) => write_link(ctx, pos, dest, *size),
-            FrameItem::Tag(_) => {}
-        }
-    }
-    Ok(())
-}
-
-/// Encode a group into the content stream.
-fn write_group(ctx: &mut Builder, pos: Point, group: &GroupItem) -> SourceResult<()> {
-    let translation = Transform::translate(pos.x, pos.y);
-
-    ctx.save_state()?;
-
-    if group.frame.kind().is_hard() {
-        ctx.group_transform(
-            ctx.state
-                .transform
-                .post_concat(ctx.state.container_transform.invert().unwrap())
-                .pre_concat(translation)
-                .pre_concat(group.transform),
-        );
-        ctx.size(group.frame.size());
-    }
-
-    ctx.transform(translation.pre_concat(group.transform));
-    if let Some(clip_curve) = &group.clip {
-        write_curve(ctx, 0.0, 0.0, clip_curve);
-        ctx.content.clip_nonzero();
-        ctx.content.end_path();
-    }
-
-    write_frame(ctx, &group.frame)?;
-    ctx.restore_state();
-
-    Ok(())
-}
-
-/// Encode a text run into the content stream.
-fn write_text(ctx: &mut Builder, pos: Point, text: &TextItem) -> SourceResult<()> {
-    if ctx.options.standards.pdfa && text.font.info().is_last_resort() {
-        bail!(
-            Span::find(text.glyphs.iter().map(|g| g.span.0)),
-            "the text {} could not be displayed with any font",
-            &text.text,
-        );
-    }
-
-    let outline_glyphs =
-        text.glyphs.iter().filter(|g| should_outline(&text.font, g)).count();
-
-    if outline_glyphs == text.glyphs.len() {
-        write_normal_text(ctx, pos, TextItemView::full(text))?;
-    } else if outline_glyphs == 0 {
-        write_complex_glyphs(ctx, pos, TextItemView::full(text))?;
-    } else {
-        // Otherwise we need to split it into smaller text runs.
-        let mut offset = 0;
-        let mut position_in_run = Abs::zero();
-        for (should_outline, sub_run) in
-            text.glyphs.group_by_key(|g| should_outline(&text.font, g))
-        {
-            let end = offset + sub_run.len();
-
-            // Build a sub text-run
-            let text_item_view = TextItemView::from_glyph_range(text, offset..end);
-
-            // Adjust the position of the run on the line
-            let pos = pos + Point::new(position_in_run, Abs::zero());
-            position_in_run += text_item_view.width();
-            offset = end;
-
-            // Actually write the sub text-run.
-            if should_outline {
-                write_normal_text(ctx, pos, text_item_view)?;
-            } else {
-                write_complex_glyphs(ctx, pos, text_item_view)?;
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Encodes a text run (without any color glyph) into the content stream.
-fn write_normal_text(
-    ctx: &mut Builder,
-    pos: Point,
-    text: TextItemView,
-) -> SourceResult<()> {
-    let x = pos.x.to_f32();
-    let y = pos.y.to_f32();
-
-    *ctx.resources.languages.entry(text.item.lang).or_insert(0) += text.glyph_range.len();
-
-    let glyph_set = ctx.resources.glyph_sets.entry(text.item.font.clone()).or_default();
-    for g in text.glyphs() {
-        glyph_set.entry(g.id).or_insert_with(|| text.glyph_text(g));
-    }
-
-    let fill_transform = ctx.state.transforms(Size::zero(), pos);
-    ctx.set_fill(&text.item.fill, true, fill_transform)?;
-
-    let stroke = text.item.stroke.as_ref().and_then(|stroke| {
-        if stroke.thickness.to_f32() > 0.0 {
-            Some(stroke)
-        } else {
-            None
-        }
-    });
-
-    if let Some(stroke) = stroke {
-        ctx.set_stroke(stroke, true, fill_transform)?;
-        ctx.set_text_rendering_mode(TextRenderingMode::FillStroke);
-    } else {
-        ctx.set_text_rendering_mode(TextRenderingMode::Fill);
-    }
-
-    ctx.set_font(&text.item.font, text.item.size);
-    ctx.set_opacities(text.item.stroke.as_ref(), Some(&text.item.fill));
-    ctx.content.begin_text();
-
-    // Position the text.
-    ctx.content.set_text_matrix([1.0, 0.0, 0.0, -1.0, x, y]);
-
-    let mut positioned = ctx.content.show_positioned();
-    let mut items = positioned.items();
-    let mut adjustment = Em::zero();
-    let mut encoded = vec![];
-
-    let glyph_remapper = ctx
-        .resources
-        .glyph_remappers
-        .entry(text.item.font.clone())
-        .or_default();
-
-    // Write the glyphs with kerning adjustments.
-    for glyph in text.glyphs() {
-        if ctx.options.standards.pdfa && glyph.id == 0 {
-            bail!(tofu(&text, glyph));
-        }
-
-        adjustment += glyph.x_offset;
-
-        if !adjustment.is_zero() {
-            if !encoded.is_empty() {
-                show_text(&mut items, &encoded);
-                encoded.clear();
-            }
-
-            items.adjust(-adjustment.to_font_units());
-            adjustment = Em::zero();
-        }
-
-        // In PDF, we use CIDs to index the glyphs in a font, not GIDs. What a
-        // CID actually refers to depends on the type of font we are embedding:
-        //
-        // - For TrueType fonts, the CIDs are defined by an external mapping.
-        // - For SID-keyed CFF fonts, the CID is the same as the GID in the font.
-        // - For CID-keyed CFF fonts, the CID refers to the CID in the font.
-        //
-        // (See in the PDF-spec for more details on this.)
-        //
-        // However, in our case:
-        // - We use the identity-mapping for TrueType fonts.
-        // - SID-keyed fonts will get converted into CID-keyed fonts by the
-        //   subsetter.
-        // - CID-keyed fonts will be rewritten in a way so that the mapping
-        //   between CID and GID is always the identity mapping, regardless of
-        //   the mapping before.
-        //
-        // Because of this, we can always use the remapped GID as the CID,
-        // regardless of which type of font we are actually embedding.
-        let cid = glyph_remapper.remap(glyph.id);
-        encoded.push((cid >> 8) as u8);
-        encoded.push((cid & 0xff) as u8);
-
-        if let Some(advance) = text.item.font.advance(glyph.id) {
-            adjustment += glyph.x_advance - advance;
-        }
-
-        adjustment -= glyph.x_offset;
-    }
-
-    if !encoded.is_empty() {
-        show_text(&mut items, &encoded);
-    }
-
-    items.finish();
-    positioned.finish();
-    ctx.content.end_text();
-
-    Ok(())
-}
-
-/// Shows text, ensuring that each individual string doesn't exceed the
-/// implementation limits.
-fn show_text(items: &mut PositionedItems, encoded: &[u8]) {
-    for chunk in encoded.chunks(Str::PDFA_LIMIT) {
-        items.show(Str(chunk));
-    }
-}
-
-/// Encodes a text run made only of color glyphs into the content stream
-fn write_complex_glyphs(
-    ctx: &mut Builder,
-    pos: Point,
-    text: TextItemView,
-) -> SourceResult<()> {
-    let x = pos.x.to_f32();
-    let y = pos.y.to_f32();
-
-    let mut last_font = None;
-
-    ctx.reset_opacities();
-
-    ctx.content.begin_text();
-    ctx.content.set_text_matrix([1.0, 0.0, 0.0, -1.0, x, y]);
-    // So that the next call to ctx.set_font() will change the font to one that
-    // displays regular glyphs and not color glyphs.
-    ctx.state.font = None;
-
-    let glyph_set = ctx
-        .resources
-        .color_glyph_sets
-        .entry(text.item.font.clone())
-        .or_default();
-
-    for glyph in text.glyphs() {
-        if ctx.options.standards.pdfa && glyph.id == 0 {
-            bail!(tofu(&text, glyph));
-        }
-
-        // Retrieve the Type3 font reference and the glyph index in the font.
-        let color_fonts = ctx
-            .resources
-            .color_fonts
-            .get_or_insert_with(|| Box::new(ColorFontMap::new()));
-
-        let (font, index) = color_fonts.get(ctx.options, &text, glyph)?;
-
-        if last_font != Some(font) {
-            ctx.content.set_font(
-                Name(eco_format!("Cf{}", font).as_bytes()),
-                text.item.size.to_f32(),
-            );
-            last_font = Some(font);
-        }
-
-        ctx.content.show(Str(&[index]));
-
-        glyph_set.entry(glyph.id).or_insert_with(|| text.glyph_text(glyph));
-    }
-    ctx.content.end_text();
-
-    Ok(())
-}
-
-/// Encode a geometrical shape into the content stream.
-fn write_shape(ctx: &mut Builder, pos: Point, shape: &Shape) -> SourceResult<()> {
-    let x = pos.x.to_f32();
-    let y = pos.y.to_f32();
-
-    let stroke = shape.stroke.as_ref().and_then(|stroke| {
-        if stroke.thickness.to_f32() > 0.0 {
-            Some(stroke)
-        } else {
-            None
-        }
-    });
-
-    if shape.fill.is_none() && stroke.is_none() {
-        return Ok(());
-    }
-
-    if let Some(fill) = &shape.fill {
-        ctx.set_fill(fill, false, ctx.state.transforms(shape.geometry.bbox_size(), pos))?;
-    }
-
-    if let Some(stroke) = stroke {
-        ctx.set_stroke(
-            stroke,
-            false,
-            ctx.state.transforms(shape.geometry.bbox_size(), pos),
-        )?;
-    }
-
-    ctx.set_opacities(stroke, shape.fill.as_ref());
-
-    match &shape.geometry {
-        Geometry::Line(target) => {
-            let dx = target.x.to_f32();
-            let dy = target.y.to_f32();
-            ctx.content.move_to(x, y);
-            ctx.content.line_to(x + dx, y + dy);
-        }
-        Geometry::Rect(size) => {
-            let w = size.x.to_f32();
-            let h = size.y.to_f32();
-            if w.abs() > f32::EPSILON && h.abs() > f32::EPSILON {
-                ctx.content.rect(x, y, w, h);
-            }
-        }
-        Geometry::Curve(curve) => {
-            write_curve(ctx, x, y, curve);
-        }
-    }
-
-    match (&shape.fill, &shape.fill_rule, stroke) {
-        (None, _, None) => unreachable!(),
-        (Some(_), FillRule::NonZero, None) => ctx.content.fill_nonzero(),
-        (Some(_), FillRule::EvenOdd, None) => ctx.content.fill_even_odd(),
-        (None, _, Some(_)) => ctx.content.stroke(),
-        (Some(_), FillRule::NonZero, Some(_)) => ctx.content.fill_nonzero_and_stroke(),
-        (Some(_), FillRule::EvenOdd, Some(_)) => ctx.content.fill_even_odd_and_stroke(),
-    };
-
-    Ok(())
-}
-
-/// Encode a curve into the content stream.
-fn write_curve(ctx: &mut Builder, x: f32, y: f32, curve: &Curve) {
-    for elem in &curve.0 {
-        match elem {
-            CurveItem::Move(p) => ctx.content.move_to(x + p.x.to_f32(), y + p.y.to_f32()),
-            CurveItem::Line(p) => ctx.content.line_to(x + p.x.to_f32(), y + p.y.to_f32()),
-            CurveItem::Cubic(p1, p2, p3) => ctx.content.cubic_to(
-                x + p1.x.to_f32(),
-                y + p1.y.to_f32(),
-                x + p2.x.to_f32(),
-                y + p2.y.to_f32(),
-                x + p3.x.to_f32(),
-                y + p3.y.to_f32(),
-            ),
-            CurveItem::Close => ctx.content.close_path(),
-        };
-    }
-}
-
-/// Encode a vector or raster image into the content stream.
-fn write_image(
-    ctx: &mut Builder,
-    x: f32,
-    y: f32,
-    image: &Image,
-    size: Size,
-    span: Span,
-) -> SourceResult<()> {
-    let index = ctx.resources.images.insert(image.clone());
-    ctx.resources.deferred_images.entry(index).or_insert_with(|| {
-        let (image, color_space) =
-            deferred_image(image.clone(), ctx.options.standards.pdfa);
-        if let Some(color_space) = color_space {
-            ctx.resources.colors.mark_as_used(color_space);
-        }
-        (image, span)
-    });
-
-    ctx.reset_opacities();
-
-    let name = eco_format!("Im{index}");
-    let w = size.x.to_f32();
-    let h = size.y.to_f32();
-    ctx.content.save_state_checked()?;
-    ctx.content.transform([w, 0.0, 0.0, -h, x, y + h]);
-
-    if let Some(alt) = image.alt() {
-        if ctx.options.standards.pdfa && alt.len() > Str::PDFA_LIMIT {
-            bail!(span, "the image's alt text is too long");
-        }
-
-        let mut image_span =
-            ctx.content.begin_marked_content_with_properties(Name(b"Span"));
-        let mut image_alt = image_span.properties();
-        image_alt.pair(Name(b"Alt"), Str(alt.as_bytes()));
-        image_alt.finish();
-        image_span.finish();
-
-        ctx.content.x_object(Name(name.as_bytes()));
-        ctx.content.end_marked_content();
-    } else {
-        ctx.content.x_object(Name(name.as_bytes()));
-    }
-
-    ctx.content.restore_state();
-    Ok(())
-}
-
-/// Save a link for later writing in the annotations dictionary.
-fn write_link(ctx: &mut Builder, pos: Point, dest: &Destination, size: Size) {
-    let mut min_x = Abs::inf();
-    let mut min_y = Abs::inf();
-    let mut max_x = -Abs::inf();
-    let mut max_y = -Abs::inf();
-
-    // Compute the bounding box of the transformed link.
-    for point in [
-        pos,
-        pos + Point::with_x(size.x),
-        pos + Point::with_y(size.y),
-        pos + size.to_point(),
-    ] {
-        let t = point.transform(ctx.state.transform);
-        min_x.set_min(t.x);
-        min_y.set_min(t.y);
-        max_x.set_max(t.x);
-        max_y.set_max(t.y);
-    }
-
-    let x1 = min_x.to_f32();
-    let x2 = max_x.to_f32();
-    let y1 = max_y.to_f32();
-    let y2 = min_y.to_f32();
-    let rect = Rect::new(x1, y1, x2, y2);
-
-    ctx.links.push((dest.clone(), rect));
-}
-
-fn to_pdf_line_cap(cap: LineCap) -> LineCapStyle {
-    match cap {
-        LineCap::Butt => LineCapStyle::ButtCap,
-        LineCap::Round => LineCapStyle::RoundCap,
-        LineCap::Square => LineCapStyle::ProjectingSquareCap,
-    }
-}
-
-fn to_pdf_line_join(join: LineJoin) -> LineJoinStyle {
-    match join {
-        LineJoin::Miter => LineJoinStyle::MiterJoin,
-        LineJoin::Round => LineJoinStyle::RoundJoin,
-        LineJoin::Bevel => LineJoinStyle::BevelJoin,
-    }
-}
-
-/// The error when there is a tofu glyph.
-#[cold]
-fn tofu(text: &TextItemView, glyph: &Glyph) -> SourceDiagnostic {
-    error!(
-        glyph.span.0,
-        "the text {} could not be displayed with any font",
-        text.glyph_text(glyph).repr(),
-    )
-}
diff --git a/crates/typst-pdf/src/convert.rs b/crates/typst-pdf/src/convert.rs
new file mode 100644
index 000000000..f5ca31730
--- /dev/null
+++ b/crates/typst-pdf/src/convert.rs
@@ -0,0 +1,661 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::num::NonZeroU64;
+
+use ecow::{eco_format, EcoVec};
+use krilla::annotation::Annotation;
+use krilla::configure::{Configuration, ValidationError, Validator};
+use krilla::destination::{NamedDestination, XyzDestination};
+use krilla::embed::EmbedError;
+use krilla::error::KrillaError;
+use krilla::geom::PathBuilder;
+use krilla::page::{PageLabel, PageSettings};
+use krilla::surface::Surface;
+use krilla::{Document, SerializeSettings};
+use krilla_svg::render_svg_glyph;
+use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
+use typst_library::foundations::NativeElement;
+use typst_library::introspection::Location;
+use typst_library::layout::{
+    Abs, Frame, FrameItem, GroupItem, PagedDocument, Size, Transform,
+};
+use typst_library::model::HeadingElem;
+use typst_library::text::{Font, Lang};
+use typst_library::visualize::{Geometry, Paint};
+use typst_syntax::Span;
+
+use crate::embed::embed_files;
+use crate::image::handle_image;
+use crate::link::handle_link;
+use crate::metadata::build_metadata;
+use crate::outline::build_outline;
+use crate::page::PageLabelExt;
+use crate::shape::handle_shape;
+use crate::text::handle_text;
+use crate::util::{convert_path, display_font, AbsExt, TransformExt};
+use crate::PdfOptions;
+
+#[typst_macros::time(name = "convert document")]
+pub fn convert(
+    typst_document: &PagedDocument,
+    options: &PdfOptions,
+) -> SourceResult<Vec<u8>> {
+    let settings = SerializeSettings {
+        compress_content_streams: true,
+        no_device_cs: true,
+        ascii_compatible: false,
+        xmp_metadata: true,
+        cmyk_profile: None,
+        configuration: options.standards.config,
+        enable_tagging: false,
+        render_svg_glyph_fn: render_svg_glyph,
+    };
+
+    let mut document = Document::new_with(settings);
+    let page_index_converter = PageIndexConverter::new(typst_document, options);
+    let named_destinations =
+        collect_named_destinations(typst_document, &page_index_converter);
+    let mut gc = GlobalContext::new(
+        typst_document,
+        options,
+        named_destinations,
+        page_index_converter,
+    );
+
+    convert_pages(&mut gc, &mut document)?;
+    embed_files(typst_document, &mut document)?;
+
+    document.set_outline(build_outline(&gc));
+    document.set_metadata(build_metadata(&gc));
+
+    finish(document, gc, options.standards.config)
+}
+
+fn convert_pages(gc: &mut GlobalContext, document: &mut Document) -> SourceResult<()> {
+    for (i, typst_page) in gc.document.pages.iter().enumerate() {
+        if gc.page_index_converter.pdf_page_index(i).is_none() {
+            // Don't export this page.
+            continue;
+        } else {
+            let mut settings = PageSettings::new(
+                typst_page.frame.width().to_f32(),
+                typst_page.frame.height().to_f32(),
+            );
+
+            if let Some(label) = typst_page
+                .numbering
+                .as_ref()
+                .and_then(|num| PageLabel::generate(num, typst_page.number))
+                .or_else(|| {
+                    // When some pages were ignored from export, we show a page label with
+                    // the correct real (not logical) page number.
+                    // This is for consistency with normal output when pages have no numbering
+                    // and all are exported: the final PDF page numbers always correspond to
+                    // the real (not logical) page numbers. Here, the final PDF page number
+                    // will differ, but we can at least use labels to indicate what was
+                    // the corresponding real page number in the Typst document.
+                    gc.page_index_converter
+                        .has_skipped_pages()
+                        .then(|| PageLabel::arabic((i + 1) as u64))
+                })
+            {
+                settings = settings.with_page_label(label);
+            }
+
+            let mut page = document.start_page_with(settings);
+            let mut surface = page.surface();
+            let mut fc = FrameContext::new(typst_page.frame.size());
+
+            handle_frame(
+                &mut fc,
+                &typst_page.frame,
+                typst_page.fill_or_transparent(),
+                &mut surface,
+                gc,
+            )?;
+
+            surface.finish();
+
+            for annotation in fc.annotations {
+                page.add_annotation(annotation);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// A state allowing us to keep track of transforms and container sizes,
+/// which is mainly needed to resolve gradients and patterns correctly.
+#[derive(Debug, Clone)]
+pub(crate) struct State {
+    /// The current transform.
+    transform: Transform,
+    /// The transform of first hard frame in the hierarchy.
+    container_transform: Transform,
+    /// The size of the first hard frame in the hierarchy.
+    container_size: Size,
+}
+
+impl State {
+    /// Creates a new, clean state for a given `size`.
+    fn new(size: Size) -> Self {
+        Self {
+            transform: Transform::identity(),
+            container_transform: Transform::identity(),
+            container_size: size,
+        }
+    }
+
+    pub(crate) fn register_container(&mut self, size: Size) {
+        self.container_transform = self.transform;
+        self.container_size = size;
+    }
+
+    pub(crate) fn pre_concat(&mut self, transform: Transform) {
+        self.transform = self.transform.pre_concat(transform);
+    }
+
+    pub(crate) fn transform(&self) -> Transform {
+        self.transform
+    }
+
+    pub(crate) fn container_transform(&self) -> Transform {
+        self.container_transform
+    }
+
+    pub(crate) fn container_size(&self) -> Size {
+        self.container_size
+    }
+}
+
+/// Context needed for converting a single frame.
+pub(crate) struct FrameContext {
+    states: Vec<State>,
+    annotations: Vec<Annotation>,
+}
+
+impl FrameContext {
+    pub(crate) fn new(size: Size) -> Self {
+        Self {
+            states: vec![State::new(size)],
+            annotations: vec![],
+        }
+    }
+
+    pub(crate) fn push(&mut self) {
+        self.states.push(self.states.last().unwrap().clone());
+    }
+
+    pub(crate) fn pop(&mut self) {
+        self.states.pop();
+    }
+
+    pub(crate) fn state(&self) -> &State {
+        self.states.last().unwrap()
+    }
+
+    pub(crate) fn state_mut(&mut self) -> &mut State {
+        self.states.last_mut().unwrap()
+    }
+
+    pub(crate) fn push_annotation(&mut self, annotation: Annotation) {
+        self.annotations.push(annotation);
+    }
+}
+
+/// Globally needed context for converting a typst document.
+pub(crate) struct GlobalContext<'a> {
+    /// Cache the conversion between krilla and Typst fonts (forward and backward).
+    pub(crate) fonts_forward: HashMap<Font, krilla::text::Font>,
+    pub(crate) fonts_backward: HashMap<krilla::text::Font, Font>,
+    /// Mapping between images and their span.
+    // Note: In theory, the same image can have multiple spans
+    // if it appears in the document multiple times. We just store the
+    // first appearance, though.
+    pub(crate) image_to_spans: HashMap<krilla::image::Image, Span>,
+    /// The spans of all images that appear in the document. We use this so
+    /// we can give more accurate error messages.
+    pub(crate) image_spans: HashSet<Span>,
+    /// The document to convert.
+    pub(crate) document: &'a PagedDocument,
+    /// Options for PDF export.
+    pub(crate) options: &'a PdfOptions<'a>,
+    /// Mapping between locations in the document and named destinations.
+    pub(crate) loc_to_names: HashMap<Location, NamedDestination>,
+    /// The languages used throughout the document.
+    pub(crate) languages: BTreeMap<Lang, usize>,
+    pub(crate) page_index_converter: PageIndexConverter,
+}
+
+impl<'a> GlobalContext<'a> {
+    pub(crate) fn new(
+        document: &'a PagedDocument,
+        options: &'a PdfOptions,
+        loc_to_names: HashMap<Location, NamedDestination>,
+        page_index_converter: PageIndexConverter,
+    ) -> GlobalContext<'a> {
+        Self {
+            fonts_forward: HashMap::new(),
+            fonts_backward: HashMap::new(),
+            document,
+            options,
+            loc_to_names,
+            image_to_spans: HashMap::new(),
+            image_spans: HashSet::new(),
+            languages: BTreeMap::new(),
+            page_index_converter,
+        }
+    }
+}
+
+#[typst_macros::time(name = "handle page")]
+pub(crate) fn handle_frame(
+    fc: &mut FrameContext,
+    frame: &Frame,
+    fill: Option<Paint>,
+    surface: &mut Surface,
+    gc: &mut GlobalContext,
+) -> SourceResult<()> {
+    fc.push();
+
+    if frame.kind().is_hard() {
+        fc.state_mut().register_container(frame.size());
+    }
+
+    if let Some(fill) = fill {
+        let shape = Geometry::Rect(frame.size()).filled(fill);
+        handle_shape(fc, &shape, surface, gc, Span::detached())?;
+    }
+
+    for (point, item) in frame.items() {
+        fc.push();
+        fc.state_mut().pre_concat(Transform::translate(point.x, point.y));
+
+        match item {
+            FrameItem::Group(g) => handle_group(fc, g, surface, gc)?,
+            FrameItem::Text(t) => handle_text(fc, t, surface, gc)?,
+            FrameItem::Shape(s, span) => handle_shape(fc, s, surface, gc, *span)?,
+            FrameItem::Image(image, size, span) => {
+                handle_image(gc, fc, image, *size, surface, *span)?
+            }
+            FrameItem::Link(d, s) => handle_link(fc, gc, d, *s),
+            FrameItem::Tag(_) => {}
+        }
+
+        fc.pop();
+    }
+
+    fc.pop();
+
+    Ok(())
+}
+
+pub(crate) fn handle_group(
+    fc: &mut FrameContext,
+    group: &GroupItem,
+    surface: &mut Surface,
+    context: &mut GlobalContext,
+) -> SourceResult<()> {
+    fc.push();
+    fc.state_mut().pre_concat(group.transform);
+
+    let clip_path = group
+        .clip
+        .as_ref()
+        .and_then(|p| {
+            let mut builder = PathBuilder::new();
+            convert_path(p, &mut builder);
+            builder.finish()
+        })
+        .and_then(|p| p.transform(fc.state().transform.to_krilla()));
+
+    if let Some(clip_path) = &clip_path {
+        surface.push_clip_path(clip_path, &krilla::paint::FillRule::NonZero);
+    }
+
+    handle_frame(fc, &group.frame, None, surface, context)?;
+
+    if clip_path.is_some() {
+        surface.pop();
+    }
+
+    fc.pop();
+
+    Ok(())
+}
+
+#[typst_macros::time(name = "finish export")]
+/// Finish a krilla document and handle export errors.
+fn finish(
+    document: Document,
+    gc: GlobalContext,
+    configuration: Configuration,
+) -> SourceResult<Vec<u8>> {
+    let validator = configuration.validator();
+
+    match document.finish() {
+        Ok(r) => Ok(r),
+        Err(e) => match e {
+            KrillaError::Font(f, s) => {
+                let font_str = display_font(gc.fonts_backward.get(&f).unwrap());
+                bail!(
+                    Span::detached(),
+                    "failed to process font {font_str}: {s}";
+                    hint: "make sure the font is valid";
+                    hint: "the used font might be unsupported by Typst"
+                );
+            }
+            KrillaError::Validation(ve) => {
+                let errors = ve
+                    .iter()
+                    .map(|e| convert_error(&gc, validator, e))
+                    .collect::<EcoVec<_>>();
+                Err(errors)
+            }
+            KrillaError::Image(_, loc) => {
+                let span = to_span(loc);
+                bail!(span, "failed to process image");
+            }
+            KrillaError::SixteenBitImage(image, _) => {
+                let span = gc.image_to_spans.get(&image).unwrap();
+                bail!(
+                    *span, "16 bit images are not supported in this export mode";
+                    hint: "convert the image to 8 bit instead"
+                )
+            }
+        },
+    }
+}
+
+/// Converts a krilla error into a Typst error.
+fn convert_error(
+    gc: &GlobalContext,
+    validator: Validator,
+    error: &ValidationError,
+) -> SourceDiagnostic {
+    let prefix = eco_format!("{} error:", validator.as_str());
+    match error {
+        ValidationError::TooLongString => error!(
+            Span::detached(),
+            "{prefix} a PDF string is longer than 32767 characters";
+            hint: "ensure title and author names are short enough"
+        ),
+        // Should in theory never occur, as krilla always trims font names.
+        ValidationError::TooLongName => error!(
+            Span::detached(),
+            "{prefix} a PDF name is longer than 127 characters";
+            hint: "perhaps a font name is too long"
+        ),
+
+        ValidationError::TooLongArray => error!(
+            Span::detached(),
+            "{prefix} a PDF array is longer than 8191 elements";
+            hint: "this can happen if you have a very long text in a single line"
+        ),
+        ValidationError::TooLongDictionary => error!(
+            Span::detached(),
+            "{prefix} a PDF dictionary has more than 4095 entries";
+            hint: "try reducing the complexity of your document"
+        ),
+        ValidationError::TooLargeFloat => error!(
+            Span::detached(),
+            "{prefix} a PDF floating point number is larger than the allowed limit";
+            hint: "try exporting with a higher PDF version"
+        ),
+        ValidationError::TooManyIndirectObjects => error!(
+            Span::detached(),
+            "{prefix} the PDF has too many indirect objects";
+            hint: "reduce the size of your document"
+        ),
+        // Can only occur if we have 27+ nested clip paths
+        ValidationError::TooHighQNestingLevel => error!(
+            Span::detached(),
+            "{prefix} the PDF has too high q nesting";
+            hint: "reduce the number of nested containers"
+        ),
+        ValidationError::ContainsPostScript(loc) => error!(
+            to_span(*loc),
+            "{prefix} the PDF contains PostScript code";
+            hint: "conic gradients are not supported in this PDF standard"
+        ),
+        ValidationError::MissingCMYKProfile => error!(
+            Span::detached(),
+            "{prefix} the PDF is missing a CMYK profile";
+            hint: "CMYK colors are not yet supported in this export mode"
+        ),
+        ValidationError::ContainsNotDefGlyph(f, loc, text) => error!(
+            to_span(*loc),
+            "{prefix} the text '{text}' cannot be displayed using {}",
+            display_font(gc.fonts_backward.get(f).unwrap());
+            hint: "try using a different font"
+        ),
+        ValidationError::InvalidCodepointMapping(_, _, cp, loc) => {
+            if let Some(c) = cp.map(|c| eco_format!("{:#06x}", c as u32)) {
+                let msg = if loc.is_some() {
+                    "the PDF contains text with"
+                } else {
+                    "the text contains"
+                };
+                error!(to_span(*loc), "{prefix} {msg} the disallowed codepoint {c}")
+            } else {
+                // I think this code path is in theory unreachable,
+                // but just to be safe.
+                let msg = if loc.is_some() {
+                    "the PDF contains text with missing codepoints"
+                } else {
+                    "the text was not mapped to a code point"
+                };
+                error!(
+                    to_span(*loc),
+                    "{prefix} {msg}";
+                    hint: "for complex scripts like Arabic, it might not be \
+                           possible to produce a compliant document"
+                )
+            }
+        }
+        ValidationError::UnicodePrivateArea(_, _, c, loc) => {
+            let code_point = eco_format!("{:#06x}", *c as u32);
+            let msg = if loc.is_some() { "the PDF" } else { "the text" };
+            error!(
+                to_span(*loc),
+                "{prefix} {msg} contains the codepoint {code_point}";
+                hint: "codepoints from the Unicode private area are \
+                       forbidden in this export mode"
+            )
+        }
+        ValidationError::Transparency(loc) => {
+            let span = to_span(*loc);
+            let hint1 = "try exporting with a different standard that \
+                         supports transparency";
+            if loc.is_some() {
+                if gc.image_spans.contains(&span) {
+                    error!(
+                        span, "{prefix} the image contains transparency";
+                        hint: "{hint1}";
+                        hint: "or convert the image to a non-transparent one";
+                        hint: "you might have to convert SVGs into \
+                               non-transparent bitmap images"
+                    )
+                } else {
+                    error!(
+                        span, "{prefix} the used fill or stroke has transparency";
+                        hint: "{hint1}";
+                        hint: "or don't use colors with transparency in \
+                               this export mode"
+                    )
+                }
+            } else {
+                error!(
+                    span, "{prefix} the PDF contains transparency";
+                    hint: "{hint1}"
+                )
+            }
+        }
+        ValidationError::ImageInterpolation(loc) => {
+            let span = to_span(*loc);
+            if loc.is_some() {
+                error!(
+                    span, "{prefix} the image has smooth scaling";
+                    hint: "set the `scaling` attribute to `pixelated`"
+                )
+            } else {
+                error!(
+                    span, "{prefix} an image in the PDF has smooth scaling";
+                    hint: "set the `scaling` attribute of all images to `pixelated`"
+                )
+            }
+        }
+        ValidationError::EmbeddedFile(e, s) => {
+            // We always set the span for embedded files, so it cannot be detached.
+            let span = to_span(*s);
+            match e {
+                EmbedError::Existence => {
+                    error!(
+                        span, "{prefix} document contains an embedded file";
+                        hint: "embedded files are not supported in this export mode"
+                    )
+                }
+                EmbedError::MissingDate => {
+                    error!(
+                        span, "{prefix} document date is missing";
+                        hint: "the document must have a date when embedding files";
+                        hint: "`set document(date: none)` must not be used in this case"
+                    )
+                }
+                EmbedError::MissingDescription => {
+                    error!(span, "{prefix} the file description is missing")
+                }
+                EmbedError::MissingMimeType => {
+                    error!(span, "{prefix} the file mime type is missing")
+                }
+            }
+        }
+        // The below errors cannot occur yet, only once Typst supports full PDF/A
+        // and PDF/UA. But let's still add a message just to be on the safe side.
+        ValidationError::MissingAnnotationAltText => error!(
+            Span::detached(),
+            "{prefix} missing annotation alt text";
+            hint: "please report this as a bug"
+        ),
+        ValidationError::MissingAltText => error!(
+            Span::detached(),
+            "{prefix} missing alt text";
+            hint: "make sure your images and equations have alt text"
+        ),
+        ValidationError::NoDocumentLanguage => error!(
+            Span::detached(),
+            "{prefix} missing document language";
+            hint: "set the language of the document"
+        ),
+        // Needs to be set by typst-pdf.
+        ValidationError::MissingHeadingTitle => error!(
+            Span::detached(),
+            "{prefix} missing heading title";
+            hint: "please report this as a bug"
+        ),
+        ValidationError::MissingDocumentOutline => error!(
+            Span::detached(),
+            "{prefix} missing document outline";
+            hint: "please report this as a bug"
+        ),
+        ValidationError::MissingTagging => error!(
+            Span::detached(),
+            "{prefix} missing document tags";
+            hint: "please report this as a bug"
+        ),
+        ValidationError::NoDocumentTitle => error!(
+            Span::detached(),
+            "{prefix} missing document title";
+            hint: "set the title of the document"
+        ),
+        ValidationError::MissingDocumentDate => error!(
+            Span::detached(),
+            "{prefix} missing document date";
+            hint: "set the date of the document"
+        ),
+    }
+}
+
+/// Convert a krilla location to a span.
+fn to_span(loc: Option<krilla::surface::Location>) -> Span {
+    loc.map(|l| Span::from_raw(NonZeroU64::new(l).unwrap()))
+        .unwrap_or(Span::detached())
+}
+
+fn collect_named_destinations(
+    document: &PagedDocument,
+    pic: &PageIndexConverter,
+) -> HashMap<Location, NamedDestination> {
+    let mut locs_to_names = HashMap::new();
+
+    // Find all headings that have a label and are the first among other
+    // headings with the same label.
+    let matches: Vec<_> = {
+        let mut seen = HashSet::new();
+        document
+            .introspector
+            .query(&HeadingElem::elem().select())
+            .iter()
+            .filter_map(|elem| elem.location().zip(elem.label()))
+            .filter(|&(_, label)| seen.insert(label))
+            .collect()
+    };
+
+    for (loc, label) in matches {
+        let pos = document.introspector.position(loc);
+        let index = pos.page.get() - 1;
+        // We are subtracting 10 because the position of links e.g. to headings is always at the
+        // baseline and if you link directly to it, the text will not be visible
+        // because it is right above.
+        let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero());
+
+        // Only add named destination if page belonging to the position is exported.
+        if let Some(index) = pic.pdf_page_index(index) {
+            let named = NamedDestination::new(
+                label.resolve().to_string(),
+                XyzDestination::new(
+                    index,
+                    krilla::geom::Point::from_xy(pos.point.x.to_f32(), y.to_f32()),
+                ),
+            );
+            locs_to_names.insert(loc, named);
+        }
+    }
+
+    locs_to_names
+}
+
+pub(crate) struct PageIndexConverter {
+    page_indices: HashMap<usize, usize>,
+    skipped_pages: usize,
+}
+
+impl PageIndexConverter {
+    pub fn new(document: &PagedDocument, options: &PdfOptions) -> Self {
+        let mut page_indices = HashMap::new();
+        let mut skipped_pages = 0;
+
+        for i in 0..document.pages.len() {
+            if options
+                .page_ranges
+                .as_ref()
+                .is_some_and(|ranges| !ranges.includes_page_index(i))
+            {
+                skipped_pages += 1;
+            } else {
+                page_indices.insert(i, i - skipped_pages);
+            }
+        }
+
+        Self { page_indices, skipped_pages }
+    }
+
+    pub(crate) fn has_skipped_pages(&self) -> bool {
+        self.skipped_pages > 0
+    }
+
+    /// Get the PDF page index of a page index, if it's not excluded.
+    pub(crate) fn pdf_page_index(&self, page_index: usize) -> Option<usize> {
+        self.page_indices.get(&page_index).copied()
+    }
+}
diff --git a/crates/typst-pdf/src/embed.rs b/crates/typst-pdf/src/embed.rs
index 597638f4b..f0cd9060a 100644
--- a/crates/typst-pdf/src/embed.rs
+++ b/crates/typst-pdf/src/embed.rs
@@ -1,122 +1,122 @@
-use std::collections::BTreeMap;
+use std::sync::Arc;
 
-use ecow::EcoString;
-use pdf_writer::types::AssociationKind;
-use pdf_writer::{Filter, Finish, Name, Ref, Str, TextStr};
+use krilla::embed::{AssociationKind, EmbeddedFile};
+use krilla::Document;
 use typst_library::diag::{bail, SourceResult};
-use typst_library::foundations::{NativeElement, Packed, StyleChain};
+use typst_library::foundations::{NativeElement, StyleChain};
+use typst_library::layout::PagedDocument;
 use typst_library::pdf::{EmbedElem, EmbeddedFileRelationship};
 
-use crate::catalog::{document_date, pdf_date};
-use crate::{deflate, NameExt, PdfChunk, StrExt, WithGlobalRefs};
+pub(crate) fn embed_files(
+    typst_doc: &PagedDocument,
+    document: &mut Document,
+) -> SourceResult<()> {
+    let elements = typst_doc.introspector.query(&EmbedElem::elem().select());
 
-/// Query for all [`EmbedElem`] and write them and their file specifications.
-///
-/// This returns a map of embedding names and references so that we can later
-/// add them to the catalog's `/Names` dictionary.
-pub fn write_embedded_files(
-    ctx: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, BTreeMap<EcoString, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut embedded_files = BTreeMap::default();
-
-    let elements = ctx.document.introspector.query(&EmbedElem::elem().select());
     for elem in &elements {
-        if !ctx.options.standards.embedded_files {
-            // PDF/A-2 requires embedded files to be PDF/A-1 or PDF/A-2,
-            // which we don't currently check.
-            bail!(
-                elem.span(),
-                "file embeddings are not currently supported for PDF/A-2";
-                hint: "PDF/A-3 supports arbitrary embedded files"
-            );
-        }
-
         let embed = elem.to_packed::<EmbedElem>().unwrap();
-        if embed.path.derived.len() > Str::PDFA_LIMIT {
-            bail!(embed.span(), "embedded file path is too long");
-        }
-
-        let id = embed_file(ctx, &mut chunk, embed)?;
-        if embedded_files.insert(embed.path.derived.clone(), id).is_some() {
-            bail!(
-                elem.span(),
-                "duplicate embedded file for path `{}`", embed.path.derived;
-                hint: "embedded file paths must be unique",
-            );
-        }
-    }
-
-    Ok((chunk, embedded_files))
-}
-
-/// Write the embedded file stream and its file specification.
-fn embed_file(
-    ctx: &WithGlobalRefs,
-    chunk: &mut PdfChunk,
-    embed: &Packed<EmbedElem>,
-) -> SourceResult<Ref> {
-    let embedded_file_stream_ref = chunk.alloc.bump();
-    let file_spec_dict_ref = chunk.alloc.bump();
-
-    let data = embed.data.as_slice();
-    let compressed = deflate(data);
-
-    let mut embedded_file = chunk.embedded_file(embedded_file_stream_ref, &compressed);
-    embedded_file.filter(Filter::FlateDecode);
-
-    if let Some(mime_type) = embed.mime_type(StyleChain::default()) {
-        if mime_type.len() > Name::PDFA_LIMIT {
-            bail!(embed.span(), "embedded file MIME type is too long");
-        }
-        embedded_file.subtype(Name(mime_type.as_bytes()));
-    } else if ctx.options.standards.pdfa {
-        bail!(embed.span(), "embedded files must have a MIME type in PDF/A-3");
-    }
-
-    let mut params = embedded_file.params();
-    params.size(data.len() as i32);
-
-    let (date, tz) = document_date(ctx.document.info.date, ctx.options.timestamp);
-    if let Some(pdf_date) = date.and_then(|date| pdf_date(date, tz)) {
-        params.modification_date(pdf_date);
-    } else if ctx.options.standards.pdfa {
-        bail!(
-            embed.span(),
-            "the document must have a date when embedding files in PDF/A-3";
-            hint: "`set document(date: none)` must not be used in this case"
-        );
-    }
-
-    params.finish();
-    embedded_file.finish();
-
-    let mut file_spec = chunk.file_spec(file_spec_dict_ref);
-    file_spec.path(Str(embed.path.derived.as_bytes()));
-    file_spec.unic_file(TextStr(&embed.path.derived));
-    file_spec
-        .insert(Name(b"EF"))
-        .dict()
-        .pair(Name(b"F"), embedded_file_stream_ref)
-        .pair(Name(b"UF"), embedded_file_stream_ref);
-
-    if ctx.options.standards.pdfa {
-        // PDF 2.0, but ISO 19005-3 (PDF/A-3) Annex E allows it for PDF/A-3.
-        file_spec.association_kind(match embed.relationship(StyleChain::default()) {
-            Some(EmbeddedFileRelationship::Source) => AssociationKind::Source,
-            Some(EmbeddedFileRelationship::Data) => AssociationKind::Data,
-            Some(EmbeddedFileRelationship::Alternative) => AssociationKind::Alternative,
-            Some(EmbeddedFileRelationship::Supplement) => AssociationKind::Supplement,
+        let span = embed.span();
+        let derived_path = &embed.path.derived;
+        let path = derived_path.to_string();
+        let mime_type =
+            embed.mime_type(StyleChain::default()).clone().map(|s| s.to_string());
+        let description = embed
+            .description(StyleChain::default())
+            .clone()
+            .map(|s| s.to_string());
+        let association_kind = match embed.relationship(StyleChain::default()) {
             None => AssociationKind::Unspecified,
-        });
-    }
+            Some(e) => match e {
+                EmbeddedFileRelationship::Source => AssociationKind::Source,
+                EmbeddedFileRelationship::Data => AssociationKind::Data,
+                EmbeddedFileRelationship::Alternative => AssociationKind::Alternative,
+                EmbeddedFileRelationship::Supplement => AssociationKind::Supplement,
+            },
+        };
+        let data: Arc<dyn AsRef<[u8]> + Send + Sync> = Arc::new(embed.data.clone());
+        // TODO: update when new krilla version lands (https://github.com/LaurenzV/krilla/pull/203)
+        let compress = should_compress(&embed.data).unwrap_or(true);
 
-    if let Some(description) = embed.description(StyleChain::default()) {
-        if description.len() > Str::PDFA_LIMIT {
-            bail!(embed.span(), "embedded file description is too long");
+        let file = EmbeddedFile {
+            path,
+            mime_type,
+            description,
+            association_kind,
+            data: data.into(),
+            compress,
+            location: Some(span.into_raw().get()),
+        };
+
+        if document.embed_file(file).is_none() {
+            bail!(span, "attempted to embed file {derived_path} twice");
         }
-        file_spec.description(TextStr(description));
     }
 
-    Ok(file_spec_dict_ref)
+    Ok(())
+}
+
+fn should_compress(data: &[u8]) -> Option<bool> {
+    let ty = infer::get(data)?;
+    match ty.matcher_type() {
+        infer::MatcherType::App => None,
+        infer::MatcherType::Archive => match ty.mime_type() {
+            #[rustfmt::skip]
+            "application/zip"
+            | "application/vnd.rar"
+            | "application/gzip"
+            | "application/x-bzip2"
+            | "application/vnd.bzip3"
+            | "application/x-7z-compressed"
+            | "application/x-xz"
+            | "application/vnd.ms-cab-compressed"
+            | "application/vnd.debian.binary-package"
+            | "application/x-compress"
+            | "application/x-lzip"
+            | "application/x-rpm"
+            | "application/zstd"
+            | "application/x-lz4"
+            | "application/x-ole-storage" => Some(false),
+            _ => None,
+        },
+        infer::MatcherType::Audio => match ty.mime_type() {
+            #[rustfmt::skip]
+            "audio/mpeg"
+            | "audio/m4a"
+            | "audio/opus"
+            | "audio/ogg"
+            | "audio/x-flac"
+            | "audio/amr"
+            | "audio/aac"
+            | "audio/x-ape" => Some(false),
+            _ => None,
+        },
+        infer::MatcherType::Book => None,
+        infer::MatcherType::Doc => None,
+        infer::MatcherType::Font => None,
+        infer::MatcherType::Image => match ty.mime_type() {
+            #[rustfmt::skip]
+            "image/jpeg"
+            | "image/jp2"
+            | "image/png"
+            | "image/webp"
+            | "image/vnd.ms-photo"
+            | "image/heif"
+            | "image/avif"
+            | "image/jxl"
+            | "image/vnd.djvu" => None,
+            _ => None,
+        },
+        infer::MatcherType::Text => None,
+        infer::MatcherType::Video => match ty.mime_type() {
+            #[rustfmt::skip]
+            "video/mp4"
+            | "video/x-m4v"
+            | "video/x-matroska"
+            | "video/webm"
+            | "video/quicktime"
+            | "video/x-flv" => Some(false),
+            _ => None,
+        },
+        infer::MatcherType::Custom => None,
+    }
 }
diff --git a/crates/typst-pdf/src/extg.rs b/crates/typst-pdf/src/extg.rs
deleted file mode 100644
index 06617d8d2..000000000
--- a/crates/typst-pdf/src/extg.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::collections::HashMap;
-
-use pdf_writer::Ref;
-use typst_library::diag::SourceResult;
-
-use crate::{PdfChunk, WithGlobalRefs};
-
-/// A PDF external graphics state.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub struct ExtGState {
-    // In the range 0-255, needs to be divided before being written into the graphics state!
-    pub stroke_opacity: u8,
-    // In the range 0-255, needs to be divided before being written into the graphics state!
-    pub fill_opacity: u8,
-}
-
-impl Default for ExtGState {
-    fn default() -> Self {
-        Self { stroke_opacity: 255, fill_opacity: 255 }
-    }
-}
-
-impl ExtGState {
-    pub fn uses_opacities(&self) -> bool {
-        self.stroke_opacity != 255 || self.fill_opacity != 255
-    }
-}
-
-/// Embed all used external graphics states into the PDF.
-pub fn write_graphic_states(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<ExtGState, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = HashMap::new();
-    context.resources.traverse(&mut |resources| {
-        for external_gs in resources.ext_gs.items() {
-            if out.contains_key(external_gs) {
-                continue;
-            }
-
-            let id = chunk.alloc();
-            out.insert(*external_gs, id);
-            chunk
-                .ext_graphics(id)
-                .non_stroking_alpha(external_gs.fill_opacity as f32 / 255.0)
-                .stroking_alpha(external_gs.stroke_opacity as f32 / 255.0);
-        }
-
-        Ok(())
-    })?;
-
-    Ok((chunk, out))
-}
diff --git a/crates/typst-pdf/src/font.rs b/crates/typst-pdf/src/font.rs
deleted file mode 100644
index f2df2ac92..000000000
--- a/crates/typst-pdf/src/font.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
-use std::sync::Arc;
-
-use ecow::{eco_format, EcoString};
-use pdf_writer::types::{CidFontType, FontFlags, SystemInfo, UnicodeCmap};
-use pdf_writer::writers::{FontDescriptor, WMode};
-use pdf_writer::{Chunk, Filter, Finish, Name, Rect, Ref, Str};
-use subsetter::GlyphRemapper;
-use ttf_parser::{name_id, GlyphId, Tag};
-use typst_library::diag::{At, SourceResult};
-use typst_library::text::Font;
-use typst_syntax::Span;
-use typst_utils::SliceExt;
-
-use crate::{deflate, EmExt, NameExt, PdfChunk, WithGlobalRefs};
-
-const CFF: Tag = Tag::from_bytes(b"CFF ");
-const CFF2: Tag = Tag::from_bytes(b"CFF2");
-
-const SUBSET_TAG_LEN: usize = 6;
-const IDENTITY_H: &str = "Identity-H";
-
-pub(crate) const CMAP_NAME: Name = Name(b"Custom");
-pub(crate) const SYSTEM_INFO: SystemInfo = SystemInfo {
-    registry: Str(b"Adobe"),
-    ordering: Str(b"Identity"),
-    supplement: 0,
-};
-
-/// Embed all used fonts into the PDF.
-#[typst_macros::time(name = "write fonts")]
-pub fn write_fonts(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<Font, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = HashMap::new();
-    context.resources.traverse(&mut |resources| {
-        for font in resources.fonts.items() {
-            if out.contains_key(font) {
-                continue;
-            }
-
-            let type0_ref = chunk.alloc();
-            let cid_ref = chunk.alloc();
-            let descriptor_ref = chunk.alloc();
-            let cmap_ref = chunk.alloc();
-            let data_ref = chunk.alloc();
-            out.insert(font.clone(), type0_ref);
-
-            let glyph_set = resources.glyph_sets.get(font).unwrap();
-            let glyph_remapper = resources.glyph_remappers.get(font).unwrap();
-            let ttf = font.ttf();
-
-            // Do we have a TrueType or CFF font?
-            //
-            // FIXME: CFF2 must be handled differently and requires PDF 2.0
-            // (or we have to convert it to CFF).
-            let is_cff = ttf
-                .raw_face()
-                .table(CFF)
-                .or_else(|| ttf.raw_face().table(CFF2))
-                .is_some();
-
-            let base_font = base_font_name(font, glyph_set);
-            let base_font_type0 = if is_cff {
-                eco_format!("{base_font}-{IDENTITY_H}")
-            } else {
-                base_font.clone()
-            };
-
-            // Write the base font object referencing the CID font.
-            chunk
-                .type0_font(type0_ref)
-                .base_font(Name(base_font_type0.as_bytes()))
-                .encoding_predefined(Name(IDENTITY_H.as_bytes()))
-                .descendant_font(cid_ref)
-                .to_unicode(cmap_ref);
-
-            // Write the CID font referencing the font descriptor.
-            let mut cid = chunk.cid_font(cid_ref);
-            cid.subtype(if is_cff { CidFontType::Type0 } else { CidFontType::Type2 });
-            cid.base_font(Name(base_font.as_bytes()));
-            cid.system_info(SYSTEM_INFO);
-            cid.font_descriptor(descriptor_ref);
-            cid.default_width(0.0);
-            if !is_cff {
-                cid.cid_to_gid_map_predefined(Name(b"Identity"));
-            }
-
-            // Extract the widths of all glyphs.
-            // `remapped_gids` returns an iterator over the old GIDs in their new sorted
-            // order, so we can append the widths as is.
-            let widths = glyph_remapper
-                .remapped_gids()
-                .map(|gid| {
-                    let width = ttf.glyph_hor_advance(GlyphId(gid)).unwrap_or(0);
-                    font.to_em(width).to_font_units()
-                })
-                .collect::<Vec<_>>();
-
-            // Write all non-zero glyph widths.
-            let mut first = 0;
-            let mut width_writer = cid.widths();
-            for (w, group) in widths.group_by_key(|&w| w) {
-                let end = first + group.len();
-                if w != 0.0 {
-                    let last = end - 1;
-                    width_writer.same(first as u16, last as u16, w);
-                }
-                first = end;
-            }
-
-            width_writer.finish();
-            cid.finish();
-
-            // Write the /ToUnicode character map, which maps glyph ids back to
-            // unicode codepoints to enable copying out of the PDF.
-            let cmap = create_cmap(glyph_set, glyph_remapper);
-            chunk
-                .cmap(cmap_ref, &cmap)
-                .writing_mode(WMode::Horizontal)
-                .filter(Filter::FlateDecode);
-
-            let subset = subset_font(font, glyph_remapper)
-                .map_err(|err| {
-                    let postscript_name = font.find_name(name_id::POST_SCRIPT_NAME);
-                    let name = postscript_name.as_deref().unwrap_or(&font.info().family);
-                    eco_format!("failed to process font {name}: {err}")
-                })
-                .at(Span::detached())?;
-
-            let mut stream = chunk.stream(data_ref, &subset);
-            stream.filter(Filter::FlateDecode);
-            if is_cff {
-                stream.pair(Name(b"Subtype"), Name(b"CIDFontType0C"));
-            }
-            stream.finish();
-
-            let mut font_descriptor =
-                write_font_descriptor(&mut chunk, descriptor_ref, font, &base_font);
-            if is_cff {
-                font_descriptor.font_file3(data_ref);
-            } else {
-                font_descriptor.font_file2(data_ref);
-            }
-        }
-
-        Ok(())
-    })?;
-
-    Ok((chunk, out))
-}
-
-/// Writes a FontDescriptor dictionary.
-pub fn write_font_descriptor<'a>(
-    pdf: &'a mut Chunk,
-    descriptor_ref: Ref,
-    font: &'a Font,
-    base_font: &str,
-) -> FontDescriptor<'a> {
-    let ttf = font.ttf();
-    let metrics = font.metrics();
-    let serif = font
-        .find_name(name_id::POST_SCRIPT_NAME)
-        .is_some_and(|name| name.contains("Serif"));
-
-    let mut flags = FontFlags::empty();
-    flags.set(FontFlags::SERIF, serif);
-    flags.set(FontFlags::FIXED_PITCH, ttf.is_monospaced());
-    flags.set(FontFlags::ITALIC, ttf.is_italic());
-    flags.insert(FontFlags::SYMBOLIC);
-    flags.insert(FontFlags::SMALL_CAP);
-
-    let global_bbox = ttf.global_bounding_box();
-    let bbox = Rect::new(
-        font.to_em(global_bbox.x_min).to_font_units(),
-        font.to_em(global_bbox.y_min).to_font_units(),
-        font.to_em(global_bbox.x_max).to_font_units(),
-        font.to_em(global_bbox.y_max).to_font_units(),
-    );
-
-    let italic_angle = ttf.italic_angle();
-    let ascender = metrics.ascender.to_font_units();
-    let descender = metrics.descender.to_font_units();
-    let cap_height = metrics.cap_height.to_font_units();
-    let stem_v = 10.0 + 0.244 * (f32::from(ttf.weight().to_number()) - 50.0);
-
-    // Write the font descriptor (contains metrics about the font).
-    let mut font_descriptor = pdf.font_descriptor(descriptor_ref);
-    font_descriptor
-        .name(Name(base_font.as_bytes()))
-        .flags(flags)
-        .bbox(bbox)
-        .italic_angle(italic_angle)
-        .ascent(ascender)
-        .descent(descender)
-        .cap_height(cap_height)
-        .stem_v(stem_v);
-
-    font_descriptor
-}
-
-/// Subset a font to the given glyphs.
-///
-/// - For a font with TrueType outlines, this produces the whole OpenType font.
-/// - For a font with CFF outlines, this produces just the CFF font program.
-///
-/// In both cases, this returns the already compressed data.
-#[comemo::memoize]
-#[typst_macros::time(name = "subset font")]
-fn subset_font(
-    font: &Font,
-    glyph_remapper: &GlyphRemapper,
-) -> Result<Arc<Vec<u8>>, subsetter::Error> {
-    let data = font.data();
-    let subset = subsetter::subset(data, font.index(), glyph_remapper)?;
-    let mut data = subset.as_ref();
-
-    // Extract the standalone CFF font program if applicable.
-    let raw = ttf_parser::RawFace::parse(data, 0).unwrap();
-    if let Some(cff) = raw.table(CFF) {
-        data = cff;
-    }
-
-    Ok(Arc::new(deflate(data)))
-}
-
-/// Creates the base font name for a font with a specific glyph subset.
-/// Consists of a subset tag and the PostScript name of the font.
-///
-/// Returns a string of length maximum 116, so that even with `-Identity-H`
-/// added it does not exceed the maximum PDF/A name length of 127.
-pub(crate) fn base_font_name<T: Hash>(font: &Font, glyphs: &T) -> EcoString {
-    const MAX_LEN: usize = Name::PDFA_LIMIT - REST_LEN;
-    const REST_LEN: usize = SUBSET_TAG_LEN + 1 + 1 + IDENTITY_H.len();
-
-    let postscript_name = font.find_name(name_id::POST_SCRIPT_NAME);
-    let name = postscript_name.as_deref().unwrap_or("unknown");
-    let trimmed = &name[..name.len().min(MAX_LEN)];
-
-    // Hash the full name (we might have trimmed) and the glyphs to produce
-    // a fairly unique subset tag.
-    let subset_tag = subset_tag(&(name, glyphs));
-
-    eco_format!("{subset_tag}+{trimmed}")
-}
-
-/// Produce a unique 6 letter tag for a glyph set.
-pub(crate) fn subset_tag<T: Hash>(glyphs: &T) -> EcoString {
-    const BASE: u128 = 26;
-    let mut hash = typst_utils::hash128(&glyphs);
-    let mut letter = [b'A'; SUBSET_TAG_LEN];
-    for l in letter.iter_mut() {
-        *l = b'A' + (hash % BASE) as u8;
-        hash /= BASE;
-    }
-    std::str::from_utf8(&letter).unwrap().into()
-}
-
-/// Create a compressed `/ToUnicode` CMap.
-#[comemo::memoize]
-#[typst_macros::time(name = "create cmap")]
-fn create_cmap(
-    glyph_set: &BTreeMap<u16, EcoString>,
-    glyph_remapper: &GlyphRemapper,
-) -> Arc<Vec<u8>> {
-    // Produce a reverse mapping from glyphs' CIDs to unicode strings.
-    let mut cmap = UnicodeCmap::new(CMAP_NAME, SYSTEM_INFO);
-    for (&g, text) in glyph_set.iter() {
-        // See commend in `write_normal_text` for why we can choose the CID this way.
-        let cid = glyph_remapper.get(g).unwrap();
-        if !text.is_empty() {
-            cmap.pair_with_multiple(cid, text.chars());
-        }
-    }
-    Arc::new(deflate(&cmap.finish()))
-}
diff --git a/crates/typst-pdf/src/gradient.rs b/crates/typst-pdf/src/gradient.rs
deleted file mode 100644
index 6cd4c1ae8..000000000
--- a/crates/typst-pdf/src/gradient.rs
+++ /dev/null
@@ -1,512 +0,0 @@
-use std::collections::HashMap;
-use std::f32::consts::{PI, TAU};
-use std::sync::Arc;
-
-use ecow::eco_format;
-use pdf_writer::types::{ColorSpaceOperand, FunctionShadingType};
-use pdf_writer::writers::StreamShadingType;
-use pdf_writer::{Filter, Finish, Name, Ref};
-use typst_library::diag::SourceResult;
-use typst_library::layout::{Abs, Angle, Point, Quadrant, Ratio, Transform};
-use typst_library::visualize::{
-    Color, ColorSpace, Gradient, RatioOrAngle, RelativeTo, WeightedColor,
-};
-use typst_utils::Numeric;
-
-use crate::color::{
-    self, check_cmyk_allowed, ColorSpaceExt, PaintEncode, QuantizedColor,
-};
-use crate::{content, deflate, transform_to_array, AbsExt, PdfChunk, WithGlobalRefs};
-
-/// A unique-transform-aspect-ratio combination that will be encoded into the
-/// PDF.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PdfGradient {
-    /// The transform to apply to the gradient.
-    pub transform: Transform,
-    /// The aspect ratio of the gradient.
-    /// Required for aspect ratio correction.
-    pub aspect_ratio: Ratio,
-    /// The gradient.
-    pub gradient: Gradient,
-    /// The corrected angle of the gradient.
-    pub angle: Angle,
-}
-
-/// Writes the actual gradients (shading patterns) to the PDF.
-/// This is performed once after writing all pages.
-pub fn write_gradients(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<PdfGradient, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = HashMap::new();
-    context.resources.traverse(&mut |resources| {
-        for pdf_gradient in resources.gradients.items() {
-            if out.contains_key(pdf_gradient) {
-                continue;
-            }
-
-            let shading = chunk.alloc();
-            out.insert(pdf_gradient.clone(), shading);
-
-            let PdfGradient { transform, aspect_ratio, gradient, angle } = pdf_gradient;
-
-            let color_space = if gradient.space().hue_index().is_some() {
-                ColorSpace::Oklab
-            } else {
-                gradient.space()
-            };
-
-            if color_space == ColorSpace::Cmyk {
-                check_cmyk_allowed(context.options)?;
-            }
-
-            let mut shading_pattern = match &gradient {
-                Gradient::Linear(_) => {
-                    let shading_function =
-                        shading_function(gradient, &mut chunk, color_space);
-                    let mut shading_pattern = chunk.chunk.shading_pattern(shading);
-                    let mut shading = shading_pattern.function_shading();
-                    shading.shading_type(FunctionShadingType::Axial);
-
-                    color::write(
-                        color_space,
-                        shading.color_space(),
-                        &context.globals.color_functions,
-                    );
-
-                    let (mut sin, mut cos) = (angle.sin(), angle.cos());
-
-                    // Scale to edges of unit square.
-                    let factor = cos.abs() + sin.abs();
-                    sin *= factor;
-                    cos *= factor;
-
-                    let (x1, y1, x2, y2): (f64, f64, f64, f64) = match angle.quadrant() {
-                        Quadrant::First => (0.0, 0.0, cos, sin),
-                        Quadrant::Second => (1.0, 0.0, cos + 1.0, sin),
-                        Quadrant::Third => (1.0, 1.0, cos + 1.0, sin + 1.0),
-                        Quadrant::Fourth => (0.0, 1.0, cos, sin + 1.0),
-                    };
-
-                    shading
-                        .anti_alias(gradient.anti_alias())
-                        .function(shading_function)
-                        .coords([x1 as f32, y1 as f32, x2 as f32, y2 as f32])
-                        .extend([true; 2]);
-
-                    shading.finish();
-
-                    shading_pattern
-                }
-                Gradient::Radial(radial) => {
-                    let shading_function =
-                        shading_function(gradient, &mut chunk, color_space_of(gradient));
-                    let mut shading_pattern = chunk.chunk.shading_pattern(shading);
-                    let mut shading = shading_pattern.function_shading();
-                    shading.shading_type(FunctionShadingType::Radial);
-
-                    color::write(
-                        color_space,
-                        shading.color_space(),
-                        &context.globals.color_functions,
-                    );
-
-                    shading
-                        .anti_alias(gradient.anti_alias())
-                        .function(shading_function)
-                        .coords([
-                            radial.focal_center.x.get() as f32,
-                            radial.focal_center.y.get() as f32,
-                            radial.focal_radius.get() as f32,
-                            radial.center.x.get() as f32,
-                            radial.center.y.get() as f32,
-                            radial.radius.get() as f32,
-                        ])
-                        .extend([true; 2]);
-
-                    shading.finish();
-
-                    shading_pattern
-                }
-                Gradient::Conic(_) => {
-                    let vertices = compute_vertex_stream(gradient, *aspect_ratio);
-
-                    let stream_shading_id = chunk.alloc();
-                    let mut stream_shading =
-                        chunk.chunk.stream_shading(stream_shading_id, &vertices);
-
-                    color::write(
-                        color_space,
-                        stream_shading.color_space(),
-                        &context.globals.color_functions,
-                    );
-
-                    let range = color_space.range();
-                    stream_shading
-                        .bits_per_coordinate(16)
-                        .bits_per_component(16)
-                        .bits_per_flag(8)
-                        .shading_type(StreamShadingType::CoonsPatch)
-                        .decode(
-                            [0.0, 1.0, 0.0, 1.0].into_iter().chain(range.iter().copied()),
-                        )
-                        .anti_alias(gradient.anti_alias())
-                        .filter(Filter::FlateDecode);
-
-                    stream_shading.finish();
-
-                    let mut shading_pattern = chunk.shading_pattern(shading);
-                    shading_pattern.shading_ref(stream_shading_id);
-                    shading_pattern
-                }
-            };
-
-            shading_pattern.matrix(transform_to_array(*transform));
-        }
-
-        Ok(())
-    })?;
-
-    Ok((chunk, out))
-}
-
-/// Writes an exponential or stitched function that expresses the gradient.
-fn shading_function(
-    gradient: &Gradient,
-    chunk: &mut PdfChunk,
-    color_space: ColorSpace,
-) -> Ref {
-    let function = chunk.alloc();
-    let mut functions = vec![];
-    let mut bounds = vec![];
-    let mut encode = vec![];
-
-    // Create the individual gradient functions for each pair of stops.
-    for window in gradient.stops_ref().windows(2) {
-        let (first, second) = (window[0], window[1]);
-
-        // If we have a hue index or are using Oklab, we will create several
-        // stops in-between to make the gradient smoother without interpolation
-        // issues with native color spaces.
-        let mut last_c = first.0;
-        if gradient.space().hue_index().is_some() {
-            for i in 0..=32 {
-                let t = i as f64 / 32.0;
-                let real_t = first.1.get() * (1.0 - t) + second.1.get() * t;
-
-                let c = gradient.sample(RatioOrAngle::Ratio(Ratio::new(real_t)));
-                functions.push(single_gradient(chunk, last_c, c, color_space));
-                bounds.push(real_t as f32);
-                encode.extend([0.0, 1.0]);
-                last_c = c;
-            }
-        }
-
-        bounds.push(second.1.get() as f32);
-        functions.push(single_gradient(chunk, first.0, second.0, color_space));
-        encode.extend([0.0, 1.0]);
-    }
-
-    // Special case for gradients with only two stops.
-    if functions.len() == 1 {
-        return functions[0];
-    }
-
-    // Remove the last bound, since it's not needed for the stitching function.
-    bounds.pop();
-
-    // Create the stitching function.
-    chunk
-        .stitching_function(function)
-        .domain([0.0, 1.0])
-        .range(color_space.range().iter().copied())
-        .functions(functions)
-        .bounds(bounds)
-        .encode(encode);
-
-    function
-}
-
-/// Writes an exponential function that expresses a single segment (between two
-/// stops) of a gradient.
-fn single_gradient(
-    chunk: &mut PdfChunk,
-    first_color: Color,
-    second_color: Color,
-    color_space: ColorSpace,
-) -> Ref {
-    let reference = chunk.alloc();
-    chunk
-        .exponential_function(reference)
-        .range(color_space.range().iter().copied())
-        .c0(color_space.convert(first_color))
-        .c1(color_space.convert(second_color))
-        .domain([0.0, 1.0])
-        .n(1.0);
-
-    reference
-}
-
-impl PaintEncode for Gradient {
-    fn set_as_fill(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        ctx.reset_fill_color_space();
-
-        let index = register_gradient(ctx, self, on_text, transforms);
-        let id = eco_format!("Gr{index}");
-        let name = Name(id.as_bytes());
-
-        ctx.content.set_fill_color_space(ColorSpaceOperand::Pattern);
-        ctx.content.set_fill_pattern(None, name);
-        Ok(())
-    }
-
-    fn set_as_stroke(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        ctx.reset_stroke_color_space();
-
-        let index = register_gradient(ctx, self, on_text, transforms);
-        let id = eco_format!("Gr{index}");
-        let name = Name(id.as_bytes());
-
-        ctx.content.set_stroke_color_space(ColorSpaceOperand::Pattern);
-        ctx.content.set_stroke_pattern(None, name);
-        Ok(())
-    }
-}
-
-/// Deduplicates a gradient to a named PDF resource.
-fn register_gradient(
-    ctx: &mut content::Builder,
-    gradient: &Gradient,
-    on_text: bool,
-    mut transforms: content::Transforms,
-) -> usize {
-    // Edge cases for strokes.
-    if transforms.size.x.is_zero() {
-        transforms.size.x = Abs::pt(1.0);
-    }
-
-    if transforms.size.y.is_zero() {
-        transforms.size.y = Abs::pt(1.0);
-    }
-    let size = match gradient.unwrap_relative(on_text) {
-        RelativeTo::Self_ => transforms.size,
-        RelativeTo::Parent => transforms.container_size,
-    };
-
-    let (offset_x, offset_y) = match gradient {
-        Gradient::Conic(conic) => (
-            -size.x * (1.0 - conic.center.x.get() / 2.0) / 2.0,
-            -size.y * (1.0 - conic.center.y.get() / 2.0) / 2.0,
-        ),
-        _ => (Abs::zero(), Abs::zero()),
-    };
-
-    let rotation = gradient.angle().unwrap_or_else(Angle::zero);
-
-    let transform = match gradient.unwrap_relative(on_text) {
-        RelativeTo::Self_ => transforms.transform,
-        RelativeTo::Parent => transforms.container_transform,
-    };
-
-    let scale_offset = match gradient {
-        Gradient::Conic(_) => 4.0_f64,
-        _ => 1.0,
-    };
-
-    let pdf_gradient = PdfGradient {
-        aspect_ratio: size.aspect_ratio(),
-        transform: transform
-            .pre_concat(Transform::translate(
-                offset_x * scale_offset,
-                offset_y * scale_offset,
-            ))
-            .pre_concat(Transform::scale(
-                Ratio::new(size.x.to_pt() * scale_offset),
-                Ratio::new(size.y.to_pt() * scale_offset),
-            )),
-        gradient: gradient.clone(),
-        angle: Gradient::correct_aspect_ratio(rotation, size.aspect_ratio()),
-    };
-
-    ctx.resources.colors.mark_as_used(color_space_of(gradient));
-
-    ctx.resources.gradients.insert(pdf_gradient)
-}
-
-/// Writes a single Coons Patch as defined in the PDF specification
-/// to a binary vec.
-///
-/// Structure:
-///  - flag: `u8`
-///  - points: `[u16; 24]`
-///  - colors: `[u16; 4*N]` (N = number of components)
-fn write_patch(
-    target: &mut Vec<u8>,
-    t: f32,
-    t1: f32,
-    c0: &[u16],
-    c1: &[u16],
-    angle: Angle,
-) {
-    let theta = -TAU * t + angle.to_rad() as f32 + PI;
-    let theta1 = -TAU * t1 + angle.to_rad() as f32 + PI;
-
-    let (cp1, cp2) =
-        control_point(Point::new(Abs::pt(0.5), Abs::pt(0.5)), 0.5, theta, theta1);
-
-    // Push the flag
-    target.push(0);
-
-    let p1 =
-        [u16::quantize(0.5, [0.0, 1.0]).to_be(), u16::quantize(0.5, [0.0, 1.0]).to_be()];
-
-    let p2 = [
-        u16::quantize(theta.cos(), [-1.0, 1.0]).to_be(),
-        u16::quantize(theta.sin(), [-1.0, 1.0]).to_be(),
-    ];
-
-    let p3 = [
-        u16::quantize(theta1.cos(), [-1.0, 1.0]).to_be(),
-        u16::quantize(theta1.sin(), [-1.0, 1.0]).to_be(),
-    ];
-
-    let cp1 = [
-        u16::quantize(cp1.x.to_f32(), [0.0, 1.0]).to_be(),
-        u16::quantize(cp1.y.to_f32(), [0.0, 1.0]).to_be(),
-    ];
-
-    let cp2 = [
-        u16::quantize(cp2.x.to_f32(), [0.0, 1.0]).to_be(),
-        u16::quantize(cp2.y.to_f32(), [0.0, 1.0]).to_be(),
-    ];
-
-    // Push the points
-    target.extend_from_slice(bytemuck::cast_slice(&[
-        p1, p1, p2, p2, cp1, cp2, p3, p3, p1, p1, p1, p1,
-    ]));
-
-    // Push the colors.
-    let colors = [c0, c0, c1, c1]
-        .into_iter()
-        .flat_map(|c| c.iter().copied().map(u16::to_be_bytes))
-        .flatten();
-
-    target.extend(colors);
-}
-
-fn control_point(c: Point, r: f32, angle_start: f32, angle_end: f32) -> (Point, Point) {
-    let n = (TAU / (angle_end - angle_start)).abs();
-    let f = ((angle_end - angle_start) / n).tan() * 4.0 / 3.0;
-
-    let p1 = c + Point::new(
-        Abs::pt((r * angle_start.cos() - f * r * angle_start.sin()) as f64),
-        Abs::pt((r * angle_start.sin() + f * r * angle_start.cos()) as f64),
-    );
-
-    let p2 = c + Point::new(
-        Abs::pt((r * angle_end.cos() + f * r * angle_end.sin()) as f64),
-        Abs::pt((r * angle_end.sin() - f * r * angle_end.cos()) as f64),
-    );
-
-    (p1, p2)
-}
-
-#[comemo::memoize]
-fn compute_vertex_stream(gradient: &Gradient, aspect_ratio: Ratio) -> Arc<Vec<u8>> {
-    let Gradient::Conic(conic) = gradient else { unreachable!() };
-
-    // Generated vertices for the Coons patches
-    let mut vertices = Vec::new();
-
-    // Correct the gradient's angle
-    let angle = Gradient::correct_aspect_ratio(conic.angle, aspect_ratio);
-
-    for window in conic.stops.windows(2) {
-        let ((c0, t0), (c1, t1)) = (window[0], window[1]);
-
-        // Precision:
-        // - On an even color, insert a stop every 90deg
-        // - For a hue-based color space, insert 200 stops minimum
-        // - On any other, insert 20 stops minimum
-        let max_dt = if c0 == c1 {
-            0.25
-        } else if conic.space.hue_index().is_some() {
-            0.005
-        } else {
-            0.05
-        };
-        let encode_space = conic
-            .space
-            .hue_index()
-            .map(|_| ColorSpace::Oklab)
-            .unwrap_or(conic.space);
-        let mut t_x = t0.get();
-        let dt = (t1.get() - t0.get()).min(max_dt);
-
-        // Special casing for sharp gradients.
-        if t0 == t1 {
-            write_patch(
-                &mut vertices,
-                t0.get() as f32,
-                t1.get() as f32,
-                &encode_space.convert(c0),
-                &encode_space.convert(c1),
-                angle,
-            );
-            continue;
-        }
-
-        while t_x < t1.get() {
-            let t_next = (t_x + dt).min(t1.get());
-
-            // The current progress in the current window.
-            let t = |t| (t - t0.get()) / (t1.get() - t0.get());
-            let c = Color::mix_iter(
-                [WeightedColor::new(c0, 1.0 - t(t_x)), WeightedColor::new(c1, t(t_x))],
-                conic.space,
-            )
-            .unwrap();
-
-            let c_next = Color::mix_iter(
-                [
-                    WeightedColor::new(c0, 1.0 - t(t_next)),
-                    WeightedColor::new(c1, t(t_next)),
-                ],
-                conic.space,
-            )
-            .unwrap();
-
-            write_patch(
-                &mut vertices,
-                t_x as f32,
-                t_next as f32,
-                &encode_space.convert(c),
-                &encode_space.convert(c_next),
-                angle,
-            );
-
-            t_x = t_next;
-        }
-    }
-
-    Arc::new(deflate(&vertices))
-}
-
-fn color_space_of(gradient: &Gradient) -> ColorSpace {
-    if gradient.space().hue_index().is_some() {
-        ColorSpace::Oklab
-    } else {
-        gradient.space()
-    }
-}
diff --git a/crates/typst-pdf/src/image.rs b/crates/typst-pdf/src/image.rs
index fa326e3e0..93bdb1950 100644
--- a/crates/typst-pdf/src/image.rs
+++ b/crates/typst-pdf/src/image.rs
@@ -1,249 +1,244 @@
-use std::collections::HashMap;
-use std::io::Cursor;
+use std::hash::{Hash, Hasher};
+use std::sync::{Arc, OnceLock};
 
-use ecow::eco_format;
-use image::{DynamicImage, GenericImageView, Rgba};
-use pdf_writer::{Chunk, Filter, Finish, Ref};
-use typst_library::diag::{At, SourceResult, StrResult};
+use image::{DynamicImage, EncodableLayout, GenericImageView, Rgba};
+use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace};
+use krilla::surface::Surface;
+use krilla_svg::{SurfaceExt, SvgSettings};
+use typst_library::diag::{bail, SourceResult};
 use typst_library::foundations::Smart;
+use typst_library::layout::{Abs, Angle, Ratio, Size, Transform};
 use typst_library::visualize::{
-    ColorSpace, ExchangeFormat, Image, ImageKind, ImageScaling, RasterFormat,
-    RasterImage, SvgImage,
+    ExchangeFormat, Image, ImageKind, ImageScaling, RasterFormat, RasterImage,
 };
-use typst_utils::Deferred;
+use typst_syntax::Span;
 
-use crate::{color, deflate, PdfChunk, WithGlobalRefs};
+use crate::convert::{FrameContext, GlobalContext};
+use crate::util::{SizeExt, TransformExt};
 
-/// Embed all used images into the PDF.
-#[typst_macros::time(name = "write images")]
-pub fn write_images(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<Image, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = HashMap::new();
-    context.resources.traverse(&mut |resources| {
-        for (i, image) in resources.images.items().enumerate() {
-            if out.contains_key(image) {
-                continue;
+#[typst_macros::time(name = "handle image")]
+pub(crate) fn handle_image(
+    gc: &mut GlobalContext,
+    fc: &mut FrameContext,
+    image: &Image,
+    size: Size,
+    surface: &mut Surface,
+    span: Span,
+) -> SourceResult<()> {
+    surface.push_transform(&fc.state().transform().to_krilla());
+    surface.set_location(span.into_raw().get());
+
+    let interpolate = image.scaling() == Smart::Custom(ImageScaling::Smooth);
+
+    if let Some(alt) = image.alt() {
+        surface.start_alt_text(alt);
+    }
+
+    gc.image_spans.insert(span);
+
+    match image.kind() {
+        ImageKind::Raster(raster) => {
+            let (exif_transform, new_size) = exif_transform(raster, size);
+            surface.push_transform(&exif_transform.to_krilla());
+
+            let image = match convert_raster(raster.clone(), interpolate) {
+                None => bail!(span, "failed to process image"),
+                Some(i) => i,
+            };
+
+            if !gc.image_to_spans.contains_key(&image) {
+                gc.image_to_spans.insert(image.clone(), span);
             }
 
-            let (handle, span) = resources.deferred_images.get(&i).unwrap();
-            let encoded = handle.wait().as_ref().map_err(Clone::clone).at(*span)?;
-
-            match encoded {
-                EncodedImage::Raster {
-                    data,
-                    filter,
-                    color_space,
-                    bits_per_component,
-                    width,
-                    height,
-                    compressed_icc,
-                    alpha,
-                    interpolate,
-                } => {
-                    let image_ref = chunk.alloc();
-                    out.insert(image.clone(), image_ref);
-
-                    let mut image = chunk.chunk.image_xobject(image_ref, data);
-                    image.filter(*filter);
-                    image.width(*width as i32);
-                    image.height(*height as i32);
-                    image.bits_per_component(i32::from(*bits_per_component));
-                    image.interpolate(*interpolate);
-
-                    let mut icc_ref = None;
-                    let space = image.color_space();
-                    if compressed_icc.is_some() {
-                        let id = chunk.alloc.bump();
-                        space.icc_based(id);
-                        icc_ref = Some(id);
-                    } else {
-                        color::write(
-                            *color_space,
-                            space,
-                            &context.globals.color_functions,
-                        );
-                    }
-
-                    // Add a second gray-scale image containing the alpha values if
-                    // this image has an alpha channel.
-                    if let Some((alpha_data, alpha_filter)) = alpha {
-                        let mask_ref = chunk.alloc.bump();
-                        image.s_mask(mask_ref);
-                        image.finish();
-
-                        let mut mask = chunk.image_xobject(mask_ref, alpha_data);
-                        mask.filter(*alpha_filter);
-                        mask.width(*width as i32);
-                        mask.height(*height as i32);
-                        mask.color_space().device_gray();
-                        mask.bits_per_component(i32::from(*bits_per_component));
-                        mask.interpolate(*interpolate);
-                    } else {
-                        image.finish();
-                    }
-
-                    if let (Some(compressed_icc), Some(icc_ref)) =
-                        (compressed_icc, icc_ref)
-                    {
-                        let mut stream = chunk.icc_profile(icc_ref, compressed_icc);
-                        stream.filter(Filter::FlateDecode);
-                        match color_space {
-                            ColorSpace::Srgb => {
-                                stream.n(3);
-                                stream.alternate().srgb();
-                            }
-                            ColorSpace::D65Gray => {
-                                stream.n(1);
-                                stream.alternate().d65_gray();
-                            }
-                            _ => unimplemented!(),
-                        }
-                    }
-                }
-                EncodedImage::Svg(svg_chunk, id) => {
-                    let mut map = HashMap::new();
-                    svg_chunk.renumber_into(&mut chunk.chunk, |old| {
-                        *map.entry(old).or_insert_with(|| chunk.alloc.bump())
-                    });
-                    out.insert(image.clone(), map[id]);
-                }
-            }
+            surface.draw_image(image, new_size.to_krilla());
+            surface.pop();
         }
+        ImageKind::Svg(svg) => {
+            surface.draw_svg(
+                svg.tree(),
+                size.to_krilla(),
+                SvgSettings { embed_text: true, ..Default::default() },
+            );
+        }
+    }
 
-        Ok(())
-    })?;
+    if image.alt().is_some() {
+        surface.end_alt_text();
+    }
 
-    Ok((chunk, out))
+    surface.pop();
+    surface.reset_location();
+
+    Ok(())
 }
 
-/// Creates a new PDF image from the given image.
-///
-/// Also starts the deferred encoding of the image.
-#[comemo::memoize]
-pub fn deferred_image(
-    image: Image,
-    pdfa: bool,
-) -> (Deferred<StrResult<EncodedImage>>, Option<ColorSpace>) {
-    let color_space = match image.kind() {
-        ImageKind::Raster(raster) if raster.icc().is_none() => {
-            Some(to_color_space(raster.dynamic().color()))
+struct Repr {
+    /// The original, underlying raster image.
+    raster: RasterImage,
+    /// The alpha channel of the raster image, if existing.
+    alpha_channel: OnceLock<Option<Vec<u8>>>,
+    /// A (potentially) converted version of the dynamic image stored `raster` that is
+    /// guaranteed to either be in luma8 or rgb8, and thus can be used for the
+    /// `color_channel` method of `CustomImage`.
+    actual_dynamic: OnceLock<Arc<DynamicImage>>,
+}
+
+/// A wrapper around `RasterImage` so that we can implement `CustomImage`.
+#[derive(Clone)]
+struct PdfImage(Arc<Repr>);
+
+impl PdfImage {
+    pub fn new(raster: RasterImage) -> Self {
+        Self(Arc::new(Repr {
+            raster,
+            alpha_channel: OnceLock::new(),
+            actual_dynamic: OnceLock::new(),
+        }))
+    }
+}
+
+impl Hash for PdfImage {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // `alpha_channel` and `actual_dynamic` are generated from the underlying `RasterImage`,
+        // so this is enough. Since `raster` is prehashed, this is also very cheap.
+        self.0.raster.hash(state);
+    }
+}
+
+impl CustomImage for PdfImage {
+    fn color_channel(&self) -> &[u8] {
+        self.0
+            .actual_dynamic
+            .get_or_init(|| {
+                let dynamic = self.0.raster.dynamic();
+                let channel_count = dynamic.color().channel_count();
+
+                match (dynamic.as_ref(), channel_count) {
+                    // Pure luma8 or rgb8 image, can use it directly.
+                    (DynamicImage::ImageLuma8(_), _) => dynamic.clone(),
+                    (DynamicImage::ImageRgb8(_), _) => dynamic.clone(),
+                    // Grey-scale image, convert to luma8.
+                    (_, 1 | 2) => Arc::new(DynamicImage::ImageLuma8(dynamic.to_luma8())),
+                    // Anything else, convert to rgb8.
+                    _ => Arc::new(DynamicImage::ImageRgb8(dynamic.to_rgb8())),
+                }
+            })
+            .as_bytes()
+    }
+
+    fn alpha_channel(&self) -> Option<&[u8]> {
+        self.0
+            .alpha_channel
+            .get_or_init(|| {
+                self.0.raster.dynamic().color().has_alpha().then(|| {
+                    self.0
+                        .raster
+                        .dynamic()
+                        .pixels()
+                        .map(|(_, _, Rgba([_, _, _, a]))| a)
+                        .collect()
+                })
+            })
+            .as_ref()
+            .map(|v| &**v)
+    }
+
+    fn bits_per_component(&self) -> BitsPerComponent {
+        BitsPerComponent::Eight
+    }
+
+    fn size(&self) -> (u32, u32) {
+        (self.0.raster.width(), self.0.raster.height())
+    }
+
+    fn icc_profile(&self) -> Option<&[u8]> {
+        if matches!(
+            self.0.raster.dynamic().as_ref(),
+            DynamicImage::ImageLuma8(_)
+                | DynamicImage::ImageLumaA8(_)
+                | DynamicImage::ImageRgb8(_)
+                | DynamicImage::ImageRgba8(_)
+        ) {
+            self.0.raster.icc().map(|b| b.as_bytes())
+        } else {
+            // In all other cases, the dynamic will be converted into RGB8 or LUMA8, so the ICC
+            // profile may become invalid, and thus we don't include it.
+            None
         }
-        _ => None,
+    }
+
+    fn color_space(&self) -> ImageColorspace {
+        // Remember that we convert all images to either RGB or luma.
+        if self.0.raster.dynamic().color().has_color() {
+            ImageColorspace::Rgb
+        } else {
+            ImageColorspace::Luma
+        }
+    }
+}
+
+#[comemo::memoize]
+fn convert_raster(
+    raster: RasterImage,
+    interpolate: bool,
+) -> Option<krilla::image::Image> {
+    if let RasterFormat::Exchange(ExchangeFormat::Jpg) = raster.format() {
+        let image_data: Arc<dyn AsRef<[u8]> + Send + Sync> =
+            Arc::new(raster.data().clone());
+        let icc_profile = raster.icc().map(|i| {
+            let i: Arc<dyn AsRef<[u8]> + Send + Sync> = Arc::new(i.clone());
+            i
+        });
+
+        krilla::image::Image::from_jpeg_with_icc(
+            image_data.into(),
+            icc_profile.map(|i| i.into()),
+            interpolate,
+        )
+    } else {
+        krilla::image::Image::from_custom(PdfImage::new(raster), interpolate)
+    }
+}
+
+fn exif_transform(image: &RasterImage, size: Size) -> (Transform, Size) {
+    let base = |hp: bool, vp: bool, mut base_ts: Transform, size: Size| {
+        if hp {
+            // Flip horizontally in-place.
+            base_ts = base_ts.pre_concat(
+                Transform::scale(-Ratio::one(), Ratio::one())
+                    .pre_concat(Transform::translate(-size.x, Abs::zero())),
+            )
+        }
+
+        if vp {
+            // Flip vertically in-place.
+            base_ts = base_ts.pre_concat(
+                Transform::scale(Ratio::one(), -Ratio::one())
+                    .pre_concat(Transform::translate(Abs::zero(), -size.y)),
+            )
+        }
+
+        base_ts
     };
 
-    // PDF/A does not appear to allow interpolation.
-    // See https://github.com/typst/typst/issues/2942.
-    let interpolate = !pdfa && image.scaling() == Smart::Custom(ImageScaling::Smooth);
+    let no_flipping =
+        |hp: bool, vp: bool| (base(hp, vp, Transform::identity(), size), size);
 
-    let deferred = Deferred::new(move || match image.kind() {
-        ImageKind::Raster(raster) => Ok(encode_raster_image(raster, interpolate)),
-        ImageKind::Svg(svg) => {
-            let (chunk, id) = encode_svg(svg, pdfa)
-                .map_err(|err| eco_format!("failed to convert SVG to PDF: {err}"))?;
-            Ok(EncodedImage::Svg(chunk, id))
-        }
-    });
+    let with_flipping = |hp: bool, vp: bool| {
+        let base_ts = Transform::rotate_at(Angle::deg(90.0), Abs::zero(), Abs::zero())
+            .pre_concat(Transform::scale(Ratio::one(), -Ratio::one()));
+        let inv_size = Size::new(size.y, size.x);
+        (base(hp, vp, base_ts, inv_size), inv_size)
+    };
 
-    (deferred, color_space)
-}
-
-/// Encode an image with a suitable filter.
-#[typst_macros::time(name = "encode raster image")]
-fn encode_raster_image(image: &RasterImage, interpolate: bool) -> EncodedImage {
-    let dynamic = image.dynamic();
-    let color_space = to_color_space(dynamic.color());
-
-    let (filter, data, bits_per_component) =
-        if image.format() == RasterFormat::Exchange(ExchangeFormat::Jpg) {
-            let mut data = Cursor::new(vec![]);
-            dynamic.write_to(&mut data, image::ImageFormat::Jpeg).unwrap();
-            (Filter::DctDecode, data.into_inner(), 8)
-        } else {
-            // TODO: Encode flate streams with PNG-predictor?
-            let (data, bits_per_component) = match (dynamic, color_space) {
-                // RGB image.
-                (DynamicImage::ImageRgb8(rgb), _) => (deflate(rgb.as_raw()), 8),
-                // Grayscale image
-                (DynamicImage::ImageLuma8(luma), _) => (deflate(luma.as_raw()), 8),
-                (_, ColorSpace::D65Gray) => (deflate(dynamic.to_luma8().as_raw()), 8),
-                // Anything else
-                _ => (deflate(dynamic.to_rgb8().as_raw()), 8),
-            };
-            (Filter::FlateDecode, data, bits_per_component)
-        };
-
-    let compressed_icc = image.icc().map(|data| deflate(data));
-    let alpha = dynamic.color().has_alpha().then(|| encode_alpha(dynamic));
-
-    EncodedImage::Raster {
-        data,
-        filter,
-        color_space,
-        bits_per_component,
-        width: image.width(),
-        height: image.height(),
-        compressed_icc,
-        alpha,
-        interpolate,
-    }
-}
-
-/// Encode an image's alpha channel if present.
-#[typst_macros::time(name = "encode alpha")]
-fn encode_alpha(image: &DynamicImage) -> (Vec<u8>, Filter) {
-    let pixels: Vec<_> = image.pixels().map(|(_, _, Rgba([_, _, _, a]))| a).collect();
-    (deflate(&pixels), Filter::FlateDecode)
-}
-
-/// Encode an SVG into a chunk of PDF objects.
-#[typst_macros::time(name = "encode svg")]
-fn encode_svg(
-    svg: &SvgImage,
-    pdfa: bool,
-) -> Result<(Chunk, Ref), svg2pdf::ConversionError> {
-    svg2pdf::to_chunk(
-        svg.tree(),
-        svg2pdf::ConversionOptions { pdfa, ..Default::default() },
-    )
-}
-
-/// A pre-encoded image.
-pub enum EncodedImage {
-    /// A pre-encoded rasterized image.
-    Raster {
-        /// The raw, pre-deflated image data.
-        data: Vec<u8>,
-        /// The filter to use for the image.
-        filter: Filter,
-        /// Which color space this image is encoded in.
-        color_space: ColorSpace,
-        /// How many bits of each color component are stored.
-        bits_per_component: u8,
-        /// The image's width.
-        width: u32,
-        /// The image's height.
-        height: u32,
-        /// The image's ICC profile, deflated, if any.
-        compressed_icc: Option<Vec<u8>>,
-        /// The alpha channel of the image, pre-deflated, if any.
-        alpha: Option<(Vec<u8>, Filter)>,
-        /// Whether image interpolation should be enabled.
-        interpolate: bool,
-    },
-    /// A vector graphic.
-    ///
-    /// The chunk is the SVG converted to PDF objects.
-    Svg(Chunk, Ref),
-}
-
-/// Matches an [`image::ColorType`] to [`ColorSpace`].
-fn to_color_space(color: image::ColorType) -> ColorSpace {
-    use image::ColorType::*;
-    match color {
-        L8 | La8 | L16 | La16 => ColorSpace::D65Gray,
-        Rgb8 | Rgba8 | Rgb16 | Rgba16 | Rgb32F | Rgba32F => ColorSpace::Srgb,
-        _ => unimplemented!(),
+    match image.exif_rotation() {
+        Some(2) => no_flipping(true, false),
+        Some(3) => no_flipping(true, true),
+        Some(4) => no_flipping(false, true),
+        Some(5) => with_flipping(false, false),
+        Some(6) => with_flipping(true, false),
+        Some(7) => with_flipping(true, true),
+        Some(8) => with_flipping(false, true),
+        _ => no_flipping(false, false),
     }
 }
diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs
index 88e62389c..4e0b74308 100644
--- a/crates/typst-pdf/src/lib.rs
+++ b/crates/typst-pdf/src/lib.rs
@@ -1,81 +1,33 @@
-//! Exporting of Typst documents into PDFs.
+//! Exporting Typst documents to PDF.
 
-mod catalog;
-mod color;
-mod color_font;
-mod content;
+mod convert;
 mod embed;
-mod extg;
-mod font;
-mod gradient;
 mod image;
-mod named_destination;
+mod link;
+mod metadata;
 mod outline;
 mod page;
-mod resources;
-mod tiling;
+mod paint;
+mod shape;
+mod text;
+mod util;
+
+pub use self::metadata::{Timestamp, Timezone};
 
-use std::collections::{BTreeMap, HashMap};
 use std::fmt::{self, Debug, Formatter};
-use std::hash::Hash;
-use std::ops::{Deref, DerefMut};
 
-use base64::Engine;
-use ecow::EcoString;
-use pdf_writer::{Chunk, Name, Pdf, Ref, Str, TextStr};
+use ecow::eco_format;
 use serde::{Deserialize, Serialize};
 use typst_library::diag::{bail, SourceResult, StrResult};
-use typst_library::foundations::{Datetime, Smart};
-use typst_library::layout::{Abs, Em, PageRanges, PagedDocument, Transform};
-use typst_library::text::Font;
-use typst_library::visualize::Image;
-use typst_syntax::Span;
-use typst_utils::Deferred;
-
-use crate::catalog::write_catalog;
-use crate::color::{alloc_color_functions_refs, ColorFunctionRefs};
-use crate::color_font::{write_color_fonts, ColorFontSlice};
-use crate::embed::write_embedded_files;
-use crate::extg::{write_graphic_states, ExtGState};
-use crate::font::write_fonts;
-use crate::gradient::{write_gradients, PdfGradient};
-use crate::image::write_images;
-use crate::named_destination::{write_named_destinations, NamedDestinations};
-use crate::page::{alloc_page_refs, traverse_pages, write_page_tree, EncodedPage};
-use crate::resources::{
-    alloc_resources_refs, write_resource_dictionaries, Resources, ResourcesRefs,
-};
-use crate::tiling::{write_tilings, PdfTiling};
+use typst_library::foundations::Smart;
+use typst_library::layout::{PageRanges, PagedDocument};
 
 /// Export a document into a PDF file.
 ///
 /// Returns the raw bytes making up the PDF file.
 #[typst_macros::time(name = "pdf")]
 pub fn pdf(document: &PagedDocument, options: &PdfOptions) -> SourceResult<Vec<u8>> {
-    PdfBuilder::new(document, options)
-        .phase(|builder| builder.run(traverse_pages))?
-        .phase(|builder| {
-            Ok(GlobalRefs {
-                color_functions: builder.run(alloc_color_functions_refs)?,
-                pages: builder.run(alloc_page_refs)?,
-                resources: builder.run(alloc_resources_refs)?,
-            })
-        })?
-        .phase(|builder| {
-            Ok(References {
-                named_destinations: builder.run(write_named_destinations)?,
-                fonts: builder.run(write_fonts)?,
-                color_fonts: builder.run(write_color_fonts)?,
-                images: builder.run(write_images)?,
-                gradients: builder.run(write_gradients)?,
-                tilings: builder.run(write_tilings)?,
-                ext_gs: builder.run(write_graphic_states)?,
-                embedded_files: builder.run(write_embedded_files)?,
-            })
-        })?
-        .phase(|builder| builder.run(write_page_tree))?
-        .phase(|builder| builder.run(write_resource_dictionaries))?
-        .export_with(write_catalog)
+    convert::convert(document, options)
 }
 
 /// Settings for PDF export.
@@ -103,82 +55,74 @@ pub struct PdfOptions<'a> {
     pub standards: PdfStandards,
 }
 
-/// A timestamp with timezone information.
-#[derive(Debug, Clone, Copy)]
-pub struct Timestamp {
-    /// The datetime of the timestamp.
-    pub(crate) datetime: Datetime,
-    /// The timezone of the timestamp.
-    pub(crate) timezone: Timezone,
-}
-
-impl Timestamp {
-    /// Create a new timestamp with a given datetime and UTC suffix.
-    pub fn new_utc(datetime: Datetime) -> Self {
-        Self { datetime, timezone: Timezone::UTC }
-    }
-
-    /// Create a new timestamp with a given datetime, and a local timezone offset.
-    pub fn new_local(datetime: Datetime, whole_minute_offset: i32) -> Option<Self> {
-        let hour_offset = (whole_minute_offset / 60).try_into().ok()?;
-        // Note: the `%` operator in Rust is the remainder operator, not the
-        // modulo operator. The remainder operator can return negative results.
-        // We can simply apply `abs` here because we assume the `minute_offset`
-        // will have the same sign as `hour_offset`.
-        let minute_offset = (whole_minute_offset % 60).abs().try_into().ok()?;
-        match (hour_offset, minute_offset) {
-            // Only accept valid timezone offsets with `-23 <= hours <= 23`,
-            // and `0 <= minutes <= 59`.
-            (-23..=23, 0..=59) => Some(Self {
-                datetime,
-                timezone: Timezone::Local { hour_offset, minute_offset },
-            }),
-            _ => None,
-        }
-    }
-}
-
-/// A timezone.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Timezone {
-    /// The UTC timezone.
-    UTC,
-    /// The local timezone offset from UTC. And the `minute_offset` will have
-    /// same sign as `hour_offset`.
-    Local { hour_offset: i8, minute_offset: u8 },
-}
-
 /// Encapsulates a list of compatible PDF standards.
 #[derive(Clone)]
 pub struct PdfStandards {
-    /// For now, we simplify to just PDF/A. But it can be more fine-grained in
-    /// the future.
-    pub(crate) pdfa: bool,
-    /// Whether the standard allows for embedding any kind of file into the PDF.
-    /// We disallow this for PDF/A-2, since it only allows embedding
-    /// PDF/A-1 and PDF/A-2 documents.
-    pub(crate) embedded_files: bool,
-    /// Part of the PDF/A standard.
-    pub(crate) pdfa_part: Option<(i32, &'static str)>,
+    pub(crate) config: krilla::configure::Configuration,
 }
 
 impl PdfStandards {
     /// Validates a list of PDF standards for compatibility and returns their
     /// encapsulated representation.
     pub fn new(list: &[PdfStandard]) -> StrResult<Self> {
-        let a2b = list.contains(&PdfStandard::A_2b);
-        let a3b = list.contains(&PdfStandard::A_3b);
+        use krilla::configure::{Configuration, PdfVersion, Validator};
 
-        if a2b && a3b {
-            bail!("PDF cannot conform to A-2B and A-3B at the same time")
+        let mut version: Option<PdfVersion> = None;
+        let mut set_version = |v: PdfVersion| -> StrResult<()> {
+            if let Some(prev) = version {
+                bail!(
+                    "PDF cannot conform to {} and {} at the same time",
+                    prev.as_str(),
+                    v.as_str()
+                );
+            }
+            version = Some(v);
+            Ok(())
+        };
+
+        let mut validator = None;
+        let mut set_validator = |v: Validator| -> StrResult<()> {
+            if validator.is_some() {
+                bail!("Typst currently only supports one PDF substandard at a time");
+            }
+            validator = Some(v);
+            Ok(())
+        };
+
+        for standard in list {
+            match standard {
+                PdfStandard::V_1_4 => set_version(PdfVersion::Pdf14)?,
+                PdfStandard::V_1_5 => set_version(PdfVersion::Pdf15)?,
+                PdfStandard::V_1_6 => set_version(PdfVersion::Pdf16)?,
+                PdfStandard::V_1_7 => set_version(PdfVersion::Pdf17)?,
+                PdfStandard::V_2_0 => set_version(PdfVersion::Pdf20)?,
+                PdfStandard::A_1b => set_validator(Validator::A1_B)?,
+                PdfStandard::A_2b => set_validator(Validator::A2_B)?,
+                PdfStandard::A_2u => set_validator(Validator::A2_U)?,
+                PdfStandard::A_3b => set_validator(Validator::A3_B)?,
+                PdfStandard::A_3u => set_validator(Validator::A3_U)?,
+                PdfStandard::A_4 => set_validator(Validator::A4)?,
+                PdfStandard::A_4f => set_validator(Validator::A4F)?,
+                PdfStandard::A_4e => set_validator(Validator::A4E)?,
+            }
         }
 
-        let pdfa = a2b || a3b;
-        Ok(Self {
-            pdfa,
-            embedded_files: !a2b,
-            pdfa_part: pdfa.then_some((if a2b { 2 } else { 3 }, "B")),
-        })
+        let config = match (version, validator) {
+            (Some(version), Some(validator)) => {
+                Configuration::new_with(validator, version).ok_or_else(|| {
+                    eco_format!(
+                        "{} is not compatible with {}",
+                        version.as_str(),
+                        validator.as_str()
+                    )
+                })?
+            }
+            (Some(version), None) => Configuration::new_with_version(version),
+            (None, Some(validator)) => Configuration::new_with_validator(validator),
+            (None, None) => Configuration::new_with_version(PdfVersion::Pdf17),
+        };
+
+        Ok(Self { config })
     }
 }
 
@@ -190,7 +134,10 @@ impl Debug for PdfStandards {
 
 impl Default for PdfStandards {
     fn default() -> Self {
-        Self { pdfa: false, embedded_files: true, pdfa_part: None }
+        use krilla::configure::{Configuration, PdfVersion};
+        Self {
+            config: Configuration::new_with_version(PdfVersion::Pdf17),
+        }
     }
 }
 
@@ -201,531 +148,43 @@ impl Default for PdfStandards {
 #[allow(non_camel_case_types)]
 #[non_exhaustive]
 pub enum PdfStandard {
+    /// PDF 1.4.
+    #[serde(rename = "1.4")]
+    V_1_4,
+    /// PDF 1.5.
+    #[serde(rename = "1.5")]
+    V_1_5,
+    /// PDF 1.5.
+    #[serde(rename = "1.6")]
+    V_1_6,
     /// PDF 1.7.
     #[serde(rename = "1.7")]
     V_1_7,
+    /// PDF 2.0.
+    #[serde(rename = "2.0")]
+    V_2_0,
+    /// PDF/A-1b.
+    #[serde(rename = "a-1b")]
+    A_1b,
     /// PDF/A-2b.
     #[serde(rename = "a-2b")]
     A_2b,
-    /// PDF/A-3b.
+    /// PDF/A-2u.
+    #[serde(rename = "a-2u")]
+    A_2u,
+    /// PDF/A-3u.
     #[serde(rename = "a-3b")]
     A_3b,
-}
-
-/// A struct to build a PDF following a fixed succession of phases.
-///
-/// This type uses generics to represent its current state. `S` (for "state") is
-/// all data that was produced by the previous phases, that is now read-only.
-///
-/// Phase after phase, this state will be transformed. Each phase corresponds to
-/// a call to the [eponymous function](`PdfBuilder::phase`) and produces a new
-/// part of the state, that will be aggregated with all other information, for
-/// consumption during the next phase.
-///
-/// In other words: this struct follows the **typestate pattern**. This prevents
-/// you from using data that is not yet available, at the type level.
-///
-/// Each phase consists of processes, that can read the state of the previous
-/// phases, and construct a part of the new state.
-///
-/// A final step, that has direct access to the global reference allocator and
-/// PDF document, can be run with [`PdfBuilder::export_with`].
-struct PdfBuilder<S> {
-    /// The context that has been accumulated so far.
-    state: S,
-    /// A global bump allocator.
-    alloc: Ref,
-    /// The PDF document that is being written.
-    pdf: Pdf,
-}
-
-/// The initial state: we are exploring the document, collecting all resources
-/// that will be necessary later. The content of the pages is also built during
-/// this phase.
-struct WithDocument<'a> {
-    /// The Typst document that is exported.
-    document: &'a PagedDocument,
-    /// Settings for PDF export.
-    options: &'a PdfOptions<'a>,
-}
-
-/// At this point, resources were listed, but they don't have any reference
-/// associated with them.
-///
-/// This phase allocates some global references.
-struct WithResources<'a> {
-    document: &'a PagedDocument,
-    options: &'a PdfOptions<'a>,
-    /// The content of the pages encoded as PDF content streams.
-    ///
-    /// The pages are at the index corresponding to their page number, but they
-    /// may be `None` if they are not in the range specified by
-    /// `exported_pages`.
-    pages: Vec<Option<EncodedPage>>,
-    /// The PDF resources that are used in the content of the pages.
-    resources: Resources<()>,
-}
-
-/// Global references.
-struct GlobalRefs {
-    /// References for color conversion functions.
-    color_functions: ColorFunctionRefs,
-    /// Reference for pages.
-    ///
-    /// Items of this vector are `None` if the corresponding page is not
-    /// exported.
-    pages: Vec<Option<Ref>>,
-    /// References for the resource dictionaries.
-    resources: ResourcesRefs,
-}
-
-impl<'a> From<(WithDocument<'a>, (Vec<Option<EncodedPage>>, Resources<()>))>
-    for WithResources<'a>
-{
-    fn from(
-        (previous, (pages, resources)): (
-            WithDocument<'a>,
-            (Vec<Option<EncodedPage>>, Resources<()>),
-        ),
-    ) -> Self {
-        Self {
-            document: previous.document,
-            options: previous.options,
-            pages,
-            resources,
-        }
-    }
-}
-
-/// At this point, the resources have been collected, and global references have
-/// been allocated.
-///
-/// We are now writing objects corresponding to resources, and giving them references,
-/// that will be collected in [`References`].
-struct WithGlobalRefs<'a> {
-    document: &'a PagedDocument,
-    options: &'a PdfOptions<'a>,
-    pages: Vec<Option<EncodedPage>>,
-    /// Resources are the same as in previous phases, but each dictionary now has a reference.
-    resources: Resources,
-    /// Global references that were just allocated.
-    globals: GlobalRefs,
-}
-
-impl<'a> From<(WithResources<'a>, GlobalRefs)> for WithGlobalRefs<'a> {
-    fn from((previous, globals): (WithResources<'a>, GlobalRefs)) -> Self {
-        Self {
-            document: previous.document,
-            options: previous.options,
-            pages: previous.pages,
-            resources: previous.resources.with_refs(&globals.resources),
-            globals,
-        }
-    }
-}
-
-/// The references that have been assigned to each object.
-struct References {
-    /// List of named destinations, each with an ID.
-    named_destinations: NamedDestinations,
-    /// The IDs of written fonts.
-    fonts: HashMap<Font, Ref>,
-    /// The IDs of written color fonts.
-    color_fonts: HashMap<ColorFontSlice, Ref>,
-    /// The IDs of written images.
-    images: HashMap<Image, Ref>,
-    /// The IDs of written gradients.
-    gradients: HashMap<PdfGradient, Ref>,
-    /// The IDs of written tilings.
-    tilings: HashMap<PdfTiling, Ref>,
-    /// The IDs of written external graphics states.
-    ext_gs: HashMap<ExtGState, Ref>,
-    /// The names and references for embedded files.
-    embedded_files: BTreeMap<EcoString, Ref>,
-}
-
-/// At this point, the references have been assigned to all resources. The page
-/// tree is going to be written, and given a reference. It is also at this point that
-/// the page contents is actually written.
-struct WithRefs<'a> {
-    document: &'a PagedDocument,
-    options: &'a PdfOptions<'a>,
-    globals: GlobalRefs,
-    pages: Vec<Option<EncodedPage>>,
-    resources: Resources,
-    /// References that were allocated for resources.
-    references: References,
-}
-
-impl<'a> From<(WithGlobalRefs<'a>, References)> for WithRefs<'a> {
-    fn from((previous, references): (WithGlobalRefs<'a>, References)) -> Self {
-        Self {
-            document: previous.document,
-            options: previous.options,
-            globals: previous.globals,
-            pages: previous.pages,
-            resources: previous.resources,
-            references,
-        }
-    }
-}
-
-/// In this phase, we write resource dictionaries.
-///
-/// Each sub-resource gets its own isolated resource dictionary.
-struct WithEverything<'a> {
-    document: &'a PagedDocument,
-    options: &'a PdfOptions<'a>,
-    globals: GlobalRefs,
-    pages: Vec<Option<EncodedPage>>,
-    resources: Resources,
-    references: References,
-    /// Reference that was allocated for the page tree.
-    page_tree_ref: Ref,
-}
-
-impl<'a> From<(WithEverything<'a>, ())> for WithEverything<'a> {
-    fn from((this, _): (WithEverything<'a>, ())) -> Self {
-        this
-    }
-}
-
-impl<'a> From<(WithRefs<'a>, Ref)> for WithEverything<'a> {
-    fn from((previous, page_tree_ref): (WithRefs<'a>, Ref)) -> Self {
-        Self {
-            document: previous.document,
-            options: previous.options,
-            globals: previous.globals,
-            resources: previous.resources,
-            references: previous.references,
-            pages: previous.pages,
-            page_tree_ref,
-        }
-    }
-}
-
-impl<'a> PdfBuilder<WithDocument<'a>> {
-    /// Start building a PDF for a Typst document.
-    fn new(document: &'a PagedDocument, options: &'a PdfOptions<'a>) -> Self {
-        Self {
-            alloc: Ref::new(1),
-            pdf: Pdf::new(),
-            state: WithDocument { document, options },
-        }
-    }
-}
-
-impl<S> PdfBuilder<S> {
-    /// Start a new phase, and save its output in the global state.
-    fn phase<NS, B, O>(mut self, builder: B) -> SourceResult<PdfBuilder<NS>>
-    where
-        // New state
-        NS: From<(S, O)>,
-        // Builder
-        B: Fn(&mut Self) -> SourceResult<O>,
-    {
-        let output = builder(&mut self)?;
-        Ok(PdfBuilder {
-            state: NS::from((self.state, output)),
-            alloc: self.alloc,
-            pdf: self.pdf,
-        })
-    }
-
-    /// Run a step with the current state, merges its output into the PDF file,
-    /// and renumbers any references it returned.
-    fn run<P, O>(&mut self, process: P) -> SourceResult<O>
-    where
-        // Process
-        P: Fn(&S) -> SourceResult<(PdfChunk, O)>,
-        // Output
-        O: Renumber,
-    {
-        let (chunk, mut output) = process(&self.state)?;
-        // Allocate a final reference for each temporary one
-        let allocated = chunk.alloc.get() - TEMPORARY_REFS_START;
-        let offset = TEMPORARY_REFS_START - self.alloc.get();
-
-        // Merge the chunk into the PDF, using the new references
-        chunk.renumber_into(&mut self.pdf, |mut r| {
-            r.renumber(offset);
-
-            r
-        });
-
-        // Also update the references in the output
-        output.renumber(offset);
-
-        self.alloc = Ref::new(self.alloc.get() + allocated);
-
-        Ok(output)
-    }
-
-    /// Finalize the PDF export and returns the buffer representing the
-    /// document.
-    fn export_with<P>(mut self, process: P) -> SourceResult<Vec<u8>>
-    where
-        P: Fn(S, &mut Pdf, &mut Ref) -> SourceResult<()>,
-    {
-        process(self.state, &mut self.pdf, &mut self.alloc)?;
-        Ok(self.pdf.finish())
-    }
-}
-
-/// A reference or collection of references that can be re-numbered,
-/// to become valid in a global scope.
-trait Renumber {
-    /// Renumber this value by shifting any references it contains by `offset`.
-    fn renumber(&mut self, offset: i32);
-}
-
-impl Renumber for () {
-    fn renumber(&mut self, _offset: i32) {}
-}
-
-impl Renumber for Ref {
-    fn renumber(&mut self, offset: i32) {
-        if self.get() >= TEMPORARY_REFS_START {
-            *self = Ref::new(self.get() - offset);
-        }
-    }
-}
-
-impl<R: Renumber> Renumber for Vec<R> {
-    fn renumber(&mut self, offset: i32) {
-        for item in self {
-            item.renumber(offset);
-        }
-    }
-}
-
-impl<T: Eq + Hash, R: Renumber> Renumber for HashMap<T, R> {
-    fn renumber(&mut self, offset: i32) {
-        for v in self.values_mut() {
-            v.renumber(offset);
-        }
-    }
-}
-
-impl<T: Ord, R: Renumber> Renumber for BTreeMap<T, R> {
-    fn renumber(&mut self, offset: i32) {
-        for v in self.values_mut() {
-            v.renumber(offset);
-        }
-    }
-}
-
-impl<R: Renumber> Renumber for Option<R> {
-    fn renumber(&mut self, offset: i32) {
-        if let Some(r) = self {
-            r.renumber(offset)
-        }
-    }
-}
-
-impl<T, R: Renumber> Renumber for (T, R) {
-    fn renumber(&mut self, offset: i32) {
-        self.1.renumber(offset)
-    }
-}
-
-/// A portion of a PDF file.
-struct PdfChunk {
-    /// The actual chunk.
-    chunk: Chunk,
-    /// A local allocator.
-    alloc: Ref,
-}
-
-/// Any reference below that value was already allocated before and
-/// should not be rewritten. Anything above was allocated in the current
-/// chunk, and should be remapped.
-///
-/// This is a constant (large enough to avoid collisions) and not
-/// dependent on self.alloc to allow for better memoization of steps, if
-/// needed in the future.
-const TEMPORARY_REFS_START: i32 = 1_000_000_000;
-
-/// A part of a PDF document.
-impl PdfChunk {
-    /// Start writing a new part of the document.
-    fn new() -> Self {
-        PdfChunk {
-            chunk: Chunk::new(),
-            alloc: Ref::new(TEMPORARY_REFS_START),
-        }
-    }
-
-    /// Allocate a reference that is valid in the context of this chunk.
-    ///
-    /// References allocated with this function should be [renumbered](`Renumber::renumber`)
-    /// before being used in other chunks. This is done automatically if these
-    /// references are stored in the global `PdfBuilder` state.
-    fn alloc(&mut self) -> Ref {
-        self.alloc.bump()
-    }
-}
-
-impl Deref for PdfChunk {
-    type Target = Chunk;
-
-    fn deref(&self) -> &Self::Target {
-        &self.chunk
-    }
-}
-
-impl DerefMut for PdfChunk {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.chunk
-    }
-}
-
-/// Compress data with the DEFLATE algorithm.
-fn deflate(data: &[u8]) -> Vec<u8> {
-    const COMPRESSION_LEVEL: u8 = 6;
-    miniz_oxide::deflate::compress_to_vec_zlib(data, COMPRESSION_LEVEL)
-}
-
-/// Memoized and deferred version of [`deflate`] specialized for a page's content
-/// stream.
-#[comemo::memoize]
-fn deflate_deferred(content: Vec<u8>) -> Deferred<Vec<u8>> {
-    Deferred::new(move || deflate(&content))
-}
-
-/// Create a base64-encoded hash of the value.
-fn hash_base64<T: Hash>(value: &T) -> String {
-    base64::engine::general_purpose::STANDARD
-        .encode(typst_utils::hash128(value).to_be_bytes())
-}
-
-/// Additional methods for [`Abs`].
-trait AbsExt {
-    /// Convert an to a number of points.
-    fn to_f32(self) -> f32;
-}
-
-impl AbsExt for Abs {
-    fn to_f32(self) -> f32 {
-        self.to_pt() as f32
-    }
-}
-
-/// Additional methods for [`Em`].
-trait EmExt {
-    /// Convert an em length to a number of PDF font units.
-    fn to_font_units(self) -> f32;
-}
-
-impl EmExt for Em {
-    fn to_font_units(self) -> f32 {
-        1000.0 * self.get() as f32
-    }
-}
-
-trait NameExt<'a> {
-    /// The maximum length of a name in PDF/A.
-    const PDFA_LIMIT: usize = 127;
-}
-
-impl<'a> NameExt<'a> for Name<'a> {}
-
-/// Additional methods for [`Str`].
-trait StrExt<'a>: Sized {
-    /// The maximum length of a string in PDF/A.
-    const PDFA_LIMIT: usize = 32767;
-
-    /// Create a string that satisfies the constraints of PDF/A.
-    #[allow(unused)]
-    fn trimmed(string: &'a [u8]) -> Self;
-}
-
-impl<'a> StrExt<'a> for Str<'a> {
-    fn trimmed(string: &'a [u8]) -> Self {
-        Self(&string[..string.len().min(Self::PDFA_LIMIT)])
-    }
-}
-
-/// Additional methods for [`TextStr`].
-trait TextStrExt<'a>: Sized {
-    /// The maximum length of a string in PDF/A.
-    const PDFA_LIMIT: usize = Str::PDFA_LIMIT;
-
-    /// Create a text string that satisfies the constraints of PDF/A.
-    fn trimmed(string: &'a str) -> Self;
-}
-
-impl<'a> TextStrExt<'a> for TextStr<'a> {
-    fn trimmed(string: &'a str) -> Self {
-        Self(&string[..string.len().min(Self::PDFA_LIMIT)])
-    }
-}
-
-/// Extension trait for [`Content`](pdf_writer::Content).
-trait ContentExt {
-    fn save_state_checked(&mut self) -> SourceResult<()>;
-}
-
-impl ContentExt for pdf_writer::Content {
-    fn save_state_checked(&mut self) -> SourceResult<()> {
-        self.save_state();
-        if self.state_nesting_depth() > 28 {
-            bail!(
-                Span::detached(),
-                "maximum PDF grouping depth exceeding";
-                hint: "try to avoid excessive nesting of layout containers",
-            );
-        }
-        Ok(())
-    }
-}
-
-/// Convert to an array of floats.
-fn transform_to_array(ts: Transform) -> [f32; 6] {
-    [
-        ts.sx.get() as f32,
-        ts.ky.get() as f32,
-        ts.kx.get() as f32,
-        ts.sy.get() as f32,
-        ts.tx.to_f32(),
-        ts.ty.to_f32(),
-    ]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_timestamp_new_local() {
-        let dummy_datetime = Datetime::from_ymd_hms(2024, 12, 17, 10, 10, 10).unwrap();
-        let test = |whole_minute_offset, expect_timezone| {
-            assert_eq!(
-                Timestamp::new_local(dummy_datetime, whole_minute_offset)
-                    .unwrap()
-                    .timezone,
-                expect_timezone
-            );
-        };
-
-        // Valid timezone offsets
-        test(0, Timezone::Local { hour_offset: 0, minute_offset: 0 });
-        test(480, Timezone::Local { hour_offset: 8, minute_offset: 0 });
-        test(-480, Timezone::Local { hour_offset: -8, minute_offset: 0 });
-        test(330, Timezone::Local { hour_offset: 5, minute_offset: 30 });
-        test(-210, Timezone::Local { hour_offset: -3, minute_offset: 30 });
-        test(-720, Timezone::Local { hour_offset: -12, minute_offset: 0 }); // AoE
-
-        // Corner cases
-        test(315, Timezone::Local { hour_offset: 5, minute_offset: 15 });
-        test(-225, Timezone::Local { hour_offset: -3, minute_offset: 45 });
-        test(1439, Timezone::Local { hour_offset: 23, minute_offset: 59 });
-        test(-1439, Timezone::Local { hour_offset: -23, minute_offset: 59 });
-
-        // Invalid timezone offsets
-        assert!(Timestamp::new_local(dummy_datetime, 1440).is_none());
-        assert!(Timestamp::new_local(dummy_datetime, -1440).is_none());
-        assert!(Timestamp::new_local(dummy_datetime, i32::MAX).is_none());
-        assert!(Timestamp::new_local(dummy_datetime, i32::MIN).is_none());
-    }
+    /// PDF/A-3u.
+    #[serde(rename = "a-3u")]
+    A_3u,
+    /// PDF/A-4.
+    #[serde(rename = "a-4")]
+    A_4,
+    /// PDF/A-4f.
+    #[serde(rename = "a-4f")]
+    A_4f,
+    /// PDF/A-4e.
+    #[serde(rename = "a-4e")]
+    A_4e,
 }
diff --git a/crates/typst-pdf/src/link.rs b/crates/typst-pdf/src/link.rs
new file mode 100644
index 000000000..64cb8f0a2
--- /dev/null
+++ b/crates/typst-pdf/src/link.rs
@@ -0,0 +1,94 @@
+use krilla::action::{Action, LinkAction};
+use krilla::annotation::{LinkAnnotation, Target};
+use krilla::destination::XyzDestination;
+use krilla::geom::Rect;
+use typst_library::layout::{Abs, Point, Size};
+use typst_library::model::Destination;
+
+use crate::convert::{FrameContext, GlobalContext};
+use crate::util::{AbsExt, PointExt};
+
+pub(crate) fn handle_link(
+    fc: &mut FrameContext,
+    gc: &mut GlobalContext,
+    dest: &Destination,
+    size: Size,
+) {
+    let mut min_x = Abs::inf();
+    let mut min_y = Abs::inf();
+    let mut max_x = -Abs::inf();
+    let mut max_y = -Abs::inf();
+
+    let pos = Point::zero();
+
+    // Compute the bounding box of the transformed link.
+    for point in [
+        pos,
+        pos + Point::with_x(size.x),
+        pos + Point::with_y(size.y),
+        pos + size.to_point(),
+    ] {
+        let t = point.transform(fc.state().transform());
+        min_x.set_min(t.x);
+        min_y.set_min(t.y);
+        max_x.set_max(t.x);
+        max_y.set_max(t.y);
+    }
+
+    let x1 = min_x.to_f32();
+    let x2 = max_x.to_f32();
+    let y1 = min_y.to_f32();
+    let y2 = max_y.to_f32();
+
+    let rect = Rect::from_ltrb(x1, y1, x2, y2).unwrap();
+
+    // TODO: Support quad points.
+
+    let pos = match dest {
+        Destination::Url(u) => {
+            fc.push_annotation(
+                LinkAnnotation::new(
+                    rect,
+                    None,
+                    Target::Action(Action::Link(LinkAction::new(u.to_string()))),
+                )
+                .into(),
+            );
+            return;
+        }
+        Destination::Position(p) => *p,
+        Destination::Location(loc) => {
+            if let Some(nd) = gc.loc_to_names.get(loc) {
+                // If a named destination has been registered, it's already guaranteed to
+                // not point to an excluded page.
+                fc.push_annotation(
+                    LinkAnnotation::new(
+                        rect,
+                        None,
+                        Target::Destination(krilla::destination::Destination::Named(
+                            nd.clone(),
+                        )),
+                    )
+                    .into(),
+                );
+                return;
+            } else {
+                gc.document.introspector.position(*loc)
+            }
+        }
+    };
+
+    let page_index = pos.page.get() - 1;
+    if let Some(index) = gc.page_index_converter.pdf_page_index(page_index) {
+        fc.push_annotation(
+            LinkAnnotation::new(
+                rect,
+                None,
+                Target::Destination(krilla::destination::Destination::Xyz(
+                    XyzDestination::new(index, pos.point.to_krilla()),
+                )),
+            )
+            .into(),
+        );
+    }
+}
diff --git a/crates/typst-pdf/src/metadata.rs b/crates/typst-pdf/src/metadata.rs
new file mode 100644
index 000000000..589c5e2fb
--- /dev/null
+++ b/crates/typst-pdf/src/metadata.rs
@@ -0,0 +1,184 @@
+use ecow::EcoString;
+use krilla::metadata::{Metadata, TextDirection};
+use typst_library::foundations::{Datetime, Smart};
+use typst_library::layout::Dir;
+use typst_library::text::Lang;
+
+use crate::convert::GlobalContext;
+
+pub(crate) fn build_metadata(gc: &GlobalContext) -> Metadata {
+    let creator = format!("Typst {}", env!("CARGO_PKG_VERSION"));
+
+    let lang = gc.languages.iter().max_by_key(|(_, &count)| count).map(|(&l, _)| l);
+
+    let dir = if lang.map(Lang::dir) == Some(Dir::RTL) {
+        TextDirection::RightToLeft
+    } else {
+        TextDirection::LeftToRight
+    };
+
+    let mut metadata = Metadata::new()
+        .creator(creator)
+        .keywords(gc.document.info.keywords.iter().map(EcoString::to_string).collect())
+        .authors(gc.document.info.author.iter().map(EcoString::to_string).collect());
+
+    let lang = gc.languages.iter().max_by_key(|(_, &count)| count).map(|(&l, _)| l);
+
+    if let Some(lang) = lang {
+        metadata = metadata.language(lang.as_str().to_string());
+    }
+
+    if let Some(title) = &gc.document.info.title {
+        metadata = metadata.title(title.to_string());
+    }
+
+    if let Some(subject) = &gc.document.info.description {
+        metadata = metadata.subject(subject.to_string());
+    }
+
+    if let Some(ident) = gc.options.ident.custom() {
+        metadata = metadata.document_id(ident.to_string());
+    }
+
+    // (1) If the `document.date` is set to specific `datetime` or `none`, use it.
+    // (2) If the `document.date` is set to `auto` or not set, try to use the
+    //     date from the options.
+    // (3) Otherwise, we don't write date metadata.
+    let (date, tz) = match (gc.document.info.date, gc.options.timestamp) {
+        (Smart::Custom(date), _) => (date, None),
+        (Smart::Auto, Some(timestamp)) => {
+            (Some(timestamp.datetime), Some(timestamp.timezone))
+        }
+        _ => (None, None),
+    };
+
+    if let Some(date) = date.and_then(|d| convert_date(d, tz)) {
+        metadata = metadata.creation_date(date);
+    }
+
+    metadata = metadata.text_direction(dir);
+
+    metadata
+}
+
+fn convert_date(
+    datetime: Datetime,
+    tz: Option<Timezone>,
+) -> Option<krilla::metadata::DateTime> {
+    let year = datetime.year().filter(|&y| y >= 0)? as u16;
+
+    let mut kd = krilla::metadata::DateTime::new(year);
+
+    if let Some(month) = datetime.month() {
+        kd = kd.month(month);
+    }
+
+    if let Some(day) = datetime.day() {
+        kd = kd.day(day);
+    }
+
+    if let Some(h) = datetime.hour() {
+        kd = kd.hour(h);
+    }
+
+    if let Some(m) = datetime.minute() {
+        kd = kd.minute(m);
+    }
+
+    if let Some(s) = datetime.second() {
+        kd = kd.second(s);
+    }
+
+    match tz {
+        Some(Timezone::UTC) => kd = kd.utc_offset_hour(0).utc_offset_minute(0),
+        Some(Timezone::Local { hour_offset, minute_offset }) => {
+            kd = kd.utc_offset_hour(hour_offset).utc_offset_minute(minute_offset)
+        }
+        None => {}
+    }
+
+    Some(kd)
+}
+
+/// A timestamp with timezone information.
+#[derive(Debug, Clone, Copy)]
+pub struct Timestamp {
+    /// The datetime of the timestamp.
+    pub(crate) datetime: Datetime,
+    /// The timezone of the timestamp.
+    pub(crate) timezone: Timezone,
+}
+
+impl Timestamp {
+    /// Create a new timestamp with a given datetime and UTC suffix.
+    pub fn new_utc(datetime: Datetime) -> Self {
+        Self { datetime, timezone: Timezone::UTC }
+    }
+
+    /// Create a new timestamp with a given datetime, and a local timezone offset.
+    pub fn new_local(datetime: Datetime, whole_minute_offset: i32) -> Option<Self> {
+        let hour_offset = (whole_minute_offset / 60).try_into().ok()?;
+        // Note: the `%` operator in Rust is the remainder operator, not the
+        // modulo operator. The remainder operator can return negative results.
+        // We can simply apply `abs` here because we assume the `minute_offset`
+        // will have the same sign as `hour_offset`.
+        let minute_offset = (whole_minute_offset % 60).abs().try_into().ok()?;
+        match (hour_offset, minute_offset) {
+            // Only accept valid timezone offsets with `-23 <= hours <= 23`,
+            // and `0 <= minutes <= 59`.
+            (-23..=23, 0..=59) => Some(Self {
+                datetime,
+                timezone: Timezone::Local { hour_offset, minute_offset },
+            }),
+            _ => None,
+        }
+    }
+}
+
+/// A timezone.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Timezone {
+    /// The UTC timezone.
+    UTC,
+    /// The local timezone offset from UTC. And the `minute_offset` will have
+    /// same sign as `hour_offset`.
+    Local { hour_offset: i8, minute_offset: u8 },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_timestamp_new_local() {
+        let dummy_datetime = Datetime::from_ymd_hms(2024, 12, 17, 10, 10, 10).unwrap();
+        let test = |whole_minute_offset, expect_timezone| {
+            assert_eq!(
+                Timestamp::new_local(dummy_datetime, whole_minute_offset)
+                    .unwrap()
+                    .timezone,
+                expect_timezone
+            );
+        };
+
+        // Valid timezone offsets
+        test(0, Timezone::Local { hour_offset: 0, minute_offset: 0 });
+        test(480, Timezone::Local { hour_offset: 8, minute_offset: 0 });
+        test(-480, Timezone::Local { hour_offset: -8, minute_offset: 0 });
+        test(330, Timezone::Local { hour_offset: 5, minute_offset: 30 });
+        test(-210, Timezone::Local { hour_offset: -3, minute_offset: 30 });
+        test(-720, Timezone::Local { hour_offset: -12, minute_offset: 0 }); // AoE
+
+        // Corner cases
+        test(315, Timezone::Local { hour_offset: 5, minute_offset: 15 });
+        test(-225, Timezone::Local { hour_offset: -3, minute_offset: 45 });
+        test(1439, Timezone::Local { hour_offset: 23, minute_offset: 59 });
+        test(-1439, Timezone::Local { hour_offset: -23, minute_offset: 59 });
+
+        // Invalid timezone offsets
+        assert!(Timestamp::new_local(dummy_datetime, 1440).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, -1440).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, i32::MAX).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, i32::MIN).is_none());
+    }
+}
diff --git a/crates/typst-pdf/src/named_destination.rs b/crates/typst-pdf/src/named_destination.rs
deleted file mode 100644
index 7ae2c5e6f..000000000
--- a/crates/typst-pdf/src/named_destination.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use pdf_writer::writers::Destination;
-use pdf_writer::{Ref, Str};
-use typst_library::diag::SourceResult;
-use typst_library::foundations::{Label, NativeElement};
-use typst_library::introspection::Location;
-use typst_library::layout::Abs;
-use typst_library::model::HeadingElem;
-
-use crate::{AbsExt, PdfChunk, Renumber, StrExt, WithGlobalRefs};
-
-/// A list of destinations in the PDF document (a specific point on a specific
-/// page), that have a name associated with them.
-///
-/// Typst creates a named destination for each heading in the document, that
-/// will then be written in the document catalog. PDF readers can then display
-/// them to show a clickable outline of the document.
-#[derive(Default)]
-pub struct NamedDestinations {
-    /// A map between elements and their associated labels
-    pub loc_to_dest: HashMap<Location, Label>,
-    /// A sorted list of all named destinations.
-    pub dests: Vec<(Label, Ref)>,
-}
-
-impl Renumber for NamedDestinations {
-    fn renumber(&mut self, offset: i32) {
-        for (_, reference) in &mut self.dests {
-            reference.renumber(offset);
-        }
-    }
-}
-
-/// Fills in the map and vector for named destinations and writes the indirect
-/// destination objects.
-pub fn write_named_destinations(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, NamedDestinations)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = NamedDestinations::default();
-    let mut seen = HashSet::new();
-
-    // Find all headings that have a label and are the first among other
-    // headings with the same label.
-    let mut matches: Vec<_> = context
-        .document
-        .introspector
-        .query(&HeadingElem::elem().select())
-        .iter()
-        .filter_map(|elem| elem.location().zip(elem.label()))
-        .filter(|&(_, label)| seen.insert(label))
-        .collect();
-
-    // Named destinations must be sorted by key.
-    matches.sort_by_key(|&(_, label)| label.resolve());
-
-    for (loc, label) in matches {
-        // Don't encode named destinations that would exceed the limit. Those
-        // will instead be encoded as normal links.
-        if label.resolve().len() > Str::PDFA_LIMIT {
-            continue;
-        }
-
-        let pos = context.document.introspector.position(loc);
-        let index = pos.page.get() - 1;
-        let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero());
-
-        if let Some((Some(page), Some(page_ref))) =
-            context.pages.get(index).zip(context.globals.pages.get(index))
-        {
-            let dest_ref = chunk.alloc();
-            let x = pos.point.x.to_f32();
-            let y = (page.content.size.y - y).to_f32();
-            out.dests.push((label, dest_ref));
-            out.loc_to_dest.insert(loc, label);
-            chunk
-                .indirect(dest_ref)
-                .start::<Destination>()
-                .page(*page_ref)
-                .xyz(x, y, None);
-        }
-    }
-
-    Ok((chunk, out))
-}
diff --git a/crates/typst-pdf/src/outline.rs b/crates/typst-pdf/src/outline.rs
index eff1182c1..e6324309f 100644
--- a/crates/typst-pdf/src/outline.rs
+++ b/crates/typst-pdf/src/outline.rs
@@ -1,18 +1,15 @@
 use std::num::NonZeroUsize;
 
-use pdf_writer::{Finish, Pdf, Ref, TextStr};
+use krilla::destination::XyzDestination;
+use krilla::outline::{Outline, OutlineNode};
 use typst_library::foundations::{NativeElement, Packed, StyleChain};
 use typst_library::layout::Abs;
 use typst_library::model::HeadingElem;
 
-use crate::{AbsExt, TextStrExt, WithEverything};
+use crate::convert::GlobalContext;
+use crate::util::AbsExt;
 
-/// Construct the outline for the document.
-pub(crate) fn write_outline(
-    chunk: &mut Pdf,
-    alloc: &mut Ref,
-    ctx: &WithEverything,
-) -> Option<Ref> {
+pub(crate) fn build_outline(gc: &GlobalContext) -> Outline {
     let mut tree: Vec<HeadingNode> = vec![];
 
     // Stores the level of the topmost skipped ancestor of the next bookmarked
@@ -21,14 +18,14 @@ pub(crate) fn write_outline(
     // Therefore, its next descendant must be added at its level, which is
     // enforced in the manner shown below.
     let mut last_skipped_level = None;
-    let elements = ctx.document.introspector.query(&HeadingElem::elem().select());
+    let elements = &gc.document.introspector.query(&HeadingElem::elem().select());
 
     for elem in elements.iter() {
-        if let Some(page_ranges) = &ctx.options.page_ranges {
+        if let Some(page_ranges) = &gc.options.page_ranges {
             if !page_ranges
-                .includes_page(ctx.document.introspector.page(elem.location().unwrap()))
+                .includes_page(gc.document.introspector.page(elem.location().unwrap()))
             {
-                // Don't bookmark headings in non-exported pages
+                // Don't bookmark headings in non-exported pages.
                 continue;
             }
         }
@@ -95,39 +92,15 @@ pub(crate) fn write_outline(
         }
     }
 
-    if tree.is_empty() {
-        return None;
+    let mut outline = Outline::new();
+
+    for child in convert_nodes(&tree, gc) {
+        outline.push_child(child);
     }
 
-    let root_id = alloc.bump();
-    let start_ref = *alloc;
-    let len = tree.len();
-
-    let mut prev_ref = None;
-    for (i, node) in tree.iter().enumerate() {
-        prev_ref = Some(write_outline_item(
-            ctx,
-            chunk,
-            alloc,
-            node,
-            root_id,
-            prev_ref,
-            i + 1 == len,
-        ));
-    }
-
-    chunk
-        .outline(root_id)
-        .first(start_ref)
-        .last(Ref::new(
-            alloc.get() - tree.last().map(|child| child.len() as i32).unwrap_or(1),
-        ))
-        .count(tree.len() as i32);
-
-    Some(root_id)
+    outline
 }
 
-/// A heading in the outline panel.
 #[derive(Debug)]
 struct HeadingNode<'a> {
     element: &'a Packed<HeadingElem>,
@@ -149,73 +122,31 @@ impl<'a> HeadingNode<'a> {
         }
     }
 
-    fn len(&self) -> usize {
-        1 + self.children.iter().map(Self::len).sum::<usize>()
+    fn to_krilla(&self, gc: &GlobalContext) -> Option<OutlineNode> {
+        let loc = self.element.location().unwrap();
+        let title = self.element.body.plain_text().to_string();
+        let pos = gc.document.introspector.position(loc);
+        let page_index = pos.page.get() - 1;
+
+        if let Some(index) = gc.page_index_converter.pdf_page_index(page_index) {
+            let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero());
+            let dest = XyzDestination::new(
+                index,
+                krilla::geom::Point::from_xy(pos.point.x.to_f32(), y.to_f32()),
+            );
+
+            let mut outline_node = OutlineNode::new(title, dest);
+            for child in convert_nodes(&self.children, gc) {
+                outline_node.push_child(child);
+            }
+
+            return Some(outline_node);
+        }
+
+        None
     }
 }
 
-/// Write an outline item and all its children.
-fn write_outline_item(
-    ctx: &WithEverything,
-    chunk: &mut Pdf,
-    alloc: &mut Ref,
-    node: &HeadingNode,
-    parent_ref: Ref,
-    prev_ref: Option<Ref>,
-    is_last: bool,
-) -> Ref {
-    let id = alloc.bump();
-    let next_ref = Ref::new(id.get() + node.len() as i32);
-
-    let mut outline = chunk.outline_item(id);
-    outline.parent(parent_ref);
-
-    if !is_last {
-        outline.next(next_ref);
-    }
-
-    if let Some(prev_rev) = prev_ref {
-        outline.prev(prev_rev);
-    }
-
-    if let Some(last_immediate_child) = node.children.last() {
-        outline.first(Ref::new(id.get() + 1));
-        outline.last(Ref::new(next_ref.get() - last_immediate_child.len() as i32));
-        outline.count(-(node.children.len() as i32));
-    }
-
-    outline.title(TextStr::trimmed(node.element.body.plain_text().trim()));
-
-    let loc = node.element.location().unwrap();
-    let pos = ctx.document.introspector.position(loc);
-    let index = pos.page.get() - 1;
-
-    // Don't link to non-exported pages.
-    if let Some((Some(page), Some(page_ref))) =
-        ctx.pages.get(index).zip(ctx.globals.pages.get(index))
-    {
-        let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero());
-        outline.dest().page(*page_ref).xyz(
-            pos.point.x.to_f32(),
-            (page.content.size.y - y).to_f32(),
-            None,
-        );
-    }
-
-    outline.finish();
-
-    let mut prev_ref = None;
-    for (i, child) in node.children.iter().enumerate() {
-        prev_ref = Some(write_outline_item(
-            ctx,
-            chunk,
-            alloc,
-            child,
-            id,
-            prev_ref,
-            i + 1 == node.children.len(),
-        ));
-    }
-
-    id
+fn convert_nodes(nodes: &[HeadingNode], gc: &GlobalContext) -> Vec<OutlineNode> {
+    nodes.iter().flat_map(|node| node.to_krilla(gc)).collect()
 }
diff --git a/crates/typst-pdf/src/page.rs b/crates/typst-pdf/src/page.rs
index 4e95f3c70..aa34400ef 100644
--- a/crates/typst-pdf/src/page.rs
+++ b/crates/typst-pdf/src/page.rs
@@ -1,310 +1,64 @@
-use std::collections::HashMap;
 use std::num::NonZeroUsize;
 
-use ecow::EcoString;
-use pdf_writer::types::{ActionType, AnnotationFlags, AnnotationType, NumberingStyle};
-use pdf_writer::{Filter, Finish, Name, Rect, Ref, Str};
-use typst_library::diag::SourceResult;
-use typst_library::foundations::Label;
-use typst_library::introspection::Location;
-use typst_library::layout::{Abs, Page};
-use typst_library::model::{Destination, Numbering};
+use krilla::page::{NumberingStyle, PageLabel};
+use typst_library::model::Numbering;
 
-use crate::{
-    content, AbsExt, PdfChunk, PdfOptions, Resources, WithDocument, WithRefs,
-    WithResources,
-};
-
-/// Construct page objects.
-#[typst_macros::time(name = "construct pages")]
-#[allow(clippy::type_complexity)]
-pub fn traverse_pages(
-    state: &WithDocument,
-) -> SourceResult<(PdfChunk, (Vec<Option<EncodedPage>>, Resources<()>))> {
-    let mut resources = Resources::default();
-    let mut pages = Vec::with_capacity(state.document.pages.len());
-    let mut skipped_pages = 0;
-    for (i, page) in state.document.pages.iter().enumerate() {
-        if state
-            .options
-            .page_ranges
-            .as_ref()
-            .is_some_and(|ranges| !ranges.includes_page_index(i))
-        {
-            // Don't export this page.
-            pages.push(None);
-            skipped_pages += 1;
-        } else {
-            let mut encoded = construct_page(state.options, &mut resources, page)?;
-            encoded.label = page
-                .numbering
-                .as_ref()
-                .and_then(|num| PdfPageLabel::generate(num, page.number))
-                .or_else(|| {
-                    // When some pages were ignored from export, we show a page label with
-                    // the correct real (not logical) page number.
-                    // This is for consistency with normal output when pages have no numbering
-                    // and all are exported: the final PDF page numbers always correspond to
-                    // the real (not logical) page numbers. Here, the final PDF page number
-                    // will differ, but we can at least use labels to indicate what was
-                    // the corresponding real page number in the Typst document.
-                    (skipped_pages > 0).then(|| PdfPageLabel::arabic(i + 1))
-                });
-            pages.push(Some(encoded));
-        }
-    }
-
-    Ok((PdfChunk::new(), (pages, resources)))
-}
-
-/// Construct a page object.
-#[typst_macros::time(name = "construct page")]
-fn construct_page(
-    options: &PdfOptions,
-    out: &mut Resources<()>,
-    page: &Page,
-) -> SourceResult<EncodedPage> {
-    Ok(EncodedPage {
-        content: content::build(
-            options,
-            out,
-            &page.frame,
-            page.fill_or_transparent(),
-            None,
-        )?,
-        label: None,
-    })
-}
-
-/// Allocate a reference for each exported page.
-pub fn alloc_page_refs(
-    context: &WithResources,
-) -> SourceResult<(PdfChunk, Vec<Option<Ref>>)> {
-    let mut chunk = PdfChunk::new();
-    let page_refs = context
-        .pages
-        .iter()
-        .map(|p| p.as_ref().map(|_| chunk.alloc()))
-        .collect();
-    Ok((chunk, page_refs))
-}
-
-/// Write the page tree.
-pub fn write_page_tree(ctx: &WithRefs) -> SourceResult<(PdfChunk, Ref)> {
-    let mut chunk = PdfChunk::new();
-    let page_tree_ref = chunk.alloc.bump();
-
-    for i in 0..ctx.pages.len() {
-        let content_id = chunk.alloc.bump();
-        write_page(
-            &mut chunk,
-            ctx,
-            content_id,
-            page_tree_ref,
-            &ctx.references.named_destinations.loc_to_dest,
-            i,
-        );
-    }
-
-    let page_kids = ctx.globals.pages.iter().filter_map(Option::as_ref).copied();
-
-    chunk
-        .pages(page_tree_ref)
-        .count(page_kids.clone().count() as i32)
-        .kids(page_kids);
-
-    Ok((chunk, page_tree_ref))
-}
-
-/// Write a page tree node.
-fn write_page(
-    chunk: &mut PdfChunk,
-    ctx: &WithRefs,
-    content_id: Ref,
-    page_tree_ref: Ref,
-    loc_to_dest: &HashMap<Location, Label>,
-    i: usize,
-) {
-    let Some((page, page_ref)) = ctx.pages[i].as_ref().zip(ctx.globals.pages[i]) else {
-        // Page excluded from export.
-        return;
-    };
-
-    let mut annotations = Vec::with_capacity(page.content.links.len());
-    for (dest, rect) in &page.content.links {
-        let id = chunk.alloc();
-        annotations.push(id);
-
-        let mut annotation = chunk.annotation(id);
-        annotation.subtype(AnnotationType::Link).rect(*rect);
-        annotation.border(0.0, 0.0, 0.0, None).flags(AnnotationFlags::PRINT);
-
-        let pos = match dest {
-            Destination::Url(uri) => {
-                annotation
-                    .action()
-                    .action_type(ActionType::Uri)
-                    .uri(Str(uri.as_bytes()));
-                continue;
-            }
-            Destination::Position(pos) => *pos,
-            Destination::Location(loc) => {
-                if let Some(key) = loc_to_dest.get(loc) {
-                    annotation
-                        .action()
-                        .action_type(ActionType::GoTo)
-                        // `key` must be a `Str`, not a `Name`.
-                        .pair(Name(b"D"), Str(key.resolve().as_bytes()));
-                    continue;
-                } else {
-                    ctx.document.introspector.position(*loc)
-                }
-            }
-        };
-
-        let index = pos.page.get() - 1;
-        let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero());
-
-        // Don't add links to non-exported pages.
-        if let Some((Some(page), Some(page_ref))) =
-            ctx.pages.get(index).zip(ctx.globals.pages.get(index))
-        {
-            annotation
-                .action()
-                .action_type(ActionType::GoTo)
-                .destination()
-                .page(*page_ref)
-                .xyz(pos.point.x.to_f32(), (page.content.size.y - y).to_f32(), None);
-        }
-    }
-
-    let mut page_writer = chunk.page(page_ref);
-    page_writer.parent(page_tree_ref);
-
-    let w = page.content.size.x.to_f32();
-    let h = page.content.size.y.to_f32();
-    page_writer.media_box(Rect::new(0.0, 0.0, w, h));
-    page_writer.contents(content_id);
-    page_writer.pair(Name(b"Resources"), ctx.resources.reference);
-
-    if page.content.uses_opacities {
-        page_writer
-            .group()
-            .transparency()
-            .isolated(false)
-            .knockout(false)
-            .color_space()
-            .srgb();
-    }
-
-    page_writer.annotations(annotations);
-
-    page_writer.finish();
-
-    chunk
-        .stream(content_id, page.content.content.wait())
-        .filter(Filter::FlateDecode);
-}
-
-/// Specification for a PDF page label.
-#[derive(Debug, Clone, PartialEq, Hash, Default)]
-pub(crate) struct PdfPageLabel {
-    /// Can be any string or none. Will always be prepended to the numbering style.
-    pub prefix: Option<EcoString>,
-    /// Based on the numbering pattern.
-    ///
-    /// If `None` or numbering is a function, the field will be empty.
-    pub style: Option<PdfPageLabelStyle>,
-    /// Offset for the page label start.
-    ///
-    /// Describes where to start counting from when setting a style.
-    /// (Has to be greater or equal than 1)
-    pub offset: Option<NonZeroUsize>,
-}
-
-/// A PDF page label number style.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum PdfPageLabelStyle {
-    /// Decimal arabic numerals (1, 2, 3).
-    Arabic,
-    /// Lowercase roman numerals (i, ii, iii).
-    LowerRoman,
-    /// Uppercase roman numerals (I, II, III).
-    UpperRoman,
-    /// Lowercase letters (`a` to `z` for the first 26 pages,
-    /// `aa` to `zz` and so on for the next).
-    LowerAlpha,
-    /// Uppercase letters (`A` to `Z` for the first 26 pages,
-    /// `AA` to `ZZ` and so on for the next).
-    UpperAlpha,
-}
-
-impl PdfPageLabel {
-    /// Create a new `PdfNumbering` from a `Numbering` applied to a page
+pub(crate) trait PageLabelExt {
+    /// Create a new `PageLabel` from a `Numbering` applied to a page
     /// number.
-    fn generate(numbering: &Numbering, number: usize) -> Option<PdfPageLabel> {
-        let Numbering::Pattern(pat) = numbering else {
-            return None;
-        };
-
-        let (prefix, kind) = pat.pieces.first()?;
-
-        // If there is a suffix, we cannot use the common style optimisation,
-        // since PDF does not provide a suffix field.
-        let style = if pat.suffix.is_empty() {
-            use typst_library::model::NumberingKind as Kind;
-            use PdfPageLabelStyle as Style;
-            match kind {
-                Kind::Arabic => Some(Style::Arabic),
-                Kind::LowerRoman => Some(Style::LowerRoman),
-                Kind::UpperRoman => Some(Style::UpperRoman),
-                Kind::LowerLatin if number <= 26 => Some(Style::LowerAlpha),
-                Kind::LowerLatin if number <= 26 => Some(Style::UpperAlpha),
-                _ => None,
-            }
-        } else {
-            None
-        };
-
-        // Prefix and offset depend on the style: If it is supported by the PDF
-        // spec, we use the given prefix and an offset. Otherwise, everything
-        // goes into prefix.
-        let prefix = if style.is_none() {
-            Some(pat.apply(&[number]))
-        } else {
-            (!prefix.is_empty()).then(|| prefix.clone())
-        };
-
-        let offset = style.and(NonZeroUsize::new(number));
-        Some(PdfPageLabel { prefix, style, offset })
-    }
+    fn generate(numbering: &Numbering, number: u64) -> Option<PageLabel>;
 
     /// Creates an arabic page label with the specified page number.
     /// For example, this will display page label `11` when given the page
     /// number 11.
-    fn arabic(number: usize) -> PdfPageLabel {
-        PdfPageLabel {
-            prefix: None,
-            style: Some(PdfPageLabelStyle::Arabic),
-            offset: NonZeroUsize::new(number),
-        }
-    }
+    fn arabic(number: u64) -> PageLabel;
 }
 
-impl PdfPageLabelStyle {
-    pub fn to_pdf_numbering_style(self) -> NumberingStyle {
-        match self {
-            PdfPageLabelStyle::Arabic => NumberingStyle::Arabic,
-            PdfPageLabelStyle::LowerRoman => NumberingStyle::LowerRoman,
-            PdfPageLabelStyle::UpperRoman => NumberingStyle::UpperRoman,
-            PdfPageLabelStyle::LowerAlpha => NumberingStyle::LowerAlpha,
-            PdfPageLabelStyle::UpperAlpha => NumberingStyle::UpperAlpha,
+impl PageLabelExt for PageLabel {
+    fn generate(numbering: &Numbering, number: u64) -> Option<PageLabel> {
+        {
+            let Numbering::Pattern(pat) = numbering else {
+                return None;
+            };
+
+            let (prefix, kind) = pat.pieces.first()?;
+
+            // If there is a suffix, we cannot use the common style optimisation,
+            // since PDF does not provide a suffix field.
+            let style = if pat.suffix.is_empty() {
+                use krilla::page::NumberingStyle as Style;
+                use typst_library::model::NumberingKind as Kind;
+                match kind {
+                    Kind::Arabic => Some(Style::Arabic),
+                    Kind::LowerRoman => Some(Style::LowerRoman),
+                    Kind::UpperRoman => Some(Style::UpperRoman),
+                    Kind::LowerLatin if number <= 26 => Some(Style::LowerAlpha),
+                    Kind::LowerLatin if number <= 26 => Some(Style::UpperAlpha),
+                    _ => None,
+                }
+            } else {
+                None
+            };
+
+            // Prefix and offset depend on the style: If it is supported by the PDF
+            // spec, we use the given prefix and an offset. Otherwise, everything
+            // goes into prefix.
+            let prefix = if style.is_none() {
+                Some(pat.apply(&[number]))
+            } else {
+                (!prefix.is_empty()).then(|| prefix.clone())
+            };
+
+            let offset = style.and(number.try_into().ok().and_then(NonZeroUsize::new));
+            Some(PageLabel::new(style, prefix.map(|s| s.to_string()), offset))
         }
     }
-}
 
-/// Data for an exported page.
-pub struct EncodedPage {
-    pub content: content::Encoded,
-    pub label: Option<PdfPageLabel>,
+    fn arabic(number: u64) -> PageLabel {
+        PageLabel::new(
+            Some(NumberingStyle::Arabic),
+            None,
+            number.try_into().ok().and_then(NonZeroUsize::new),
+        )
+    }
 }
diff --git a/crates/typst-pdf/src/paint.rs b/crates/typst-pdf/src/paint.rs
new file mode 100644
index 000000000..5224464ab
--- /dev/null
+++ b/crates/typst-pdf/src/paint.rs
@@ -0,0 +1,379 @@
+//! Convert paint types from typst to krilla.
+
+use krilla::color::{self, cmyk, luma, rgb};
+use krilla::num::NormalizedF32;
+use krilla::paint::{
+    Fill, LinearGradient, Pattern, RadialGradient, SpreadMethod, Stop, Stroke,
+    StrokeDash, SweepGradient,
+};
+use krilla::surface::Surface;
+use typst_library::diag::SourceResult;
+use typst_library::layout::{Abs, Angle, Quadrant, Ratio, Size, Transform};
+use typst_library::visualize::{
+    Color, ColorSpace, DashPattern, FillRule, FixedStroke, Gradient, Paint, RatioOrAngle,
+    RelativeTo, Tiling, WeightedColor,
+};
+use typst_utils::Numeric;
+
+use crate::convert::{handle_frame, FrameContext, GlobalContext, State};
+use crate::util::{AbsExt, FillRuleExt, LineCapExt, LineJoinExt, TransformExt};
+
+pub(crate) fn convert_fill(
+    gc: &mut GlobalContext,
+    paint_: &Paint,
+    fill_rule_: FillRule,
+    on_text: bool,
+    surface: &mut Surface,
+    state: &State,
+    size: Size,
+) -> SourceResult<Fill> {
+    let (paint, opacity) = convert_paint(gc, paint_, on_text, surface, state, size)?;
+
+    Ok(Fill {
+        paint,
+        rule: fill_rule_.to_krilla(),
+        opacity: NormalizedF32::new(opacity as f32 / 255.0).unwrap(),
+    })
+}
+
+pub(crate) fn convert_stroke(
+    fc: &mut GlobalContext,
+    stroke: &FixedStroke,
+    on_text: bool,
+    surface: &mut Surface,
+    state: &State,
+    size: Size,
+) -> SourceResult<Stroke> {
+    let (paint, opacity) =
+        convert_paint(fc, &stroke.paint, on_text, surface, state, size)?;
+
+    Ok(Stroke {
+        paint,
+        width: stroke.thickness.to_f32(),
+        miter_limit: stroke.miter_limit.get() as f32,
+        line_join: stroke.join.to_krilla(),
+        line_cap: stroke.cap.to_krilla(),
+        opacity: NormalizedF32::new(opacity as f32 / 255.0).unwrap(),
+        dash: stroke.dash.as_ref().map(convert_dash),
+    })
+}
+
+fn convert_paint(
+    gc: &mut GlobalContext,
+    paint: &Paint,
+    on_text: bool,
+    surface: &mut Surface,
+    state: &State,
+    mut size: Size,
+) -> SourceResult<(krilla::paint::Paint, u8)> {
+    // Edge cases for strokes.
+    if size.x.is_zero() {
+        size.x = Abs::pt(1.0);
+    }
+
+    if size.y.is_zero() {
+        size.y = Abs::pt(1.0);
+    }
+
+    match paint {
+        Paint::Solid(c) => {
+            let (c, a) = convert_solid(c);
+            Ok((c.into(), a))
+        }
+        Paint::Gradient(g) => Ok(convert_gradient(g, on_text, state, size)),
+        Paint::Tiling(p) => convert_pattern(gc, p, on_text, surface, state),
+    }
+}
+
+fn convert_solid(color: &Color) -> (color::Color, u8) {
+    match color.space() {
+        ColorSpace::D65Gray => {
+            let (c, a) = convert_luma(color);
+            (c.into(), a)
+        }
+        ColorSpace::Cmyk => (convert_cmyk(color).into(), 255),
+        // Convert all other colors in different colors spaces into RGB.
+        _ => {
+            let (c, a) = convert_rgb(color);
+            (c.into(), a)
+        }
+    }
+}
+
+fn convert_cmyk(color: &Color) -> cmyk::Color {
+    let components = color.to_space(ColorSpace::Cmyk).to_vec4_u8();
+
+    cmyk::Color::new(components[0], components[1], components[2], components[3])
+}
+
+fn convert_rgb(color: &Color) -> (rgb::Color, u8) {
+    let components = color.to_space(ColorSpace::Srgb).to_vec4_u8();
+    (rgb::Color::new(components[0], components[1], components[2]), components[3])
+}
+
+fn convert_luma(color: &Color) -> (luma::Color, u8) {
+    let components = color.to_space(ColorSpace::D65Gray).to_vec4_u8();
+    (luma::Color::new(components[0]), components[3])
+}
+
+fn convert_pattern(
+    gc: &mut GlobalContext,
+    pattern: &Tiling,
+    on_text: bool,
+    surface: &mut Surface,
+    state: &State,
+) -> SourceResult<(krilla::paint::Paint, u8)> {
+    let transform = correct_transform(state, pattern.unwrap_relative(on_text));
+
+    let mut stream_builder = surface.stream_builder();
+    let mut surface = stream_builder.surface();
+    let mut fc = FrameContext::new(pattern.frame().size());
+    handle_frame(&mut fc, pattern.frame(), None, &mut surface, gc)?;
+    surface.finish();
+    let stream = stream_builder.finish();
+    let pattern = Pattern {
+        stream,
+        transform: transform.to_krilla(),
+        width: (pattern.size().x + pattern.spacing().x).to_pt() as _,
+        height: (pattern.size().y + pattern.spacing().y).to_pt() as _,
+    };
+
+    Ok((pattern.into(), 255))
+}
+
+fn convert_gradient(
+    gradient: &Gradient,
+    on_text: bool,
+    state: &State,
+    size: Size,
+) -> (krilla::paint::Paint, u8) {
+    let size = match gradient.unwrap_relative(on_text) {
+        RelativeTo::Self_ => size,
+        RelativeTo::Parent => state.container_size(),
+    };
+
+    let angle = gradient.angle().unwrap_or_else(Angle::zero);
+    let base_transform = correct_transform(state, gradient.unwrap_relative(on_text));
+    let stops = convert_gradient_stops(gradient);
+    match &gradient {
+        Gradient::Linear(_) => {
+            let (x1, y1, x2, y2) = {
+                let (mut sin, mut cos) = (angle.sin(), angle.cos());
+
+                // Scale to edges of unit square.
+                let factor = cos.abs() + sin.abs();
+                sin *= factor;
+                cos *= factor;
+
+                match angle.quadrant() {
+                    Quadrant::First => (0.0, 0.0, cos as f32, sin as f32),
+                    Quadrant::Second => (1.0, 0.0, cos as f32 + 1.0, sin as f32),
+                    Quadrant::Third => (1.0, 1.0, cos as f32 + 1.0, sin as f32 + 1.0),
+                    Quadrant::Fourth => (0.0, 1.0, cos as f32, sin as f32 + 1.0),
+                }
+            };
+
+            let linear = LinearGradient {
+                x1,
+                y1,
+                x2,
+                y2,
+                // x and y coordinates are normalized, so need to scale by the size.
+                transform: base_transform
+                    .pre_concat(Transform::scale(
+                        Ratio::new(size.x.to_f32() as f64),
+                        Ratio::new(size.y.to_f32() as f64),
+                    ))
+                    .to_krilla(),
+                spread_method: SpreadMethod::Pad,
+                stops,
+                anti_alias: gradient.anti_alias(),
+            };
+
+            (linear.into(), 255)
+        }
+        Gradient::Radial(radial) => {
+            let radial = RadialGradient {
+                fx: radial.focal_center.x.get() as f32,
+                fy: radial.focal_center.y.get() as f32,
+                fr: radial.focal_radius.get() as f32,
+                cx: radial.center.x.get() as f32,
+                cy: radial.center.y.get() as f32,
+                cr: radial.radius.get() as f32,
+                transform: base_transform
+                    .pre_concat(Transform::scale(
+                        Ratio::new(size.x.to_f32() as f64),
+                        Ratio::new(size.y.to_f32() as f64),
+                    ))
+                    .to_krilla(),
+                spread_method: SpreadMethod::Pad,
+                stops,
+                anti_alias: gradient.anti_alias(),
+            };
+
+            (radial.into(), 255)
+        }
+        Gradient::Conic(conic) => {
+            // Correct the gradient's angle.
+            let cx = size.x.to_f32() * conic.center.x.get() as f32;
+            let cy = size.y.to_f32() * conic.center.y.get() as f32;
+            let actual_transform = base_transform
+                // Adjust for the angle.
+                .pre_concat(Transform::rotate_at(
+                    angle,
+                    Abs::pt(cx as f64),
+                    Abs::pt(cy as f64),
+                ))
+                // Default start point in krilla and typst are at the opposite side, so we need
+                // to flip it horizontally.
+                .pre_concat(Transform::scale_at(
+                    -Ratio::one(),
+                    Ratio::one(),
+                    Abs::pt(cx as f64),
+                    Abs::pt(cy as f64),
+                ));
+
+            let sweep = SweepGradient {
+                cx,
+                cy,
+                start_angle: 0.0,
+                end_angle: 360.0,
+                transform: actual_transform.to_krilla(),
+                spread_method: SpreadMethod::Pad,
+                stops,
+                anti_alias: gradient.anti_alias(),
+            };
+
+            (sweep.into(), 255)
+        }
+    }
+}
+
+fn convert_gradient_stops(gradient: &Gradient) -> Vec<Stop> {
+    let mut stops = vec![];
+
+    let use_cmyk = gradient.stops().iter().all(|s| s.color.space() == ColorSpace::Cmyk);
+
+    let mut add_single = |color: &Color, offset: Ratio| {
+        let (color, opacity) = if use_cmyk {
+            (convert_cmyk(color).into(), 255)
+        } else {
+            let (c, a) = convert_rgb(color);
+            (c.into(), a)
+        };
+
+        let opacity = NormalizedF32::new((opacity as f32) / 255.0).unwrap();
+        let offset = NormalizedF32::new(offset.get() as f32).unwrap();
+        let stop = Stop { offset, color, opacity };
+        stops.push(stop);
+    };
+
+    // Convert stops.
+    match &gradient {
+        Gradient::Linear(_) | Gradient::Radial(_) => {
+            if let Some(s) = gradient.stops().first() {
+                add_single(&s.color, s.offset.unwrap());
+            }
+
+            // Create the individual gradient functions for each pair of stops.
+            for window in gradient.stops().windows(2) {
+                let (first, second) = (window[0], window[1]);
+
+                // If we have a hue index or are using Oklab, we will create several
+                // stops in-between to make the gradient smoother without interpolation
+                // issues with native color spaces.
+                if gradient.space().hue_index().is_some() {
+                    for i in 0..=32 {
+                        let t = i as f64 / 32.0;
+                        let real_t = Ratio::new(
+                            first.offset.unwrap().get() * (1.0 - t)
+                                + second.offset.unwrap().get() * t,
+                        );
+
+                        let c = gradient.sample(RatioOrAngle::Ratio(real_t));
+                        add_single(&c, real_t);
+                    }
+                }
+
+                add_single(&second.color, second.offset.unwrap());
+            }
+        }
+        Gradient::Conic(conic) => {
+            if let Some((c, t)) = conic.stops.first() {
+                add_single(c, *t);
+            }
+
+            for window in conic.stops.windows(2) {
+                let ((c0, t0), (c1, t1)) = (window[0], window[1]);
+
+                // Precision:
+                // - On an even color, insert a stop every 90deg.
+                // - For a hue-based color space, insert 200 stops minimum.
+                // - On any other, insert 20 stops minimum.
+                let max_dt = if c0 == c1 {
+                    0.25
+                } else if conic.space.hue_index().is_some() {
+                    0.005
+                } else {
+                    0.05
+                };
+
+                let mut t_x = t0.get();
+                let dt = (t1.get() - t0.get()).min(max_dt);
+
+                // Special casing for sharp gradients.
+                if t0 == t1 {
+                    add_single(&c1, t1);
+                    continue;
+                }
+
+                while t_x < t1.get() {
+                    let t_next = (t_x + dt).min(t1.get());
+
+                    // The current progress in the current window.
+                    let t = |t| (t - t0.get()) / (t1.get() - t0.get());
+
+                    let c_next = Color::mix_iter(
+                        [
+                            WeightedColor::new(c0, 1.0 - t(t_next)),
+                            WeightedColor::new(c1, t(t_next)),
+                        ],
+                        conic.space,
+                    )
+                    .unwrap();
+
+                    add_single(&c_next, Ratio::new(t_next));
+                    t_x = t_next;
+                }
+
+                add_single(&c1, t1);
+            }
+        }
+    }
+
+    stops
+}
+
+fn convert_dash(dash: &DashPattern<Abs, Abs>) -> StrokeDash {
+    StrokeDash {
+        array: dash.array.iter().map(|e| e.to_f32()).collect(),
+        offset: dash.phase.to_f32(),
+    }
+}
+
+fn correct_transform(state: &State, relative: RelativeTo) -> Transform {
+    // In krilla, if we have a shape with a transform and a complex paint,
+    // then the paint will inherit the transform of the shape.
+    match relative {
+        // Because of the above, we don't need to apply an additional transform here.
+        RelativeTo::Self_ => Transform::identity(),
+        // Because of the above, we need to first reverse the transform that will be
+        // applied from the shape, and then re-apply the transform that is used for
+        // the next parent container.
+        RelativeTo::Parent => state
+            .transform()
+            .invert()
+            .unwrap()
+            .pre_concat(state.container_transform()),
+    }
+}
diff --git a/crates/typst-pdf/src/resources.rs b/crates/typst-pdf/src/resources.rs
deleted file mode 100644
index bdbf2f1e4..000000000
--- a/crates/typst-pdf/src/resources.rs
+++ /dev/null
@@ -1,349 +0,0 @@
-//! PDF resources.
-//!
-//! Resources are defined in dictionaries. They map identifiers such as `Im0` to
-//! a PDF reference. Each [content stream] is associated with a resource dictionary.
-//! The identifiers defined in the resources can then be used in content streams.
-//!
-//! [content stream]: `crate::content`
-
-use std::collections::{BTreeMap, HashMap};
-use std::hash::Hash;
-
-use ecow::{eco_format, EcoString};
-use pdf_writer::{Dict, Finish, Name, Ref};
-use subsetter::GlyphRemapper;
-use typst_library::diag::{SourceResult, StrResult};
-use typst_library::text::{Font, Lang};
-use typst_library::visualize::Image;
-use typst_syntax::Span;
-use typst_utils::Deferred;
-
-use crate::color::ColorSpaces;
-use crate::color_font::ColorFontMap;
-use crate::extg::ExtGState;
-use crate::gradient::PdfGradient;
-use crate::image::EncodedImage;
-use crate::tiling::TilingRemapper;
-use crate::{PdfChunk, Renumber, WithEverything, WithResources};
-
-/// All the resources that have been collected when traversing the document.
-///
-/// This does not allocate references to resources, only track what was used
-/// and deduplicate what can be deduplicated.
-///
-/// You may notice that this structure is a tree: [`TilingRemapper`] and
-/// [`ColorFontMap`] (that are present in the fields of [`Resources`]),
-/// themselves contain [`Resources`] (that will be called "sub-resources" from
-/// now on). Because color glyphs and tilings are defined using content
-/// streams, just like pages, they can refer to resources too, which are tracked
-/// by the respective sub-resources.
-///
-/// Each instance of this structure will become a `/Resources` dictionary in
-/// the final PDF. It is not possible to use a single shared dictionary for all
-/// pages, tilings and color fonts, because if a resource is listed in its own
-/// `/Resources` dictionary, some PDF readers will fail to open the document.
-///
-/// Because we need to lazily initialize sub-resources (we don't know how deep
-/// the tree will be before reading the document), and that this is done in a
-/// context where no PDF reference allocator is available, `Resources` are
-/// originally created with the type parameter `R = ()`. The reference for each
-/// dictionary will only be allocated in the next phase, once we know the shape
-/// of the tree, at which point `R` becomes `Ref`. No other value of `R` should
-/// ever exist.
-pub struct Resources<R = Ref> {
-    /// The global reference to this resource dictionary, or `()` if it has not
-    /// been allocated yet.
-    pub reference: R,
-
-    /// Handles color space writing.
-    pub colors: ColorSpaces,
-
-    /// Deduplicates fonts used across the document.
-    pub fonts: Remapper<Font>,
-    /// Deduplicates images used across the document.
-    pub images: Remapper<Image>,
-    /// Handles to deferred image conversions.
-    pub deferred_images: HashMap<usize, (Deferred<StrResult<EncodedImage>>, Span)>,
-    /// Deduplicates gradients used across the document.
-    pub gradients: Remapper<PdfGradient>,
-    /// Deduplicates tilings used across the document.
-    pub tilings: Option<Box<TilingRemapper<R>>>,
-    /// Deduplicates external graphics states used across the document.
-    pub ext_gs: Remapper<ExtGState>,
-    /// Deduplicates color glyphs.
-    pub color_fonts: Option<Box<ColorFontMap<R>>>,
-
-    // The fields below do not correspond to actual resources that will be
-    // written in a dictionary, but are more meta-data about resources that
-    // can't really live somewhere else.
-    /// The number of glyphs for all referenced languages in the content stream.
-    /// We keep track of this to determine the main document language.
-    /// BTreeMap is used to write sorted list of languages to metadata.
-    pub languages: BTreeMap<Lang, usize>,
-
-    /// For each font a mapping from used glyphs to their text representation.
-    /// This is used for the PDF's /ToUnicode map, and important for copy-paste
-    /// and searching.
-    ///
-    /// Note that the text representation may contain multiple chars in case of
-    /// ligatures or similar things, and it may have no entry in the font's cmap
-    /// (or only a private-use codepoint), like the “Th” in Linux Libertine.
-    ///
-    /// A glyph may have multiple entries in the font's cmap, and even the same
-    /// glyph can have a different text representation within one document.
-    /// But /ToUnicode does not support that, so we just save the first occurrence.
-    pub glyph_sets: HashMap<Font, BTreeMap<u16, EcoString>>,
-    /// Same as `glyph_sets`, but for color fonts.
-    pub color_glyph_sets: HashMap<Font, BTreeMap<u16, EcoString>>,
-    /// Stores the glyph remapper for each font for the subsetter.
-    pub glyph_remappers: HashMap<Font, GlyphRemapper>,
-}
-
-impl<R: Renumber> Renumber for Resources<R> {
-    fn renumber(&mut self, offset: i32) {
-        self.reference.renumber(offset);
-
-        if let Some(color_fonts) = &mut self.color_fonts {
-            color_fonts.resources.renumber(offset);
-        }
-
-        if let Some(tilings) = &mut self.tilings {
-            tilings.resources.renumber(offset);
-        }
-    }
-}
-
-impl Default for Resources<()> {
-    fn default() -> Self {
-        Resources {
-            reference: (),
-            colors: ColorSpaces::default(),
-            fonts: Remapper::new("F"),
-            images: Remapper::new("Im"),
-            deferred_images: HashMap::new(),
-            gradients: Remapper::new("Gr"),
-            tilings: None,
-            ext_gs: Remapper::new("Gs"),
-            color_fonts: None,
-            languages: BTreeMap::new(),
-            glyph_sets: HashMap::new(),
-            color_glyph_sets: HashMap::new(),
-            glyph_remappers: HashMap::new(),
-        }
-    }
-}
-
-impl Resources<()> {
-    /// Associate a reference with this resource dictionary (and do so
-    /// recursively for sub-resources).
-    pub fn with_refs(self, refs: &ResourcesRefs) -> Resources<Ref> {
-        Resources {
-            reference: refs.reference,
-            colors: self.colors,
-            fonts: self.fonts,
-            images: self.images,
-            deferred_images: self.deferred_images,
-            gradients: self.gradients,
-            tilings: self
-                .tilings
-                .zip(refs.tilings.as_ref())
-                .map(|(p, r)| Box::new(p.with_refs(r))),
-            ext_gs: self.ext_gs,
-            color_fonts: self
-                .color_fonts
-                .zip(refs.color_fonts.as_ref())
-                .map(|(c, r)| Box::new(c.with_refs(r))),
-            languages: self.languages,
-            glyph_sets: self.glyph_sets,
-            color_glyph_sets: self.color_glyph_sets,
-            glyph_remappers: self.glyph_remappers,
-        }
-    }
-}
-
-impl<R> Resources<R> {
-    /// Run a function on this resource dictionary and all
-    /// of its sub-resources.
-    pub fn traverse<P>(&self, process: &mut P) -> SourceResult<()>
-    where
-        P: FnMut(&Self) -> SourceResult<()>,
-    {
-        process(self)?;
-        if let Some(color_fonts) = &self.color_fonts {
-            color_fonts.resources.traverse(process)?;
-        }
-        if let Some(tilings) = &self.tilings {
-            tilings.resources.traverse(process)?;
-        }
-        Ok(())
-    }
-}
-
-/// References for a resource tree.
-///
-/// This structure is a tree too, that should have the same structure as the
-/// corresponding `Resources`.
-pub struct ResourcesRefs {
-    pub reference: Ref,
-    pub color_fonts: Option<Box<ResourcesRefs>>,
-    pub tilings: Option<Box<ResourcesRefs>>,
-}
-
-impl Renumber for ResourcesRefs {
-    fn renumber(&mut self, offset: i32) {
-        self.reference.renumber(offset);
-        if let Some(color_fonts) = &mut self.color_fonts {
-            color_fonts.renumber(offset);
-        }
-        if let Some(tilings) = &mut self.tilings {
-            tilings.renumber(offset);
-        }
-    }
-}
-
-/// Allocate references for all resource dictionaries.
-pub fn alloc_resources_refs(
-    context: &WithResources,
-) -> SourceResult<(PdfChunk, ResourcesRefs)> {
-    let mut chunk = PdfChunk::new();
-    /// Recursively explore resource dictionaries and assign them references.
-    fn refs_for(resources: &Resources<()>, chunk: &mut PdfChunk) -> ResourcesRefs {
-        ResourcesRefs {
-            reference: chunk.alloc(),
-            color_fonts: resources
-                .color_fonts
-                .as_ref()
-                .map(|c| Box::new(refs_for(&c.resources, chunk))),
-            tilings: resources
-                .tilings
-                .as_ref()
-                .map(|p| Box::new(refs_for(&p.resources, chunk))),
-        }
-    }
-
-    let refs = refs_for(&context.resources, &mut chunk);
-    Ok((chunk, refs))
-}
-
-/// Write the resource dictionaries that will be referenced by all pages.
-///
-/// We add a reference to this dictionary to each page individually instead of
-/// to the root node of the page tree because using the resource inheritance
-/// feature breaks PDF merging with Apple Preview.
-///
-/// Also write resource dictionaries for Type3 fonts and PDF patterns.
-pub fn write_resource_dictionaries(ctx: &WithEverything) -> SourceResult<(PdfChunk, ())> {
-    let mut chunk = PdfChunk::new();
-    let mut used_color_spaces = ColorSpaces::default();
-
-    ctx.resources.traverse(&mut |resources| {
-        used_color_spaces.merge(&resources.colors);
-
-        let images_ref = chunk.alloc.bump();
-        let patterns_ref = chunk.alloc.bump();
-        let ext_gs_states_ref = chunk.alloc.bump();
-        let color_spaces_ref = chunk.alloc.bump();
-
-        let mut color_font_slices = Vec::new();
-        let mut color_font_numbers = HashMap::new();
-        if let Some(color_fonts) = &resources.color_fonts {
-            for (_, font_slice) in color_fonts.iter() {
-                color_font_numbers.insert(font_slice.clone(), color_font_slices.len());
-                color_font_slices.push(font_slice);
-            }
-        }
-        let color_font_remapper = Remapper {
-            prefix: "Cf",
-            to_pdf: color_font_numbers,
-            to_items: color_font_slices,
-        };
-
-        resources
-            .images
-            .write(&ctx.references.images, &mut chunk.indirect(images_ref).dict());
-
-        let mut patterns_dict = chunk.indirect(patterns_ref).dict();
-        resources
-            .gradients
-            .write(&ctx.references.gradients, &mut patterns_dict);
-        if let Some(p) = &resources.tilings {
-            p.remapper.write(&ctx.references.tilings, &mut patterns_dict);
-        }
-        patterns_dict.finish();
-
-        resources
-            .ext_gs
-            .write(&ctx.references.ext_gs, &mut chunk.indirect(ext_gs_states_ref).dict());
-
-        let mut res_dict = chunk
-            .indirect(resources.reference)
-            .start::<pdf_writer::writers::Resources>();
-        res_dict.pair(Name(b"XObject"), images_ref);
-        res_dict.pair(Name(b"Pattern"), patterns_ref);
-        res_dict.pair(Name(b"ExtGState"), ext_gs_states_ref);
-        res_dict.pair(Name(b"ColorSpace"), color_spaces_ref);
-
-        // TODO: can't this be an indirect reference too?
-        let mut fonts_dict = res_dict.fonts();
-        resources.fonts.write(&ctx.references.fonts, &mut fonts_dict);
-        color_font_remapper.write(&ctx.references.color_fonts, &mut fonts_dict);
-        fonts_dict.finish();
-
-        res_dict.finish();
-
-        let color_spaces = chunk.indirect(color_spaces_ref).dict();
-        resources
-            .colors
-            .write_color_spaces(color_spaces, &ctx.globals.color_functions);
-
-        Ok(())
-    })?;
-
-    used_color_spaces.write_functions(&mut chunk, &ctx.globals.color_functions);
-
-    Ok((chunk, ()))
-}
-
-/// Assigns new, consecutive PDF-internal indices to items.
-pub struct Remapper<T> {
-    /// The prefix to use when naming these resources.
-    prefix: &'static str,
-    /// Forwards from the items to the pdf indices.
-    to_pdf: HashMap<T, usize>,
-    /// Backwards from the pdf indices to the items.
-    to_items: Vec<T>,
-}
-
-impl<T> Remapper<T>
-where
-    T: Eq + Hash + Clone,
-{
-    /// Create an empty mapping.
-    pub fn new(prefix: &'static str) -> Self {
-        Self { prefix, to_pdf: HashMap::new(), to_items: vec![] }
-    }
-
-    /// Insert an item in the mapping if it was not already present.
-    pub fn insert(&mut self, item: T) -> usize {
-        let to_layout = &mut self.to_items;
-        *self.to_pdf.entry(item.clone()).or_insert_with(|| {
-            let pdf_index = to_layout.len();
-            to_layout.push(item);
-            pdf_index
-        })
-    }
-
-    /// All items in this
-    pub fn items(&self) -> impl Iterator<Item = &T> + '_ {
-        self.to_items.iter()
-    }
-
-    /// Write this list of items in a Resource dictionary.
-    fn write(&self, mapping: &HashMap<T, Ref>, dict: &mut Dict) {
-        for (number, item) in self.items().enumerate() {
-            let name = eco_format!("{}{}", self.prefix, number);
-            let reference = mapping[item];
-            dict.pair(Name(name.as_bytes()), reference);
-        }
-    }
-}
diff --git a/crates/typst-pdf/src/shape.rs b/crates/typst-pdf/src/shape.rs
new file mode 100644
index 000000000..5b9232dbe
--- /dev/null
+++ b/crates/typst-pdf/src/shape.rs
@@ -0,0 +1,106 @@
+use krilla::geom::{Path, PathBuilder, Rect};
+use krilla::surface::Surface;
+use typst_library::diag::SourceResult;
+use typst_library::visualize::{Geometry, Shape};
+use typst_syntax::Span;
+
+use crate::convert::{FrameContext, GlobalContext};
+use crate::paint;
+use crate::util::{convert_path, AbsExt, TransformExt};
+
+#[typst_macros::time(name = "handle shape")]
+pub(crate) fn handle_shape(
+    fc: &mut FrameContext,
+    shape: &Shape,
+    surface: &mut Surface,
+    gc: &mut GlobalContext,
+    span: Span,
+) -> SourceResult<()> {
+    surface.set_location(span.into_raw().get());
+    surface.push_transform(&fc.state().transform().to_krilla());
+
+    if let Some(path) = convert_geometry(&shape.geometry) {
+        let fill = if let Some(paint) = &shape.fill {
+            Some(paint::convert_fill(
+                gc,
+                paint,
+                shape.fill_rule,
+                false,
+                surface,
+                fc.state(),
+                shape.geometry.bbox_size(),
+            )?)
+        } else {
+            None
+        };
+
+        let stroke = shape.stroke.as_ref().and_then(|stroke| {
+            if stroke.thickness.to_f32() > 0.0 {
+                Some(stroke)
+            } else {
+                None
+            }
+        });
+
+        let stroke = if let Some(stroke) = &stroke {
+            let stroke = paint::convert_stroke(
+                gc,
+                stroke,
+                false,
+                surface,
+                fc.state(),
+                shape.geometry.bbox_size(),
+            )?;
+
+            Some(stroke)
+        } else {
+            None
+        };
+
+        // Otherwise, krilla will by default fill with a black paint.
+        if fill.is_some() || stroke.is_some() {
+            surface.set_fill(fill);
+            surface.set_stroke(stroke);
+            surface.draw_path(&path);
+        }
+    }
+
+    surface.pop();
+    surface.reset_location();
+
+    Ok(())
+}
+
+fn convert_geometry(geometry: &Geometry) -> Option<Path> {
+    let mut path_builder = PathBuilder::new();
+
+    match geometry {
+        Geometry::Line(l) => {
+            path_builder.move_to(0.0, 0.0);
+            path_builder.line_to(l.x.to_f32(), l.y.to_f32());
+        }
+        Geometry::Rect(size) => {
+            let w = size.x.to_f32();
+            let h = size.y.to_f32();
+            let rect = if w < 0.0 || h < 0.0 {
+                // krilla doesn't normally allow for negative dimensions, but
+                // Typst supports them, so we apply a transform if needed.
+                let transform =
+                    krilla::geom::Transform::from_scale(w.signum(), h.signum());
+                Rect::from_xywh(0.0, 0.0, w.abs(), h.abs())
+                    .and_then(|rect| rect.transform(transform))
+            } else {
+                Rect::from_xywh(0.0, 0.0, w, h)
+            };
+
+            if let Some(rect) = rect {
+                path_builder.push_rect(rect);
+            }
+        }
+        Geometry::Curve(c) => {
+            convert_path(c, &mut path_builder);
+        }
+    }
+
+    path_builder.finish()
+}
diff --git a/crates/typst-pdf/src/text.rs b/crates/typst-pdf/src/text.rs
new file mode 100644
index 000000000..9876927d0
--- /dev/null
+++ b/crates/typst-pdf/src/text.rs
@@ -0,0 +1,137 @@
+use std::ops::Range;
+use std::sync::Arc;
+
+use bytemuck::TransparentWrapper;
+use krilla::surface::{Location, Surface};
+use krilla::text::GlyphId;
+use typst_library::diag::{bail, SourceResult};
+use typst_library::layout::Size;
+use typst_library::text::{Font, Glyph, TextItem};
+use typst_library::visualize::FillRule;
+use typst_syntax::Span;
+
+use crate::convert::{FrameContext, GlobalContext};
+use crate::paint;
+use crate::util::{display_font, AbsExt, TransformExt};
+
+#[typst_macros::time(name = "handle text")]
+pub(crate) fn handle_text(
+    fc: &mut FrameContext,
+    t: &TextItem,
+    surface: &mut Surface,
+    gc: &mut GlobalContext,
+) -> SourceResult<()> {
+    *gc.languages.entry(t.lang).or_insert(0) += t.glyphs.len();
+
+    let font = convert_font(gc, t.font.clone())?;
+    let fill = paint::convert_fill(
+        gc,
+        &t.fill,
+        FillRule::NonZero,
+        true,
+        surface,
+        fc.state(),
+        Size::zero(),
+    )?;
+    let stroke =
+        if let Some(stroke) = t.stroke.as_ref().map(|s| {
+            paint::convert_stroke(gc, s, true, surface, fc.state(), Size::zero())
+        }) {
+            Some(stroke?)
+        } else {
+            None
+        };
+    let text = t.text.as_str();
+    let size = t.size;
+    let glyphs: &[PdfGlyph] = TransparentWrapper::wrap_slice(t.glyphs.as_slice());
+
+    surface.push_transform(&fc.state().transform().to_krilla());
+    surface.set_fill(Some(fill));
+    surface.set_stroke(stroke);
+    surface.draw_glyphs(
+        krilla::geom::Point::from_xy(0.0, 0.0),
+        glyphs,
+        font.clone(),
+        text,
+        size.to_f32(),
+        false,
+    );
+
+    surface.pop();
+
+    Ok(())
+}
+
+fn convert_font(
+    gc: &mut GlobalContext,
+    typst_font: Font,
+) -> SourceResult<krilla::text::Font> {
+    if let Some(font) = gc.fonts_forward.get(&typst_font) {
+        Ok(font.clone())
+    } else {
+        let font = build_font(typst_font.clone())?;
+
+        gc.fonts_forward.insert(typst_font.clone(), font.clone());
+        gc.fonts_backward.insert(font.clone(), typst_font.clone());
+
+        Ok(font)
+    }
+}
+
+#[comemo::memoize]
+fn build_font(typst_font: Font) -> SourceResult<krilla::text::Font> {
+    let font_data: Arc<dyn AsRef<[u8]> + Send + Sync> =
+        Arc::new(typst_font.data().clone());
+
+    match krilla::text::Font::new(font_data.into(), typst_font.index()) {
+        None => {
+            let font_str = display_font(&typst_font);
+            bail!(Span::detached(), "failed to process font {font_str}");
+        }
+        Some(f) => Ok(f),
+    }
+}
+
+#[derive(TransparentWrapper, Debug)]
+#[repr(transparent)]
+struct PdfGlyph(Glyph);
+
+impl krilla::text::Glyph for PdfGlyph {
+    #[inline(always)]
+    fn glyph_id(&self) -> GlyphId {
+        GlyphId::new(self.0.id as u32)
+    }
+
+    #[inline(always)]
+    fn text_range(&self) -> Range<usize> {
+        self.0.range.start as usize..self.0.range.end as usize
+    }
+
+    #[inline(always)]
+    fn x_advance(&self, size: f32) -> f32 {
+        // Don't use `Em::at`, because it contains an expensive check whether the result is finite.
+        self.0.x_advance.get() as f32 * size
+    }
+
+    #[inline(always)]
+    fn x_offset(&self, size: f32) -> f32 {
+        // Don't use `Em::at`, because it contains an expensive check whether the result is finite.
+        self.0.x_offset.get() as f32 * size
+    }
+
+    #[inline(always)]
+    fn y_offset(&self, size: f32) -> f32 {
+        // Don't use `Em::at`, because it contains an expensive check whether the result is finite.
+        self.0.y_offset.get() as f32 * size
+    }
+
+    #[inline(always)]
+    fn y_advance(&self, size: f32) -> f32 {
+        // Don't use `Em::at`, because it contains an expensive check whether the result is finite.
+        self.0.y_advance.get() as f32 * size
+    }
+
+    fn location(&self) -> Option<Location> {
+        Some(self.0.span.0.into_raw().get())
+    }
+}
diff --git a/crates/typst-pdf/src/tiling.rs b/crates/typst-pdf/src/tiling.rs
deleted file mode 100644
index f8950f344..000000000
--- a/crates/typst-pdf/src/tiling.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use std::collections::HashMap;
-
-use ecow::eco_format;
-use pdf_writer::types::{ColorSpaceOperand, PaintType, TilingType};
-use pdf_writer::{Filter, Name, Rect, Ref};
-use typst_library::diag::SourceResult;
-use typst_library::layout::{Abs, Ratio, Transform};
-use typst_library::visualize::{RelativeTo, Tiling};
-use typst_utils::Numeric;
-
-use crate::color::PaintEncode;
-use crate::resources::{Remapper, ResourcesRefs};
-use crate::{content, transform_to_array, PdfChunk, Resources, WithGlobalRefs};
-
-/// Writes the actual patterns (tiling patterns) to the PDF.
-/// This is performed once after writing all pages.
-pub fn write_tilings(
-    context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<PdfTiling, Ref>)> {
-    let mut chunk = PdfChunk::new();
-    let mut out = HashMap::new();
-    context.resources.traverse(&mut |resources| {
-        let Some(patterns) = &resources.tilings else {
-            return Ok(());
-        };
-
-        for pdf_pattern in patterns.remapper.items() {
-            let PdfTiling { transform, pattern, content, .. } = pdf_pattern;
-            if out.contains_key(pdf_pattern) {
-                continue;
-            }
-
-            let tiling = chunk.alloc();
-            out.insert(pdf_pattern.clone(), tiling);
-
-            let mut tiling_pattern = chunk.tiling_pattern(tiling, content);
-            tiling_pattern
-                .tiling_type(TilingType::ConstantSpacing)
-                .paint_type(PaintType::Colored)
-                .bbox(Rect::new(
-                    0.0,
-                    0.0,
-                    pattern.size().x.to_pt() as _,
-                    pattern.size().y.to_pt() as _,
-                ))
-                .x_step((pattern.size().x + pattern.spacing().x).to_pt() as _)
-                .y_step((pattern.size().y + pattern.spacing().y).to_pt() as _);
-
-            // The actual resource dict will be written in a later step
-            tiling_pattern.pair(Name(b"Resources"), patterns.resources.reference);
-
-            tiling_pattern
-                .matrix(transform_to_array(
-                    transform
-                        .pre_concat(Transform::scale(Ratio::one(), -Ratio::one()))
-                        .post_concat(Transform::translate(
-                            Abs::zero(),
-                            pattern.spacing().y,
-                        )),
-                ))
-                .filter(Filter::FlateDecode);
-        }
-
-        Ok(())
-    })?;
-
-    Ok((chunk, out))
-}
-
-/// A pattern and its transform.
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct PdfTiling {
-    /// The transform to apply to the pattern.
-    pub transform: Transform,
-    /// The pattern to paint.
-    pub pattern: Tiling,
-    /// The rendered pattern.
-    pub content: Vec<u8>,
-}
-
-/// Registers a pattern with the PDF.
-fn register_pattern(
-    ctx: &mut content::Builder,
-    pattern: &Tiling,
-    on_text: bool,
-    mut transforms: content::Transforms,
-) -> SourceResult<usize> {
-    let patterns = ctx
-        .resources
-        .tilings
-        .get_or_insert_with(|| Box::new(TilingRemapper::new()));
-
-    // Edge cases for strokes.
-    if transforms.size.x.is_zero() {
-        transforms.size.x = Abs::pt(1.0);
-    }
-
-    if transforms.size.y.is_zero() {
-        transforms.size.y = Abs::pt(1.0);
-    }
-
-    let transform = match pattern.unwrap_relative(on_text) {
-        RelativeTo::Self_ => transforms.transform,
-        RelativeTo::Parent => transforms.container_transform,
-    };
-
-    // Render the body.
-    let content = content::build(
-        ctx.options,
-        &mut patterns.resources,
-        pattern.frame(),
-        None,
-        None,
-    )?;
-
-    let pdf_pattern = PdfTiling {
-        transform,
-        pattern: pattern.clone(),
-        content: content.content.wait().clone(),
-    };
-
-    Ok(patterns.remapper.insert(pdf_pattern))
-}
-
-impl PaintEncode for Tiling {
-    fn set_as_fill(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        ctx.reset_fill_color_space();
-
-        let index = register_pattern(ctx, self, on_text, transforms)?;
-        let id = eco_format!("P{index}");
-        let name = Name(id.as_bytes());
-
-        ctx.content.set_fill_color_space(ColorSpaceOperand::Pattern);
-        ctx.content.set_fill_pattern(None, name);
-        Ok(())
-    }
-
-    fn set_as_stroke(
-        &self,
-        ctx: &mut content::Builder,
-        on_text: bool,
-        transforms: content::Transforms,
-    ) -> SourceResult<()> {
-        ctx.reset_stroke_color_space();
-
-        let index = register_pattern(ctx, self, on_text, transforms)?;
-        let id = eco_format!("P{index}");
-        let name = Name(id.as_bytes());
-
-        ctx.content.set_stroke_color_space(ColorSpaceOperand::Pattern);
-        ctx.content.set_stroke_pattern(None, name);
-        Ok(())
-    }
-}
-
-/// De-duplicate patterns and the resources they require to be drawn.
-pub struct TilingRemapper<R> {
-    /// Pattern de-duplicator.
-    pub remapper: Remapper<PdfTiling>,
-    /// PDF resources that are used by these patterns.
-    pub resources: Resources<R>,
-}
-
-impl TilingRemapper<()> {
-    pub fn new() -> Self {
-        Self {
-            remapper: Remapper::new("P"),
-            resources: Resources::default(),
-        }
-    }
-
-    /// Allocate a reference to the resource dictionary of these patterns.
-    pub fn with_refs(self, refs: &ResourcesRefs) -> TilingRemapper<Ref> {
-        TilingRemapper {
-            remapper: self.remapper,
-            resources: self.resources.with_refs(refs),
-        }
-    }
-}
diff --git a/crates/typst-pdf/src/util.rs b/crates/typst-pdf/src/util.rs
new file mode 100644
index 000000000..3b85d0b8a
--- /dev/null
+++ b/crates/typst-pdf/src/util.rs
@@ -0,0 +1,120 @@
+//! Basic utilities for converting typst types to krilla.
+
+use krilla::geom as kg;
+use krilla::geom::PathBuilder;
+use krilla::paint as kp;
+use typst_library::layout::{Abs, Point, Size, Transform};
+use typst_library::text::Font;
+use typst_library::visualize::{Curve, CurveItem, FillRule, LineCap, LineJoin};
+
+pub(crate) trait SizeExt {
+    fn to_krilla(&self) -> kg::Size;
+}
+
+impl SizeExt for Size {
+    fn to_krilla(&self) -> kg::Size {
+        kg::Size::from_wh(self.x.to_f32(), self.y.to_f32()).unwrap()
+    }
+}
+
+pub(crate) trait PointExt {
+    fn to_krilla(&self) -> kg::Point;
+}
+
+impl PointExt for Point {
+    fn to_krilla(&self) -> kg::Point {
+        kg::Point::from_xy(self.x.to_f32(), self.y.to_f32())
+    }
+}
+
+pub(crate) trait LineCapExt {
+    fn to_krilla(&self) -> kp::LineCap;
+}
+
+impl LineCapExt for LineCap {
+    fn to_krilla(&self) -> kp::LineCap {
+        match self {
+            LineCap::Butt => kp::LineCap::Butt,
+            LineCap::Round => kp::LineCap::Round,
+            LineCap::Square => kp::LineCap::Square,
+        }
+    }
+}
+
+pub(crate) trait LineJoinExt {
+    fn to_krilla(&self) -> kp::LineJoin;
+}
+
+impl LineJoinExt for LineJoin {
+    fn to_krilla(&self) -> kp::LineJoin {
+        match self {
+            LineJoin::Miter => kp::LineJoin::Miter,
+            LineJoin::Round => kp::LineJoin::Round,
+            LineJoin::Bevel => kp::LineJoin::Bevel,
+        }
+    }
+}
+
+pub(crate) trait TransformExt {
+    fn to_krilla(&self) -> kg::Transform;
+}
+
+impl TransformExt for Transform {
+    fn to_krilla(&self) -> kg::Transform {
+        kg::Transform::from_row(
+            self.sx.get() as f32,
+            self.ky.get() as f32,
+            self.kx.get() as f32,
+            self.sy.get() as f32,
+            self.tx.to_f32(),
+            self.ty.to_f32(),
+        )
+    }
+}
+
+pub(crate) trait FillRuleExt {
+    fn to_krilla(&self) -> kp::FillRule;
+}
+
+impl FillRuleExt for FillRule {
+    fn to_krilla(&self) -> kp::FillRule {
+        match self {
+            FillRule::NonZero => kp::FillRule::NonZero,
+            FillRule::EvenOdd => kp::FillRule::EvenOdd,
+        }
+    }
+}
+
+pub(crate) trait AbsExt {
+    fn to_f32(self) -> f32;
+}
+
+impl AbsExt for Abs {
+    fn to_f32(self) -> f32 {
+        self.to_pt() as f32
+    }
+}
+
+/// Display the font family of a font.
+pub(crate) fn display_font(font: &Font) -> &str {
+    &font.info().family
+}
+
+/// Convert a typst path to a krilla path.
+pub(crate) fn convert_path(path: &Curve, builder: &mut PathBuilder) {
+    for item in &path.0 {
+        match item {
+            CurveItem::Move(p) => builder.move_to(p.x.to_f32(), p.y.to_f32()),
+            CurveItem::Line(p) => builder.line_to(p.x.to_f32(), p.y.to_f32()),
+            CurveItem::Cubic(p1, p2, p3) => builder.cubic_to(
+                p1.x.to_f32(),
+                p1.y.to_f32(),
+                p2.x.to_f32(),
+                p2.y.to_f32(),
+                p3.x.to_f32(),
+                p3.y.to_f32(),
+            ),
+            CurveItem::Close => builder.close(),
+        }
+    }
+}
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 151ae76ba..7d2460a89 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -655,6 +655,7 @@ fn visit_grouping_rules<'a>(
     let matching = s.rules.iter().find(|&rule| (rule.trigger)(content, &s.kind));
 
     // Try to continue or finish an existing grouping.
+    let mut i = 0;
     while let Some(active) = s.groupings.last() {
         // Start a nested group if a rule with higher priority matches.
         if matching.is_some_and(|rule| rule.priority > active.rule.priority) {
@@ -670,6 +671,16 @@ fn visit_grouping_rules<'a>(
         }
 
         finish_innermost_grouping(s)?;
+        i += 1;
+        if i > 512 {
+            // It seems like this case is only hit when there is a cycle between
+            // a show rule and a grouping rule. The show rule produces content
+            // that is matched by a grouping rule, which is then again processed
+            // by the show rule, and so on. The two must be at an equilibrium,
+            // otherwise either the "maximum show rule depth" or "maximum
+            // grouping depth" errors are triggered.
+            bail!(content.span(), "maximum grouping depth exceeded");
+        }
     }
 
     // Start a new grouping.
diff --git a/crates/typst-render/src/text.rs b/crates/typst-render/src/text.rs
index 16490aff4..55fe04b51 100644
--- a/crates/typst-render/src/text.rs
+++ b/crates/typst-render/src/text.rs
@@ -14,18 +14,20 @@ use crate::{shape, AbsExt, State};
 /// Render a text run into the canvas.
 pub fn render_text(canvas: &mut sk::Pixmap, state: State, text: &TextItem) {
     let mut x = Abs::zero();
+    let mut y = Abs::zero();
     for glyph in &text.glyphs {
         let id = GlyphId(glyph.id);
-        let offset = x + glyph.x_offset.at(text.size);
+        let x_offset = x + glyph.x_offset.at(text.size);
+        let y_offset = y + glyph.y_offset.at(text.size);
 
         if should_outline(&text.font, glyph) {
-            let state = state.pre_translate(Point::with_x(offset));
+            let state = state.pre_translate(Point::new(x_offset, -y_offset));
             render_outline_glyph(canvas, state, text, id);
         } else {
             let upem = text.font.units_per_em();
             let text_scale = text.size / upem;
             let state = state
-                .pre_translate(Point::new(offset, -text.size))
+                .pre_translate(Point::new(x_offset, -y_offset - text.size))
                 .pre_scale(Axes::new(text_scale, text_scale));
 
             let (glyph_frame, _) = glyph_frame(&text.font, glyph.id);
@@ -33,6 +35,7 @@ pub fn render_text(canvas: &mut sk::Pixmap, state: State, text: &TextItem) {
         }
 
         x += glyph.x_advance.at(text.size);
+        y += glyph.y_advance.at(text.size);
     }
 }
 
diff --git a/crates/typst-svg/src/image.rs b/crates/typst-svg/src/image.rs
index d74432026..1868ca39b 100644
--- a/crates/typst-svg/src/image.rs
+++ b/crates/typst-svg/src/image.rs
@@ -45,6 +45,7 @@ pub fn convert_image_to_base64_url(image: &Image) -> EcoString {
                     ExchangeFormat::Png => "png",
                     ExchangeFormat::Jpg => "jpeg",
                     ExchangeFormat::Gif => "gif",
+                    ExchangeFormat::Webp => "webp",
                 },
                 raster.data(),
             ),
diff --git a/crates/typst-svg/src/text.rs b/crates/typst-svg/src/text.rs
index e6620a59e..7099a9d72 100644
--- a/crates/typst-svg/src/text.rs
+++ b/crates/typst-svg/src/text.rs
@@ -25,25 +25,32 @@ impl SVGRenderer {
         self.xml.write_attribute("transform", "scale(1, -1)");
 
         let mut x: f64 = 0.0;
+        let mut y: f64 = 0.0;
         for glyph in &text.glyphs {
             let id = GlyphId(glyph.id);
-            let offset = x + glyph.x_offset.at(text.size).to_pt();
+            let x_offset = x + glyph.x_offset.at(text.size).to_pt();
+            let y_offset = y + glyph.y_offset.at(text.size).to_pt();
 
-            self.render_svg_glyph(text, id, offset, scale)
-                .or_else(|| self.render_bitmap_glyph(text, id, offset))
+            self.render_svg_glyph(text, id, x_offset, y_offset, scale)
+                .or_else(|| self.render_bitmap_glyph(text, id, x_offset, y_offset))
                 .or_else(|| {
                     self.render_outline_glyph(
                         state
                             .pre_concat(Transform::scale(Ratio::one(), -Ratio::one()))
-                            .pre_translate(Point::new(Abs::pt(offset), Abs::zero())),
+                            .pre_translate(Point::new(
+                                Abs::pt(x_offset),
+                                Abs::pt(y_offset),
+                            )),
                         text,
                         id,
-                        offset,
+                        x_offset,
+                        y_offset,
                         scale,
                     )
                 });
 
             x += glyph.x_advance.at(text.size).to_pt();
+            y += glyph.y_advance.at(text.size).to_pt();
         }
 
         self.xml.end_element();
@@ -55,6 +62,7 @@ impl SVGRenderer {
         text: &TextItem,
         id: GlyphId,
         x_offset: f64,
+        y_offset: f64,
         scale: f64,
     ) -> Option<()> {
         let data_url = convert_svg_glyph_to_base64_url(&text.font, id)?;
@@ -73,6 +81,7 @@ impl SVGRenderer {
         self.xml.start_element("use");
         self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
         self.xml.write_attribute("x", &x_offset);
+        self.xml.write_attribute("y", &y_offset);
         self.xml.end_element();
 
         Some(())
@@ -84,6 +93,7 @@ impl SVGRenderer {
         text: &TextItem,
         id: GlyphId,
         x_offset: f64,
+        y_offset: f64,
     ) -> Option<()> {
         let (image, bitmap_x_offset, bitmap_y_offset) =
             convert_bitmap_glyph_to_image(&text.font, id)?;
@@ -109,6 +119,7 @@ impl SVGRenderer {
         // it.
         let scale_factor = target_height / image.height();
         self.xml.write_attribute("x", &(x_offset / scale_factor));
+        self.xml.write_attribute("y", &(y_offset / scale_factor));
         self.xml.write_attribute_fmt(
             "transform",
             format_args!("scale({scale_factor} -{scale_factor})",),
@@ -125,6 +136,7 @@ impl SVGRenderer {
         text: &TextItem,
         glyph_id: GlyphId,
         x_offset: f64,
+        y_offset: f64,
         scale: f64,
     ) -> Option<()> {
         let scale = Ratio::new(scale);
@@ -139,6 +151,7 @@ impl SVGRenderer {
         self.xml.start_element("use");
         self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
         self.xml.write_attribute_fmt("x", format_args!("{x_offset}"));
+        self.xml.write_attribute_fmt("y", format_args!("{y_offset}"));
         self.write_fill(
             &text.fill,
             FillRule::default(),
diff --git a/crates/typst-syntax/Cargo.toml b/crates/typst-syntax/Cargo.toml
index 263595bd4..c20f6a087 100644
--- a/crates/typst-syntax/Cargo.toml
+++ b/crates/typst-syntax/Cargo.toml
@@ -15,6 +15,7 @@ readme = { workspace = true }
 [dependencies]
 typst-timing = { workspace = true }
 typst-utils = { workspace = true }
+comemo = { workspace = true }
 ecow = { workspace = true }
 serde = { workspace = true }
 toml = { workspace = true }
diff --git a/crates/typst-syntax/src/ast.rs b/crates/typst-syntax/src/ast.rs
index f79e65982..7b211bfc1 100644
--- a/crates/typst-syntax/src/ast.rs
+++ b/crates/typst-syntax/src/ast.rs
@@ -778,7 +778,7 @@ node! {
 
 impl<'a> EnumItem<'a> {
     /// The explicit numbering, if any: `23.`.
-    pub fn number(self) -> Option<usize> {
+    pub fn number(self) -> Option<u64> {
         self.0.children().find_map(|node| match node.kind() {
             SyntaxKind::EnumMarker => node.text().trim_end_matches('.').parse().ok(),
             _ => Option::None,
diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs
index b8f2bf25f..7d363d7b5 100644
--- a/crates/typst-syntax/src/lexer.rs
+++ b/crates/typst-syntax/src/lexer.rs
@@ -480,7 +480,7 @@ impl Lexer<'_> {
         self.s.eat_while(char::is_ascii_digit);
 
         let read = self.s.from(start);
-        if self.s.eat_if('.') && self.space_or_end() && read.parse::<usize>().is_ok() {
+        if self.s.eat_if('.') && self.space_or_end() && read.parse::<u64>().is_ok() {
             return SyntaxKind::EnumMarker;
         }
 
@@ -807,86 +807,96 @@ impl Lexer<'_> {
         }
     }
 
-    fn number(&mut self, mut start: usize, c: char) -> SyntaxKind {
+    fn number(&mut self, start: usize, first_c: char) -> SyntaxKind {
         // Handle alternative integer bases.
-        let mut base = 10;
-        if c == '0' {
-            if self.s.eat_if('b') {
-                base = 2;
-            } else if self.s.eat_if('o') {
-                base = 8;
-            } else if self.s.eat_if('x') {
-                base = 16;
-            }
-            if base != 10 {
-                start = self.s.cursor();
-            }
-        }
-
-        // Read the first part (integer or fractional depending on `first`).
-        self.s.eat_while(if base == 16 {
-            char::is_ascii_alphanumeric
-        } else {
-            char::is_ascii_digit
-        });
-
-        // Read the fractional part if not already done.
-        // Make sure not to confuse a range for the decimal separator.
-        if c != '.'
-            && !self.s.at("..")
-            && !self.s.scout(1).is_some_and(is_id_start)
-            && self.s.eat_if('.')
-            && base == 10
-        {
-            self.s.eat_while(char::is_ascii_digit);
-        }
-
-        // Read the exponent.
-        if !self.s.at("em") && self.s.eat_if(['e', 'E']) && base == 10 {
-            self.s.eat_if(['+', '-']);
-            self.s.eat_while(char::is_ascii_digit);
-        }
-
-        // Read the suffix.
-        let suffix_start = self.s.cursor();
-        if !self.s.eat_if('%') {
-            self.s.eat_while(char::is_ascii_alphanumeric);
-        }
-
-        let number = self.s.get(start..suffix_start);
-        let suffix = self.s.from(suffix_start);
-
-        let kind = if i64::from_str_radix(number, base).is_ok() {
-            SyntaxKind::Int
-        } else if base == 10 && number.parse::<f64>().is_ok() {
-            SyntaxKind::Float
-        } else {
-            return self.error(match base {
-                2 => eco_format!("invalid binary number: 0b{}", number),
-                8 => eco_format!("invalid octal number: 0o{}", number),
-                16 => eco_format!("invalid hexadecimal number: 0x{}", number),
-                _ => eco_format!("invalid number: {}", number),
-            });
+        let base = match first_c {
+            '0' if self.s.eat_if('b') => 2,
+            '0' if self.s.eat_if('o') => 8,
+            '0' if self.s.eat_if('x') => 16,
+            _ => 10,
         };
 
-        if suffix.is_empty() {
-            return kind;
+        // Read the initial digits.
+        if base == 16 {
+            self.s.eat_while(char::is_ascii_alphanumeric);
+        } else {
+            self.s.eat_while(char::is_ascii_digit);
         }
 
-        if !matches!(
-            suffix,
-            "pt" | "mm" | "cm" | "in" | "deg" | "rad" | "em" | "fr" | "%"
-        ) {
-            return self.error(eco_format!("invalid number suffix: {}", suffix));
+        // Read floating point digits and exponents.
+        let mut is_float = false;
+        if base == 10 {
+            // Read digits following a dot. Make sure not to confuse a spread
+            // operator or a method call for the decimal separator.
+            if first_c == '.' {
+                is_float = true; // We already ate the trailing digits above.
+            } else if !self.s.at("..")
+                && !self.s.scout(1).is_some_and(is_id_start)
+                && self.s.eat_if('.')
+            {
+                is_float = true;
+                self.s.eat_while(char::is_ascii_digit);
+            }
+
+            // Read the exponent.
+            if !self.s.at("em") && self.s.eat_if(['e', 'E']) {
+                is_float = true;
+                self.s.eat_if(['+', '-']);
+                self.s.eat_while(char::is_ascii_digit);
+            }
         }
 
-        if base != 10 {
-            let kind = self.error(eco_format!("invalid base-{base} prefix"));
-            self.hint("numbers with a unit cannot have a base prefix");
-            return kind;
-        }
+        let number = self.s.from(start);
+        let suffix = self.s.eat_while(|c: char| c.is_ascii_alphanumeric() || c == '%');
 
-        SyntaxKind::Numeric
+        let mut suffix_result = match suffix {
+            "" => Ok(None),
+            "pt" | "mm" | "cm" | "in" | "deg" | "rad" | "em" | "fr" | "%" => Ok(Some(())),
+            _ => Err(eco_format!("invalid number suffix: {suffix}")),
+        };
+
+        let number_result = if is_float && number.parse::<f64>().is_err() {
+            // The only invalid case should be when a float lacks digits after
+            // the exponent: e.g. `1.2e`, `2.3E-`, or `1EM`.
+            Err(eco_format!("invalid floating point number: {number}"))
+        } else if base == 10 {
+            Ok(())
+        } else {
+            let name = match base {
+                2 => "binary",
+                8 => "octal",
+                16 => "hexadecimal",
+                _ => unreachable!(),
+            };
+            // The index `[2..]` skips the leading `0b`/`0o`/`0x`.
+            match i64::from_str_radix(&number[2..], base) {
+                Ok(_) if suffix.is_empty() => Ok(()),
+                Ok(value) => {
+                    if suffix_result.is_ok() {
+                        suffix_result = Err(eco_format!(
+                            "try using a decimal number: {value}{suffix}"
+                        ));
+                    }
+                    Err(eco_format!("{name} numbers cannot have a suffix"))
+                }
+                Err(_) => Err(eco_format!("invalid {name} number: {number}")),
+            }
+        };
+
+        // Return our number or write an error with helpful hints.
+        match (number_result, suffix_result) {
+            // Valid numbers :D
+            (Ok(()), Ok(None)) if is_float => SyntaxKind::Float,
+            (Ok(()), Ok(None)) => SyntaxKind::Int,
+            (Ok(()), Ok(Some(()))) => SyntaxKind::Numeric,
+            // Invalid numbers :(
+            (Err(number_err), Err(suffix_err)) => {
+                let err = self.error(number_err);
+                self.hint(suffix_err);
+                err
+            }
+            (Ok(()), Err(msg)) | (Err(msg), Ok(_)) => self.error(msg),
+        }
     }
 
     fn string(&mut self) -> SyntaxKind {
diff --git a/crates/typst-syntax/src/lib.rs b/crates/typst-syntax/src/lib.rs
index 5e7b710fc..1249f88e9 100644
--- a/crates/typst-syntax/src/lib.rs
+++ b/crates/typst-syntax/src/lib.rs
@@ -7,6 +7,7 @@ mod file;
 mod highlight;
 mod kind;
 mod lexer;
+mod lines;
 mod node;
 mod parser;
 mod path;
@@ -22,6 +23,7 @@ pub use self::lexer::{
     is_id_continue, is_id_start, is_ident, is_newline, is_valid_label_literal_id,
     link_prefix, split_newlines,
 };
+pub use self::lines::Lines;
 pub use self::node::{LinkedChildren, LinkedNode, Side, SyntaxError, SyntaxNode};
 pub use self::parser::{parse, parse_code, parse_math};
 pub use self::path::VirtualPath;
diff --git a/crates/typst-syntax/src/lines.rs b/crates/typst-syntax/src/lines.rs
new file mode 100644
index 000000000..768119dc1
--- /dev/null
+++ b/crates/typst-syntax/src/lines.rs
@@ -0,0 +1,404 @@
+use std::hash::{Hash, Hasher};
+use std::iter::zip;
+use std::ops::Range;
+use std::sync::Arc;
+
+use crate::is_newline;
+
+/// A text buffer and metadata about lines.
+///
+/// This is internally reference-counted and thus cheap to clone.
+#[derive(Clone)]
+pub struct Lines<S>(Arc<Repr<S>>);
+
+#[derive(Clone)]
+struct Repr<T> {
+    lines: Vec<Line>,
+    text: T,
+}
+
+/// Metadata about a line.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct Line {
+    /// The UTF-8 byte offset where the line starts.
+    byte_idx: usize,
+    /// The UTF-16 codepoint offset where the line starts.
+    utf16_idx: usize,
+}
+
+impl<T: AsRef<str>> Lines<T> {
+    /// Create from the text buffer and compute the line metadata.
+    pub fn new(text: T) -> Self {
+        let lines = lines(text.as_ref());
+        Lines(Arc::new(Repr { lines, text }))
+    }
+
+    /// The text as a string slice.
+    pub fn text(&self) -> &str {
+        self.0.text.as_ref()
+    }
+
+    /// Get the length of the file in UTF-8 encoded bytes.
+    pub fn len_bytes(&self) -> usize {
+        self.0.text.as_ref().len()
+    }
+
+    /// Get the length of the file in UTF-16 code units.
+    pub fn len_utf16(&self) -> usize {
+        let last = self.0.lines.last().unwrap();
+        last.utf16_idx + len_utf16(&self.text()[last.byte_idx..])
+    }
+
+    /// Get the length of the file in lines.
+    pub fn len_lines(&self) -> usize {
+        self.0.lines.len()
+    }
+
+    /// Return the index of the UTF-16 code unit at the byte index.
+    pub fn byte_to_utf16(&self, byte_idx: usize) -> Option<usize> {
+        let line_idx = self.byte_to_line(byte_idx)?;
+        let line = self.0.lines.get(line_idx)?;
+        let head = self.text().get(line.byte_idx..byte_idx)?;
+        Some(line.utf16_idx + len_utf16(head))
+    }
+
+    /// Return the index of the line that contains the given byte index.
+    pub fn byte_to_line(&self, byte_idx: usize) -> Option<usize> {
+        (byte_idx <= self.text().len()).then(|| {
+            match self.0.lines.binary_search_by_key(&byte_idx, |line| line.byte_idx) {
+                Ok(i) => i,
+                Err(i) => i - 1,
+            }
+        })
+    }
+
+    /// Return the index of the column at the byte index.
+    ///
+    /// The column is defined as the number of characters in the line before the
+    /// byte index.
+    pub fn byte_to_column(&self, byte_idx: usize) -> Option<usize> {
+        let line = self.byte_to_line(byte_idx)?;
+        let start = self.line_to_byte(line)?;
+        let head = self.text().get(start..byte_idx)?;
+        Some(head.chars().count())
+    }
+
+    /// Return the index of the line and column at the byte index.
+    pub fn byte_to_line_column(&self, byte_idx: usize) -> Option<(usize, usize)> {
+        let line = self.byte_to_line(byte_idx)?;
+        let start = self.line_to_byte(line)?;
+        let head = self.text().get(start..byte_idx)?;
+        let col = head.chars().count();
+        Some((line, col))
+    }
+
+    /// Return the byte index at the UTF-16 code unit.
+    pub fn utf16_to_byte(&self, utf16_idx: usize) -> Option<usize> {
+        let line = self.0.lines.get(
+            match self.0.lines.binary_search_by_key(&utf16_idx, |line| line.utf16_idx) {
+                Ok(i) => i,
+                Err(i) => i - 1,
+            },
+        )?;
+
+        let text = self.text();
+        let mut k = line.utf16_idx;
+        for (i, c) in text[line.byte_idx..].char_indices() {
+            if k >= utf16_idx {
+                return Some(line.byte_idx + i);
+            }
+            k += c.len_utf16();
+        }
+
+        (k == utf16_idx).then_some(text.len())
+    }
+
+    /// Return the byte position at which the given line starts.
+    pub fn line_to_byte(&self, line_idx: usize) -> Option<usize> {
+        self.0.lines.get(line_idx).map(|line| line.byte_idx)
+    }
+
+    /// Return the range which encloses the given line.
+    pub fn line_to_range(&self, line_idx: usize) -> Option<Range<usize>> {
+        let start = self.line_to_byte(line_idx)?;
+        let end = self.line_to_byte(line_idx + 1).unwrap_or(self.text().len());
+        Some(start..end)
+    }
+
+    /// Return the byte index of the given (line, column) pair.
+    ///
+    /// The column defines the number of characters to go beyond the start of
+    /// the line.
+    pub fn line_column_to_byte(
+        &self,
+        line_idx: usize,
+        column_idx: usize,
+    ) -> Option<usize> {
+        let range = self.line_to_range(line_idx)?;
+        let line = self.text().get(range.clone())?;
+        let mut chars = line.chars();
+        for _ in 0..column_idx {
+            chars.next();
+        }
+        Some(range.start + (line.len() - chars.as_str().len()))
+    }
+}
+
+impl Lines<String> {
+    /// Fully replace the source text.
+    ///
+    /// This performs a naive (suffix/prefix-based) diff of the old and new text
+    /// to produce the smallest single edit that transforms old into new and
+    /// then calls [`edit`](Self::edit) with it.
+    ///
+    /// Returns whether any changes were made.
+    pub fn replace(&mut self, new: &str) -> bool {
+        let Some((prefix, suffix)) = self.replacement_range(new) else {
+            return false;
+        };
+
+        let old = self.text();
+        let replace = prefix..old.len() - suffix;
+        let with = &new[prefix..new.len() - suffix];
+        self.edit(replace, with);
+
+        true
+    }
+
+    /// Returns the common prefix and suffix lengths.
+    /// Returns [`None`] if the old and new strings are equal.
+    pub fn replacement_range(&self, new: &str) -> Option<(usize, usize)> {
+        let old = self.text();
+
+        let mut prefix =
+            zip(old.bytes(), new.bytes()).take_while(|(x, y)| x == y).count();
+
+        if prefix == old.len() && prefix == new.len() {
+            return None;
+        }
+
+        while !old.is_char_boundary(prefix) || !new.is_char_boundary(prefix) {
+            prefix -= 1;
+        }
+
+        let mut suffix = zip(old[prefix..].bytes().rev(), new[prefix..].bytes().rev())
+            .take_while(|(x, y)| x == y)
+            .count();
+
+        while !old.is_char_boundary(old.len() - suffix)
+            || !new.is_char_boundary(new.len() - suffix)
+        {
+            suffix += 1;
+        }
+
+        Some((prefix, suffix))
+    }
+
+    /// Edit the source file by replacing the given range.
+    ///
+    /// Returns the range in the new source that was ultimately reparsed.
+    ///
+    /// The method panics if the `replace` range is out of bounds.
+    #[track_caller]
+    pub fn edit(&mut self, replace: Range<usize>, with: &str) {
+        let start_byte = replace.start;
+        let start_utf16 = self.byte_to_utf16(start_byte).unwrap();
+        let line = self.byte_to_line(start_byte).unwrap();
+
+        let inner = Arc::make_mut(&mut self.0);
+
+        // Update the text itself.
+        inner.text.replace_range(replace.clone(), with);
+
+        // Remove invalidated line starts.
+        inner.lines.truncate(line + 1);
+
+        // Handle adjoining of \r and \n.
+        if inner.text[..start_byte].ends_with('\r') && with.starts_with('\n') {
+            inner.lines.pop();
+        }
+
+        // Recalculate the line starts after the edit.
+        inner.lines.extend(lines_from(
+            start_byte,
+            start_utf16,
+            &inner.text[start_byte..],
+        ));
+    }
+}
+
+impl<S: Hash> Hash for Lines<S> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.text.hash(state);
+    }
+}
+
+impl<S: AsRef<str>> AsRef<str> for Lines<S> {
+    fn as_ref(&self) -> &str {
+        self.0.text.as_ref()
+    }
+}
+
+/// Create a line vector.
+fn lines(text: &str) -> Vec<Line> {
+    std::iter::once(Line { byte_idx: 0, utf16_idx: 0 })
+        .chain(lines_from(0, 0, text))
+        .collect()
+}
+
+/// Compute a line iterator from an offset.
+fn lines_from(
+    byte_offset: usize,
+    utf16_offset: usize,
+    text: &str,
+) -> impl Iterator<Item = Line> + '_ {
+    let mut s = unscanny::Scanner::new(text);
+    let mut utf16_idx = utf16_offset;
+
+    std::iter::from_fn(move || {
+        s.eat_until(|c: char| {
+            utf16_idx += c.len_utf16();
+            is_newline(c)
+        });
+
+        if s.done() {
+            return None;
+        }
+
+        if s.eat() == Some('\r') && s.eat_if('\n') {
+            utf16_idx += 1;
+        }
+
+        Some(Line { byte_idx: byte_offset + s.cursor(), utf16_idx })
+    })
+}
+
+/// The number of code units this string would use if it was encoded in
+/// UTF16. This runs in linear time.
+fn len_utf16(string: &str) -> usize {
+    string.chars().map(char::len_utf16).sum()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TEST: &str = "ä\tcde\nf💛g\r\nhi\rjkl";
+
+    #[test]
+    fn test_source_file_new() {
+        let lines = Lines::new(TEST);
+        assert_eq!(
+            lines.0.lines,
+            [
+                Line { byte_idx: 0, utf16_idx: 0 },
+                Line { byte_idx: 7, utf16_idx: 6 },
+                Line { byte_idx: 15, utf16_idx: 12 },
+                Line { byte_idx: 18, utf16_idx: 15 },
+            ]
+        );
+    }
+
+    #[test]
+    fn test_source_file_pos_to_line() {
+        let lines = Lines::new(TEST);
+        assert_eq!(lines.byte_to_line(0), Some(0));
+        assert_eq!(lines.byte_to_line(2), Some(0));
+        assert_eq!(lines.byte_to_line(6), Some(0));
+        assert_eq!(lines.byte_to_line(7), Some(1));
+        assert_eq!(lines.byte_to_line(8), Some(1));
+        assert_eq!(lines.byte_to_line(12), Some(1));
+        assert_eq!(lines.byte_to_line(21), Some(3));
+        assert_eq!(lines.byte_to_line(22), None);
+    }
+
+    #[test]
+    fn test_source_file_pos_to_column() {
+        let lines = Lines::new(TEST);
+        assert_eq!(lines.byte_to_column(0), Some(0));
+        assert_eq!(lines.byte_to_column(2), Some(1));
+        assert_eq!(lines.byte_to_column(6), Some(5));
+        assert_eq!(lines.byte_to_column(7), Some(0));
+        assert_eq!(lines.byte_to_column(8), Some(1));
+        assert_eq!(lines.byte_to_column(12), Some(2));
+    }
+
+    #[test]
+    fn test_source_file_utf16() {
+        #[track_caller]
+        fn roundtrip(lines: &Lines<&str>, byte_idx: usize, utf16_idx: usize) {
+            let middle = lines.byte_to_utf16(byte_idx).unwrap();
+            let result = lines.utf16_to_byte(middle).unwrap();
+            assert_eq!(middle, utf16_idx);
+            assert_eq!(result, byte_idx);
+        }
+
+        let lines = Lines::new(TEST);
+        roundtrip(&lines, 0, 0);
+        roundtrip(&lines, 2, 1);
+        roundtrip(&lines, 3, 2);
+        roundtrip(&lines, 8, 7);
+        roundtrip(&lines, 12, 9);
+        roundtrip(&lines, 21, 18);
+        assert_eq!(lines.byte_to_utf16(22), None);
+        assert_eq!(lines.utf16_to_byte(19), None);
+    }
+
+    #[test]
+    fn test_source_file_roundtrip() {
+        #[track_caller]
+        fn roundtrip(lines: &Lines<&str>, byte_idx: usize) {
+            let line = lines.byte_to_line(byte_idx).unwrap();
+            let column = lines.byte_to_column(byte_idx).unwrap();
+            let result = lines.line_column_to_byte(line, column).unwrap();
+            assert_eq!(result, byte_idx);
+        }
+
+        let lines = Lines::new(TEST);
+        roundtrip(&lines, 0);
+        roundtrip(&lines, 7);
+        roundtrip(&lines, 12);
+        roundtrip(&lines, 21);
+    }
+
+    #[test]
+    fn test_source_file_edit() {
+        // This tests only the non-parser parts. The reparsing itself is
+        // tested separately.
+        #[track_caller]
+        fn test(prev: &str, range: Range<usize>, with: &str, after: &str) {
+            let reference = Lines::new(after);
+
+            let mut edited = Lines::new(prev.to_string());
+            edited.edit(range.clone(), with);
+            assert_eq!(edited.text(), reference.text());
+            assert_eq!(edited.0.lines, reference.0.lines);
+
+            let mut replaced = Lines::new(prev.to_string());
+            replaced.replace(&{
+                let mut s = prev.to_string();
+                s.replace_range(range, with);
+                s
+            });
+            assert_eq!(replaced.text(), reference.text());
+            assert_eq!(replaced.0.lines, reference.0.lines);
+        }
+
+        // Test inserting at the beginning.
+        test("abc\n", 0..0, "hi\n", "hi\nabc\n");
+        test("\nabc", 0..0, "hi\r", "hi\r\nabc");
+
+        // Test editing in the middle.
+        test(TEST, 4..16, "❌", "ä\tc❌i\rjkl");
+
+        // Test appending.
+        test("abc\ndef", 7..7, "hi", "abc\ndefhi");
+        test("abc\ndef\n", 8..8, "hi", "abc\ndef\nhi");
+
+        // Test appending with adjoining \r and \n.
+        test("abc\ndef\r", 8..8, "\nghi", "abc\ndef\r\nghi");
+
+        // Test removing everything.
+        test(TEST, 0..21, "", "");
+    }
+}
diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs
index c5d13c8b3..a68815806 100644
--- a/crates/typst-syntax/src/parser.rs
+++ b/crates/typst-syntax/src/parser.rs
@@ -271,11 +271,9 @@ fn math_expr_prec(p: &mut Parser, min_prec: usize, stop: SyntaxKind) {
         }
 
         SyntaxKind::Text | SyntaxKind::MathText | SyntaxKind::MathShorthand => {
-            continuable = !p.at(SyntaxKind::MathShorthand)
-                && matches!(
-                    math_class(p.current_text()),
-                    None | Some(MathClass::Alphabetic)
-                );
+            // `a(b)/c` parses as `(a(b))/c` if `a` is continuable.
+            continuable = math_class(p.current_text()) == Some(MathClass::Alphabetic)
+                || p.current_text().chars().all(char::is_alphabetic);
             if !maybe_delimited(p) {
                 p.eat();
             }
@@ -1573,10 +1571,10 @@ struct Token {
     prev_end: usize,
 }
 
-/// Information about a newline if present (currently only relevant in Markup).
+/// Information about newlines in a group of trivia.
 #[derive(Debug, Clone, Copy)]
 struct Newline {
-    /// The column of the start of our token in its line.
+    /// The column of the start of the next token in its line.
     column: Option<usize>,
     /// Whether any of our newlines were paragraph breaks.
     parbreak: bool,
@@ -1589,7 +1587,7 @@ enum AtNewline {
     Continue,
     /// Stop at any newline.
     Stop,
-    /// Continue only if there is no continuation with `else` or `.` (Code only).
+    /// Continue only if there is a continuation with `else` or `.` (Code only).
     ContextualContinue,
     /// Stop only at a parbreak, not normal newlines (Markup only).
     StopParBreak,
@@ -1612,9 +1610,10 @@ impl AtNewline {
             },
             AtNewline::StopParBreak => parbreak,
             AtNewline::RequireColumn(min_col) => {
-                // Don't stop if this newline doesn't start a column (this may
-                // be checked on the boundary of lexer modes, since we only
-                // report a column in Markup).
+                // When the column is `None`, the newline doesn't start a
+                // column, and we continue parsing. This may happen on the
+                // boundary of lexer modes, since we only report a column in
+                // Markup.
                 column.is_some_and(|column| column <= min_col)
             }
         }
diff --git a/crates/typst-syntax/src/reparser.rs b/crates/typst-syntax/src/reparser.rs
index c20d8314f..55555c96e 100644
--- a/crates/typst-syntax/src/reparser.rs
+++ b/crates/typst-syntax/src/reparser.rs
@@ -259,10 +259,10 @@ mod tests {
             panic!("test failed");
         }
         if incremental {
-            assert_ne!(source.len_bytes(), range.len(), "should have been incremental");
+            assert_ne!(source.text().len(), range.len(), "should have been incremental");
         } else {
             assert_eq!(
-                source.len_bytes(),
+                source.text().len(),
                 range.len(),
                 "shouldn't have been incremental"
             );
diff --git a/crates/typst-syntax/src/source.rs b/crates/typst-syntax/src/source.rs
index 6ff94c73f..abde1f981 100644
--- a/crates/typst-syntax/src/source.rs
+++ b/crates/typst-syntax/src/source.rs
@@ -2,14 +2,14 @@
 
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
-use std::iter::zip;
 use std::ops::Range;
 use std::sync::Arc;
 
 use typst_utils::LazyHash;
 
+use crate::lines::Lines;
 use crate::reparser::reparse;
-use crate::{is_newline, parse, FileId, LinkedNode, Span, SyntaxNode, VirtualPath};
+use crate::{parse, FileId, LinkedNode, Span, SyntaxNode, VirtualPath};
 
 /// A source file.
 ///
@@ -24,9 +24,8 @@ pub struct Source(Arc<Repr>);
 #[derive(Clone)]
 struct Repr {
     id: FileId,
-    text: LazyHash<String>,
     root: LazyHash<SyntaxNode>,
-    lines: Vec<Line>,
+    lines: LazyHash<Lines<String>>,
 }
 
 impl Source {
@@ -37,8 +36,7 @@ impl Source {
         root.numberize(id, Span::FULL).unwrap();
         Self(Arc::new(Repr {
             id,
-            lines: lines(&text),
-            text: LazyHash::new(text),
+            lines: LazyHash::new(Lines::new(text)),
             root: LazyHash::new(root),
         }))
     }
@@ -60,12 +58,13 @@ impl Source {
 
     /// The whole source as a string slice.
     pub fn text(&self) -> &str {
-        &self.0.text
+        self.0.lines.text()
     }
 
-    /// Slice out the part of the source code enclosed by the range.
-    pub fn get(&self, range: Range<usize>) -> Option<&str> {
-        self.text().get(range)
+    /// An acceleration structure for conversion of UTF-8, UTF-16 and
+    /// line/column indices.
+    pub fn lines(&self) -> &Lines<String> {
+        &self.0.lines
     }
 
     /// Fully replace the source text.
@@ -77,29 +76,12 @@ impl Source {
     /// Returns the range in the new source that was ultimately reparsed.
     pub fn replace(&mut self, new: &str) -> Range<usize> {
         let _scope = typst_timing::TimingScope::new("replace source");
-        let old = self.text();
 
-        let mut prefix =
-            zip(old.bytes(), new.bytes()).take_while(|(x, y)| x == y).count();
-
-        if prefix == old.len() && prefix == new.len() {
+        let Some((prefix, suffix)) = self.0.lines.replacement_range(new) else {
             return 0..0;
-        }
-
-        while !old.is_char_boundary(prefix) || !new.is_char_boundary(prefix) {
-            prefix -= 1;
-        }
-
-        let mut suffix = zip(old[prefix..].bytes().rev(), new[prefix..].bytes().rev())
-            .take_while(|(x, y)| x == y)
-            .count();
-
-        while !old.is_char_boundary(old.len() - suffix)
-            || !new.is_char_boundary(new.len() - suffix)
-        {
-            suffix += 1;
-        }
+        };
 
+        let old = self.text();
         let replace = prefix..old.len() - suffix;
         let with = &new[prefix..new.len() - suffix];
         self.edit(replace, with)
@@ -112,48 +94,13 @@ impl Source {
     /// The method panics if the `replace` range is out of bounds.
     #[track_caller]
     pub fn edit(&mut self, replace: Range<usize>, with: &str) -> Range<usize> {
-        let start_byte = replace.start;
-        let start_utf16 = self.byte_to_utf16(start_byte).unwrap();
-        let line = self.byte_to_line(start_byte).unwrap();
-
         let inner = Arc::make_mut(&mut self.0);
 
-        // Update the text itself.
-        inner.text.replace_range(replace.clone(), with);
-
-        // Remove invalidated line starts.
-        inner.lines.truncate(line + 1);
-
-        // Handle adjoining of \r and \n.
-        if inner.text[..start_byte].ends_with('\r') && with.starts_with('\n') {
-            inner.lines.pop();
-        }
-
-        // Recalculate the line starts after the edit.
-        inner.lines.extend(lines_from(
-            start_byte,
-            start_utf16,
-            &inner.text[start_byte..],
-        ));
+        // Update the text and lines.
+        inner.lines.edit(replace.clone(), with);
 
         // Incrementally reparse the replaced range.
-        reparse(&mut inner.root, &inner.text, replace, with.len())
-    }
-
-    /// Get the length of the file in UTF-8 encoded bytes.
-    pub fn len_bytes(&self) -> usize {
-        self.text().len()
-    }
-
-    /// Get the length of the file in UTF-16 code units.
-    pub fn len_utf16(&self) -> usize {
-        let last = self.0.lines.last().unwrap();
-        last.utf16_idx + len_utf16(&self.0.text[last.byte_idx..])
-    }
-
-    /// Get the length of the file in lines.
-    pub fn len_lines(&self) -> usize {
-        self.0.lines.len()
+        reparse(&mut inner.root, inner.lines.text(), replace, with.len())
     }
 
     /// Find the node with the given span.
@@ -171,85 +118,6 @@ impl Source {
     pub fn range(&self, span: Span) -> Option<Range<usize>> {
         Some(self.find(span)?.range())
     }
-
-    /// Return the index of the UTF-16 code unit at the byte index.
-    pub fn byte_to_utf16(&self, byte_idx: usize) -> Option<usize> {
-        let line_idx = self.byte_to_line(byte_idx)?;
-        let line = self.0.lines.get(line_idx)?;
-        let head = self.0.text.get(line.byte_idx..byte_idx)?;
-        Some(line.utf16_idx + len_utf16(head))
-    }
-
-    /// Return the index of the line that contains the given byte index.
-    pub fn byte_to_line(&self, byte_idx: usize) -> Option<usize> {
-        (byte_idx <= self.0.text.len()).then(|| {
-            match self.0.lines.binary_search_by_key(&byte_idx, |line| line.byte_idx) {
-                Ok(i) => i,
-                Err(i) => i - 1,
-            }
-        })
-    }
-
-    /// Return the index of the column at the byte index.
-    ///
-    /// The column is defined as the number of characters in the line before the
-    /// byte index.
-    pub fn byte_to_column(&self, byte_idx: usize) -> Option<usize> {
-        let line = self.byte_to_line(byte_idx)?;
-        let start = self.line_to_byte(line)?;
-        let head = self.get(start..byte_idx)?;
-        Some(head.chars().count())
-    }
-
-    /// Return the byte index at the UTF-16 code unit.
-    pub fn utf16_to_byte(&self, utf16_idx: usize) -> Option<usize> {
-        let line = self.0.lines.get(
-            match self.0.lines.binary_search_by_key(&utf16_idx, |line| line.utf16_idx) {
-                Ok(i) => i,
-                Err(i) => i - 1,
-            },
-        )?;
-
-        let mut k = line.utf16_idx;
-        for (i, c) in self.0.text[line.byte_idx..].char_indices() {
-            if k >= utf16_idx {
-                return Some(line.byte_idx + i);
-            }
-            k += c.len_utf16();
-        }
-
-        (k == utf16_idx).then_some(self.0.text.len())
-    }
-
-    /// Return the byte position at which the given line starts.
-    pub fn line_to_byte(&self, line_idx: usize) -> Option<usize> {
-        self.0.lines.get(line_idx).map(|line| line.byte_idx)
-    }
-
-    /// Return the range which encloses the given line.
-    pub fn line_to_range(&self, line_idx: usize) -> Option<Range<usize>> {
-        let start = self.line_to_byte(line_idx)?;
-        let end = self.line_to_byte(line_idx + 1).unwrap_or(self.0.text.len());
-        Some(start..end)
-    }
-
-    /// Return the byte index of the given (line, column) pair.
-    ///
-    /// The column defines the number of characters to go beyond the start of
-    /// the line.
-    pub fn line_column_to_byte(
-        &self,
-        line_idx: usize,
-        column_idx: usize,
-    ) -> Option<usize> {
-        let range = self.line_to_range(line_idx)?;
-        let line = self.get(range.clone())?;
-        let mut chars = line.chars();
-        for _ in 0..column_idx {
-            chars.next();
-        }
-        Some(range.start + (line.len() - chars.as_str().len()))
-    }
 }
 
 impl Debug for Source {
@@ -261,7 +129,7 @@ impl Debug for Source {
 impl Hash for Source {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.0.id.hash(state);
-        self.0.text.hash(state);
+        self.0.lines.hash(state);
         self.0.root.hash(state);
     }
 }
@@ -271,176 +139,3 @@ impl AsRef<str> for Source {
         self.text()
     }
 }
-
-/// Metadata about a line.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-struct Line {
-    /// The UTF-8 byte offset where the line starts.
-    byte_idx: usize,
-    /// The UTF-16 codepoint offset where the line starts.
-    utf16_idx: usize,
-}
-
-/// Create a line vector.
-fn lines(text: &str) -> Vec<Line> {
-    std::iter::once(Line { byte_idx: 0, utf16_idx: 0 })
-        .chain(lines_from(0, 0, text))
-        .collect()
-}
-
-/// Compute a line iterator from an offset.
-fn lines_from(
-    byte_offset: usize,
-    utf16_offset: usize,
-    text: &str,
-) -> impl Iterator<Item = Line> + '_ {
-    let mut s = unscanny::Scanner::new(text);
-    let mut utf16_idx = utf16_offset;
-
-    std::iter::from_fn(move || {
-        s.eat_until(|c: char| {
-            utf16_idx += c.len_utf16();
-            is_newline(c)
-        });
-
-        if s.done() {
-            return None;
-        }
-
-        if s.eat() == Some('\r') && s.eat_if('\n') {
-            utf16_idx += 1;
-        }
-
-        Some(Line { byte_idx: byte_offset + s.cursor(), utf16_idx })
-    })
-}
-
-/// The number of code units this string would use if it was encoded in
-/// UTF16. This runs in linear time.
-fn len_utf16(string: &str) -> usize {
-    string.chars().map(char::len_utf16).sum()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const TEST: &str = "ä\tcde\nf💛g\r\nhi\rjkl";
-
-    #[test]
-    fn test_source_file_new() {
-        let source = Source::detached(TEST);
-        assert_eq!(
-            source.0.lines,
-            [
-                Line { byte_idx: 0, utf16_idx: 0 },
-                Line { byte_idx: 7, utf16_idx: 6 },
-                Line { byte_idx: 15, utf16_idx: 12 },
-                Line { byte_idx: 18, utf16_idx: 15 },
-            ]
-        );
-    }
-
-    #[test]
-    fn test_source_file_pos_to_line() {
-        let source = Source::detached(TEST);
-        assert_eq!(source.byte_to_line(0), Some(0));
-        assert_eq!(source.byte_to_line(2), Some(0));
-        assert_eq!(source.byte_to_line(6), Some(0));
-        assert_eq!(source.byte_to_line(7), Some(1));
-        assert_eq!(source.byte_to_line(8), Some(1));
-        assert_eq!(source.byte_to_line(12), Some(1));
-        assert_eq!(source.byte_to_line(21), Some(3));
-        assert_eq!(source.byte_to_line(22), None);
-    }
-
-    #[test]
-    fn test_source_file_pos_to_column() {
-        let source = Source::detached(TEST);
-        assert_eq!(source.byte_to_column(0), Some(0));
-        assert_eq!(source.byte_to_column(2), Some(1));
-        assert_eq!(source.byte_to_column(6), Some(5));
-        assert_eq!(source.byte_to_column(7), Some(0));
-        assert_eq!(source.byte_to_column(8), Some(1));
-        assert_eq!(source.byte_to_column(12), Some(2));
-    }
-
-    #[test]
-    fn test_source_file_utf16() {
-        #[track_caller]
-        fn roundtrip(source: &Source, byte_idx: usize, utf16_idx: usize) {
-            let middle = source.byte_to_utf16(byte_idx).unwrap();
-            let result = source.utf16_to_byte(middle).unwrap();
-            assert_eq!(middle, utf16_idx);
-            assert_eq!(result, byte_idx);
-        }
-
-        let source = Source::detached(TEST);
-        roundtrip(&source, 0, 0);
-        roundtrip(&source, 2, 1);
-        roundtrip(&source, 3, 2);
-        roundtrip(&source, 8, 7);
-        roundtrip(&source, 12, 9);
-        roundtrip(&source, 21, 18);
-        assert_eq!(source.byte_to_utf16(22), None);
-        assert_eq!(source.utf16_to_byte(19), None);
-    }
-
-    #[test]
-    fn test_source_file_roundtrip() {
-        #[track_caller]
-        fn roundtrip(source: &Source, byte_idx: usize) {
-            let line = source.byte_to_line(byte_idx).unwrap();
-            let column = source.byte_to_column(byte_idx).unwrap();
-            let result = source.line_column_to_byte(line, column).unwrap();
-            assert_eq!(result, byte_idx);
-        }
-
-        let source = Source::detached(TEST);
-        roundtrip(&source, 0);
-        roundtrip(&source, 7);
-        roundtrip(&source, 12);
-        roundtrip(&source, 21);
-    }
-
-    #[test]
-    fn test_source_file_edit() {
-        // This tests only the non-parser parts. The reparsing itself is
-        // tested separately.
-        #[track_caller]
-        fn test(prev: &str, range: Range<usize>, with: &str, after: &str) {
-            let reference = Source::detached(after);
-
-            let mut edited = Source::detached(prev);
-            edited.edit(range.clone(), with);
-            assert_eq!(edited.text(), reference.text());
-            assert_eq!(edited.0.lines, reference.0.lines);
-
-            let mut replaced = Source::detached(prev);
-            replaced.replace(&{
-                let mut s = prev.to_string();
-                s.replace_range(range, with);
-                s
-            });
-            assert_eq!(replaced.text(), reference.text());
-            assert_eq!(replaced.0.lines, reference.0.lines);
-        }
-
-        // Test inserting at the beginning.
-        test("abc\n", 0..0, "hi\n", "hi\nabc\n");
-        test("\nabc", 0..0, "hi\r", "hi\r\nabc");
-
-        // Test editing in the middle.
-        test(TEST, 4..16, "❌", "ä\tc❌i\rjkl");
-
-        // Test appending.
-        test("abc\ndef", 7..7, "hi", "abc\ndefhi");
-        test("abc\ndef\n", 8..8, "hi", "abc\ndef\nhi");
-
-        // Test appending with adjoining \r and \n.
-        test("abc\ndef\r", 8..8, "\nghi", "abc\ndef\r\nghi");
-
-        // Test removing everything.
-        test(TEST, 0..21, "", "");
-    }
-}
diff --git a/crates/typst-syntax/src/span.rs b/crates/typst-syntax/src/span.rs
index 3618b8f2f..b383ec27f 100644
--- a/crates/typst-syntax/src/span.rs
+++ b/crates/typst-syntax/src/span.rs
@@ -71,10 +71,7 @@ impl Span {
 
     /// Create a span that does not point into any file.
     pub const fn detached() -> Self {
-        match NonZeroU64::new(Self::DETACHED) {
-            Some(v) => Self(v),
-            None => unreachable!(),
-        }
+        Self(NonZeroU64::new(Self::DETACHED).unwrap())
     }
 
     /// Create a new span from a file id and a number.
@@ -111,11 +108,9 @@ impl Span {
     /// Pack a file ID and the low bits into a span.
     const fn pack(id: FileId, low: u64) -> Self {
         let bits = ((id.into_raw().get() as u64) << Self::FILE_ID_SHIFT) | low;
-        match NonZeroU64::new(bits) {
-            Some(v) => Self(v),
-            // The file ID is non-zero.
-            None => unreachable!(),
-        }
+
+        // The file ID is non-zero.
+        Self(NonZeroU64::new(bits).unwrap())
     }
 
     /// Whether the span is detached.
diff --git a/crates/typst-utils/src/lib.rs b/crates/typst-utils/src/lib.rs
index b346a8096..abe6423df 100644
--- a/crates/typst-utils/src/lib.rs
+++ b/crates/typst-utils/src/lib.rs
@@ -26,7 +26,7 @@ pub use once_cell;
 use std::fmt::{Debug, Formatter};
 use std::hash::Hash;
 use std::iter::{Chain, Flatten, Rev};
-use std::num::NonZeroUsize;
+use std::num::{NonZeroU32, NonZeroUsize};
 use std::ops::{Add, Deref, Div, Mul, Neg, Sub};
 use std::sync::Arc;
 
@@ -66,10 +66,11 @@ pub trait NonZeroExt {
 }
 
 impl NonZeroExt for NonZeroUsize {
-    const ONE: Self = match Self::new(1) {
-        Some(v) => v,
-        None => unreachable!(),
-    };
+    const ONE: Self = Self::new(1).unwrap();
+}
+
+impl NonZeroExt for NonZeroU32 {
+    const ONE: Self = Self::new(1).unwrap();
 }
 
 /// Extra methods for [`Arc`].
diff --git a/crates/typst-utils/src/pico.rs b/crates/typst-utils/src/pico.rs
index 2c80d37de..ce43667e9 100644
--- a/crates/typst-utils/src/pico.rs
+++ b/crates/typst-utils/src/pico.rs
@@ -95,10 +95,7 @@ impl PicoStr {
             }
         };
 
-        match NonZeroU64::new(value) {
-            Some(value) => Ok(Self(value)),
-            None => unreachable!(),
-        }
+        Ok(Self(NonZeroU64::new(value).unwrap()))
     }
 
     /// Resolve to a decoded string.
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 580ba9e80..a6bb4fe38 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -27,7 +27,6 @@
 //! [module]: crate::foundations::Module
 //! [content]: crate::foundations::Content
 //! [laid out]: typst_layout::layout_document
-//! [document]: crate::model::Document
 //! [frame]: crate::layout::Frame
 
 pub extern crate comemo;
diff --git a/docs/dev/architecture.md b/docs/dev/architecture.md
index bbae06792..3620d4fda 100644
--- a/docs/dev/architecture.md
+++ b/docs/dev/architecture.md
@@ -12,6 +12,7 @@ Let's start with a broad overview of the directories in this repository:
 - `crates/typst-cli`: Typst's command line interface. This is a relatively small
   layer on top of the compiler and the exporters.
 - `crates/typst-eval`: The interpreter for the Typst language.
+- `crates/typst-html`: The HTML exporter.
 - `crates/typst-ide`: Exposes IDE functionality.
 - `crates/typst-kit`: Contains various default implementation of
   functionality used in `typst-cli`.
diff --git a/docs/reference/groups.yml b/docs/reference/groups.yml
index 8fea3a1f2..e5aa7e999 100644
--- a/docs/reference/groups.yml
+++ b/docs/reference/groups.yml
@@ -112,11 +112,18 @@
     a few more functions that create delimiter pairings for absolute, ceiled,
     and floored values as well as norms.
 
+    To prevent a delimiter from being matched by Typst, and thus auto-scaled,
+    escape it with a backslash. To instead disable auto-scaling completely, use
+    `{set math.lr(size: 1em)}`.
+
     # Example
     ```example
     $ [a, b/2] $
     $ lr(]sum_(x=1)^n], size: #50%) x $
     $ abs((x + y) / 2) $
+    $ \{ (x / y) \} $
+    #set math.lr(size: 1em)
+    $ { (a / b), a, b in (0; 1/2] } $
     ```
 
 - name: calc
diff --git a/docs/src/html.rs b/docs/src/html.rs
index 9077d5c47..9c02f08e9 100644
--- a/docs/src/html.rs
+++ b/docs/src/html.rs
@@ -498,7 +498,7 @@ impl World for DocWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        Some(FONTS.1[index].clone())
+        FONTS.1.get(index).cloned()
     }
 
     fn today(&self, _: Option<i64>) -> Option<Datetime> {
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index 091bb1b24..d848c59bd 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -622,7 +622,7 @@ fn group_page(
     });
 
     let model = PageModel {
-        route: eco_format!("{parent}{}", group.name),
+        route: eco_format!("{parent}{}/", group.name),
         title: group.title.clone(),
         description: eco_format!("Documentation for the {} functions.", group.name),
         part: None,
diff --git a/docs/tutorial/1-writing.md b/docs/tutorial/1-writing.md
index acc257830..d505d2d03 100644
--- a/docs/tutorial/1-writing.md
+++ b/docs/tutorial/1-writing.md
@@ -69,7 +69,7 @@ the first item of the list above by indenting it.
 
 ## Adding a figure { #figure }
 You think that your report would benefit from a figure. Let's add one. Typst
-supports images in the formats PNG, JPEG, GIF, and SVG. To add an image file to
+supports images in the formats PNG, JPEG, GIF, SVG, and WebP. To add an image file to
 your project, first open the _file panel_ by clicking the box icon in the left
 sidebar. Here, you can see a list of all files in your project. Currently, there
 is only one: The main Typst file you are writing in. To upload another file,
diff --git a/flake.lock b/flake.lock
index ad47d29cd..dedfbb4e0 100644
--- a/flake.lock
+++ b/flake.lock
@@ -112,13 +112,13 @@
     "rust-manifest": {
       "flake": false,
       "locked": {
-        "narHash": "sha256-irgHsBXecwlFSdmP9MfGP06Cbpca2QALJdbN4cymcko=",
+        "narHash": "sha256-BwfxWd/E8gpnXoKsucFXhMbevMlVgw3l0becLkIcWCU=",
         "type": "file",
-        "url": "https://static.rust-lang.org/dist/channel-rust-1.85.0.toml"
+        "url": "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml"
       },
       "original": {
         "type": "file",
-        "url": "https://static.rust-lang.org/dist/channel-rust-1.85.0.toml"
+        "url": "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml"
       }
     },
     "systems": {
diff --git a/flake.nix b/flake.nix
index 6938f6e57..1b2b3abc8 100644
--- a/flake.nix
+++ b/flake.nix
@@ -10,7 +10,7 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
     rust-manifest = {
-      url = "https://static.rust-lang.org/dist/channel-rust-1.85.0.toml";
+      url = "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml";
       flake = false;
     };
   };
diff --git a/tests/ref/bibliography-basic.png b/tests/ref/bibliography-basic.png
index 0844eaf81..86d02cc69 100644
Binary files a/tests/ref/bibliography-basic.png and b/tests/ref/bibliography-basic.png differ
diff --git a/tests/ref/bibliography-before-content.png b/tests/ref/bibliography-before-content.png
index eb9f26d83..a16ea1df5 100644
Binary files a/tests/ref/bibliography-before-content.png and b/tests/ref/bibliography-before-content.png differ
diff --git a/tests/ref/bibliography-grid-par.png b/tests/ref/bibliography-grid-par.png
index 5befbcc54..0757e92c5 100644
Binary files a/tests/ref/bibliography-grid-par.png and b/tests/ref/bibliography-grid-par.png differ
diff --git a/tests/ref/bibliography-indent-par.png b/tests/ref/bibliography-indent-par.png
index 02278124b..031e28974 100644
Binary files a/tests/ref/bibliography-indent-par.png and b/tests/ref/bibliography-indent-par.png differ
diff --git a/tests/ref/bibliography-math.png b/tests/ref/bibliography-math.png
index 6b60fef4a..6d6d88d53 100644
Binary files a/tests/ref/bibliography-math.png and b/tests/ref/bibliography-math.png differ
diff --git a/tests/ref/bibliography-multiple-files.png b/tests/ref/bibliography-multiple-files.png
index 3be3763f4..b2e7b0144 100644
Binary files a/tests/ref/bibliography-multiple-files.png and b/tests/ref/bibliography-multiple-files.png differ
diff --git a/tests/ref/bibliography-ordering.png b/tests/ref/bibliography-ordering.png
index c19b7e7d0..ad5e86019 100644
Binary files a/tests/ref/bibliography-ordering.png and b/tests/ref/bibliography-ordering.png differ
diff --git a/tests/ref/block-consistent-width.png b/tests/ref/block-consistent-width.png
index 045603cb8..f181bd335 100644
Binary files a/tests/ref/block-consistent-width.png and b/tests/ref/block-consistent-width.png differ
diff --git a/tests/ref/cite-footnote.png b/tests/ref/cite-footnote.png
index dd2cf8bdb..e89b1dc12 100644
Binary files a/tests/ref/cite-footnote.png and b/tests/ref/cite-footnote.png differ
diff --git a/tests/ref/cite-form.png b/tests/ref/cite-form.png
index a9fbe7515..91a6d2e26 100644
Binary files a/tests/ref/cite-form.png and b/tests/ref/cite-form.png differ
diff --git a/tests/ref/cite-group.png b/tests/ref/cite-group.png
index 02772f499..d512d07e0 100644
Binary files a/tests/ref/cite-group.png and b/tests/ref/cite-group.png differ
diff --git a/tests/ref/cite-grouping-and-ordering.png b/tests/ref/cite-grouping-and-ordering.png
index 8dea1b533..69c1db475 100644
Binary files a/tests/ref/cite-grouping-and-ordering.png and b/tests/ref/cite-grouping-and-ordering.png differ
diff --git a/tests/ref/double-percent.png b/tests/ref/double-percent.png
deleted file mode 100644
index 61a0d6143..000000000
Binary files a/tests/ref/double-percent.png and /dev/null differ
diff --git a/tests/ref/enum-numbering-huge.png b/tests/ref/enum-numbering-huge.png
new file mode 100644
index 000000000..b8117e0f4
Binary files /dev/null and b/tests/ref/enum-numbering-huge.png differ
diff --git a/tests/ref/figure-basic.png b/tests/ref/figure-basic.png
index 69388755f..eed77cc3a 100644
Binary files a/tests/ref/figure-basic.png and b/tests/ref/figure-basic.png differ
diff --git a/tests/ref/footnote-basic.png b/tests/ref/footnote-basic.png
index 44ace9035..7351bbb7f 100644
Binary files a/tests/ref/footnote-basic.png and b/tests/ref/footnote-basic.png differ
diff --git a/tests/ref/footnote-block-at-end.png b/tests/ref/footnote-block-at-end.png
index 09880aaba..15d0bb593 100644
Binary files a/tests/ref/footnote-block-at-end.png and b/tests/ref/footnote-block-at-end.png differ
diff --git a/tests/ref/footnote-block-fr.png b/tests/ref/footnote-block-fr.png
index 451e4d778..80781fd1d 100644
Binary files a/tests/ref/footnote-block-fr.png and b/tests/ref/footnote-block-fr.png differ
diff --git a/tests/ref/footnote-break-across-pages-block.png b/tests/ref/footnote-break-across-pages-block.png
index f2882dbcd..fd512950b 100644
Binary files a/tests/ref/footnote-break-across-pages-block.png and b/tests/ref/footnote-break-across-pages-block.png differ
diff --git a/tests/ref/footnote-break-across-pages-float.png b/tests/ref/footnote-break-across-pages-float.png
index 5d3ea1078..a343137b8 100644
Binary files a/tests/ref/footnote-break-across-pages-float.png and b/tests/ref/footnote-break-across-pages-float.png differ
diff --git a/tests/ref/footnote-break-across-pages-nested.png b/tests/ref/footnote-break-across-pages-nested.png
index f87658ce8..79b09cfb9 100644
Binary files a/tests/ref/footnote-break-across-pages-nested.png and b/tests/ref/footnote-break-across-pages-nested.png differ
diff --git a/tests/ref/footnote-break-across-pages.png b/tests/ref/footnote-break-across-pages.png
index 878227cb9..ba985d1eb 100644
Binary files a/tests/ref/footnote-break-across-pages.png and b/tests/ref/footnote-break-across-pages.png differ
diff --git a/tests/ref/footnote-duplicate.png b/tests/ref/footnote-duplicate.png
index b5a73f74b..e95228e48 100644
Binary files a/tests/ref/footnote-duplicate.png and b/tests/ref/footnote-duplicate.png differ
diff --git a/tests/ref/footnote-entry.png b/tests/ref/footnote-entry.png
index dd09acb92..9e0108f88 100644
Binary files a/tests/ref/footnote-entry.png and b/tests/ref/footnote-entry.png differ
diff --git a/tests/ref/footnote-float-priority.png b/tests/ref/footnote-float-priority.png
index 1017ed51c..7d649d55c 100644
Binary files a/tests/ref/footnote-float-priority.png and b/tests/ref/footnote-float-priority.png differ
diff --git a/tests/ref/footnote-in-caption.png b/tests/ref/footnote-in-caption.png
index 79b2b5d0f..cd4f837bb 100644
Binary files a/tests/ref/footnote-in-caption.png and b/tests/ref/footnote-in-caption.png differ
diff --git a/tests/ref/footnote-in-columns.png b/tests/ref/footnote-in-columns.png
index 281ec8836..8b5f1201d 100644
Binary files a/tests/ref/footnote-in-columns.png and b/tests/ref/footnote-in-columns.png differ
diff --git a/tests/ref/footnote-in-list.png b/tests/ref/footnote-in-list.png
index daf94e950..edb24156b 100644
Binary files a/tests/ref/footnote-in-list.png and b/tests/ref/footnote-in-list.png differ
diff --git a/tests/ref/footnote-in-place.png b/tests/ref/footnote-in-place.png
index b500ac80f..2f9681e23 100644
Binary files a/tests/ref/footnote-in-place.png and b/tests/ref/footnote-in-place.png differ
diff --git a/tests/ref/footnote-in-table.png b/tests/ref/footnote-in-table.png
index e110eac6d..2c7e42309 100644
Binary files a/tests/ref/footnote-in-table.png and b/tests/ref/footnote-in-table.png differ
diff --git a/tests/ref/footnote-invariant.png b/tests/ref/footnote-invariant.png
index a183ba7ab..23838c368 100644
Binary files a/tests/ref/footnote-invariant.png and b/tests/ref/footnote-invariant.png differ
diff --git a/tests/ref/footnote-multiple-in-one-line.png b/tests/ref/footnote-multiple-in-one-line.png
index 12def79ba..41faa1fb1 100644
Binary files a/tests/ref/footnote-multiple-in-one-line.png and b/tests/ref/footnote-multiple-in-one-line.png differ
diff --git a/tests/ref/footnote-nested-break-across-pages.png b/tests/ref/footnote-nested-break-across-pages.png
index 889fb0671..0903214c2 100644
Binary files a/tests/ref/footnote-nested-break-across-pages.png and b/tests/ref/footnote-nested-break-across-pages.png differ
diff --git a/tests/ref/footnote-nested.png b/tests/ref/footnote-nested.png
index 06617d984..365bef4e7 100644
Binary files a/tests/ref/footnote-nested.png and b/tests/ref/footnote-nested.png differ
diff --git a/tests/ref/footnote-ref-call.png b/tests/ref/footnote-ref-call.png
index afc103211..635865e41 100644
Binary files a/tests/ref/footnote-ref-call.png and b/tests/ref/footnote-ref-call.png differ
diff --git a/tests/ref/footnote-ref-forward.png b/tests/ref/footnote-ref-forward.png
index afb4d7cb5..f222b4be8 100644
Binary files a/tests/ref/footnote-ref-forward.png and b/tests/ref/footnote-ref-forward.png differ
diff --git a/tests/ref/footnote-ref-in-footnote.png b/tests/ref/footnote-ref-in-footnote.png
index 944985983..73901b479 100644
Binary files a/tests/ref/footnote-ref-in-footnote.png and b/tests/ref/footnote-ref-in-footnote.png differ
diff --git a/tests/ref/footnote-ref-multiple.png b/tests/ref/footnote-ref-multiple.png
index 899afca16..59e9fecef 100644
Binary files a/tests/ref/footnote-ref-multiple.png and b/tests/ref/footnote-ref-multiple.png differ
diff --git a/tests/ref/footnote-ref.png b/tests/ref/footnote-ref.png
index 812514eac..278f0e594 100644
Binary files a/tests/ref/footnote-ref.png and b/tests/ref/footnote-ref.png differ
diff --git a/tests/ref/footnote-space-collapsing.png b/tests/ref/footnote-space-collapsing.png
index bad0691fb..6936f3c13 100644
Binary files a/tests/ref/footnote-space-collapsing.png and b/tests/ref/footnote-space-collapsing.png differ
diff --git a/tests/ref/footnote-styling.png b/tests/ref/footnote-styling.png
index a68cca9dd..f9400ee7e 100644
Binary files a/tests/ref/footnote-styling.png and b/tests/ref/footnote-styling.png differ
diff --git a/tests/ref/gradient-math-conic.png b/tests/ref/gradient-math-conic.png
index ffd3e8068..9bac6c3d4 100644
Binary files a/tests/ref/gradient-math-conic.png and b/tests/ref/gradient-math-conic.png differ
diff --git a/tests/ref/gradient-math-dir.png b/tests/ref/gradient-math-dir.png
index 8d33f51f5..c2f5bcef5 100644
Binary files a/tests/ref/gradient-math-dir.png and b/tests/ref/gradient-math-dir.png differ
diff --git a/tests/ref/gradient-math-mat.png b/tests/ref/gradient-math-mat.png
index ecf953038..d003d6d03 100644
Binary files a/tests/ref/gradient-math-mat.png and b/tests/ref/gradient-math-mat.png differ
diff --git a/tests/ref/gradient-math-misc.png b/tests/ref/gradient-math-misc.png
index 13f5c27b3..419481384 100644
Binary files a/tests/ref/gradient-math-misc.png and b/tests/ref/gradient-math-misc.png differ
diff --git a/tests/ref/gradient-math-radial.png b/tests/ref/gradient-math-radial.png
index 8d0047bbe..97fb17e6f 100644
Binary files a/tests/ref/gradient-math-radial.png and b/tests/ref/gradient-math-radial.png differ
diff --git a/tests/ref/grid-footer-expand.png b/tests/ref/grid-footer-expand.png
deleted file mode 100644
index 6b173b0da..000000000
Binary files a/tests/ref/grid-footer-expand.png and /dev/null differ
diff --git a/tests/ref/grid-footer-moved-to-bottom-of-rowspans.png b/tests/ref/grid-footer-moved-to-bottom-of-rowspans.png
new file mode 100644
index 000000000..d8a9c74f8
Binary files /dev/null and b/tests/ref/grid-footer-moved-to-bottom-of-rowspans.png differ
diff --git a/tests/ref/grid-footer-non-repeatable-unbreakable.png b/tests/ref/grid-footer-non-repeatable-unbreakable.png
new file mode 100644
index 000000000..59d72201f
Binary files /dev/null and b/tests/ref/grid-footer-non-repeatable-unbreakable.png differ
diff --git a/tests/ref/grid-footer-repeatable-unbreakable.png b/tests/ref/grid-footer-repeatable-unbreakable.png
new file mode 100644
index 000000000..0fa30f773
Binary files /dev/null and b/tests/ref/grid-footer-repeatable-unbreakable.png differ
diff --git a/tests/ref/grid-footer-top-hlines-with-only-row-pos-cell.png b/tests/ref/grid-footer-top-hlines-with-only-row-pos-cell.png
new file mode 100644
index 000000000..f78e80c17
Binary files /dev/null and b/tests/ref/grid-footer-top-hlines-with-only-row-pos-cell.png differ
diff --git a/tests/ref/grid-footer-top-hlines-with-row-and-auto-pos-cell.png b/tests/ref/grid-footer-top-hlines-with-row-and-auto-pos-cell.png
new file mode 100644
index 000000000..fda05a3cd
Binary files /dev/null and b/tests/ref/grid-footer-top-hlines-with-row-and-auto-pos-cell.png differ
diff --git a/tests/ref/grid-header-and-large-auto-contiguous.png b/tests/ref/grid-header-and-large-auto-contiguous.png
new file mode 100644
index 000000000..2dbaba238
Binary files /dev/null and b/tests/ref/grid-header-and-large-auto-contiguous.png differ
diff --git a/tests/ref/grid-header-and-rowspan-contiguous-1.png b/tests/ref/grid-header-and-rowspan-contiguous-1.png
new file mode 100644
index 000000000..7cf2cb9ca
Binary files /dev/null and b/tests/ref/grid-header-and-rowspan-contiguous-1.png differ
diff --git a/tests/ref/grid-header-and-rowspan-contiguous-2.png b/tests/ref/grid-header-and-rowspan-contiguous-2.png
new file mode 100644
index 000000000..29bc411d1
Binary files /dev/null and b/tests/ref/grid-header-and-rowspan-contiguous-2.png differ
diff --git a/tests/ref/grid-header-cell-with-x.png b/tests/ref/grid-header-cell-with-x.png
new file mode 100644
index 000000000..659826250
Binary files /dev/null and b/tests/ref/grid-header-cell-with-x.png differ
diff --git a/tests/ref/grid-header-expand.png b/tests/ref/grid-header-expand.png
deleted file mode 100644
index d0fbd72ed..000000000
Binary files a/tests/ref/grid-header-expand.png and /dev/null differ
diff --git a/tests/ref/grid-header-multiple.png b/tests/ref/grid-header-multiple.png
new file mode 100644
index 000000000..199cc051f
Binary files /dev/null and b/tests/ref/grid-header-multiple.png differ
diff --git a/tests/ref/grid-header-non-repeating-orphan-prevention.png b/tests/ref/grid-header-non-repeating-orphan-prevention.png
new file mode 100644
index 000000000..d0dbc5974
Binary files /dev/null and b/tests/ref/grid-header-non-repeating-orphan-prevention.png differ
diff --git a/tests/ref/grid-header-not-at-first-row-two-columns.png b/tests/ref/grid-header-not-at-first-row-two-columns.png
new file mode 100644
index 000000000..21ee5f93a
Binary files /dev/null and b/tests/ref/grid-header-not-at-first-row-two-columns.png differ
diff --git a/tests/ref/grid-header-not-at-first-row.png b/tests/ref/grid-header-not-at-first-row.png
new file mode 100644
index 000000000..21ee5f93a
Binary files /dev/null and b/tests/ref/grid-header-not-at-first-row.png differ
diff --git a/tests/ref/grid-header-not-at-the-top.png b/tests/ref/grid-header-not-at-the-top.png
new file mode 100644
index 000000000..96f9adcda
Binary files /dev/null and b/tests/ref/grid-header-not-at-the-top.png differ
diff --git a/tests/ref/grid-header-replace-doesnt-fit.png b/tests/ref/grid-header-replace-doesnt-fit.png
new file mode 100644
index 000000000..a06ce0e96
Binary files /dev/null and b/tests/ref/grid-header-replace-doesnt-fit.png differ
diff --git a/tests/ref/grid-header-replace-orphan.png b/tests/ref/grid-header-replace-orphan.png
new file mode 100644
index 000000000..9d116169c
Binary files /dev/null and b/tests/ref/grid-header-replace-orphan.png differ
diff --git a/tests/ref/grid-header-replace.png b/tests/ref/grid-header-replace.png
new file mode 100644
index 000000000..dafecd7f4
Binary files /dev/null and b/tests/ref/grid-header-replace.png differ
diff --git a/tests/ref/grid-header-skip.png b/tests/ref/grid-header-skip.png
new file mode 100644
index 000000000..9c4f294d0
Binary files /dev/null and b/tests/ref/grid-header-skip.png differ
diff --git a/tests/ref/grid-header-too-large-non-repeating-orphan.png b/tests/ref/grid-header-too-large-non-repeating-orphan.png
new file mode 100644
index 000000000..a4e7843b0
Binary files /dev/null and b/tests/ref/grid-header-too-large-non-repeating-orphan.png differ
diff --git a/tests/ref/grid-header-too-large-repeating-orphan-not-at-first-row.png b/tests/ref/grid-header-too-large-repeating-orphan-not-at-first-row.png
new file mode 100644
index 000000000..754509f36
Binary files /dev/null and b/tests/ref/grid-header-too-large-repeating-orphan-not-at-first-row.png differ
diff --git a/tests/ref/grid-header-too-large-repeating-orphan-with-footer.png b/tests/ref/grid-header-too-large-repeating-orphan-with-footer.png
new file mode 100644
index 000000000..8fff77269
Binary files /dev/null and b/tests/ref/grid-header-too-large-repeating-orphan-with-footer.png differ
diff --git a/tests/ref/grid-header-too-large-repeating-orphan.png b/tests/ref/grid-header-too-large-repeating-orphan.png
new file mode 100644
index 000000000..76d54c341
Binary files /dev/null and b/tests/ref/grid-header-too-large-repeating-orphan.png differ
diff --git a/tests/ref/grid-rtl-counter.png b/tests/ref/grid-rtl-counter.png
new file mode 100644
index 000000000..fb0df44ad
Binary files /dev/null and b/tests/ref/grid-rtl-counter.png differ
diff --git a/tests/ref/grid-rtl-rowspan-counter-equal.png b/tests/ref/grid-rtl-rowspan-counter-equal.png
new file mode 100644
index 000000000..fb0df44ad
Binary files /dev/null and b/tests/ref/grid-rtl-rowspan-counter-equal.png differ
diff --git a/tests/ref/grid-rtl-rowspan-counter-mixed-1.png b/tests/ref/grid-rtl-rowspan-counter-mixed-1.png
new file mode 100644
index 000000000..fffccc566
Binary files /dev/null and b/tests/ref/grid-rtl-rowspan-counter-mixed-1.png differ
diff --git a/tests/ref/grid-rtl-rowspan-counter-mixed-2.png b/tests/ref/grid-rtl-rowspan-counter-mixed-2.png
new file mode 100644
index 000000000..c091f3a80
Binary files /dev/null and b/tests/ref/grid-rtl-rowspan-counter-mixed-2.png differ
diff --git a/tests/ref/grid-rtl-rowspan-counter-unequal-1.png b/tests/ref/grid-rtl-rowspan-counter-unequal-1.png
new file mode 100644
index 000000000..c091f3a80
Binary files /dev/null and b/tests/ref/grid-rtl-rowspan-counter-unequal-1.png differ
diff --git a/tests/ref/grid-rtl-rowspan-counter-unequal-2.png b/tests/ref/grid-rtl-rowspan-counter-unequal-2.png
new file mode 100644
index 000000000..fffccc566
Binary files /dev/null and b/tests/ref/grid-rtl-rowspan-counter-unequal-2.png differ
diff --git a/tests/ref/grid-subheaders-alone-no-orphan-prevention.png b/tests/ref/grid-subheaders-alone-no-orphan-prevention.png
new file mode 100644
index 000000000..17bf3fe4f
Binary files /dev/null and b/tests/ref/grid-subheaders-alone-no-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-alone-with-footer-no-orphan-prevention.png b/tests/ref/grid-subheaders-alone-with-footer-no-orphan-prevention.png
new file mode 100644
index 000000000..9b083f378
Binary files /dev/null and b/tests/ref/grid-subheaders-alone-with-footer-no-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-alone-with-footer.png b/tests/ref/grid-subheaders-alone-with-footer.png
new file mode 100644
index 000000000..41bf88bc4
Binary files /dev/null and b/tests/ref/grid-subheaders-alone-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-alone-with-gutter-and-footer-no-orphan-prevention.png b/tests/ref/grid-subheaders-alone-with-gutter-and-footer-no-orphan-prevention.png
new file mode 100644
index 000000000..7d6cc45e0
Binary files /dev/null and b/tests/ref/grid-subheaders-alone-with-gutter-and-footer-no-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-alone-with-gutter-no-orphan-prevention.png b/tests/ref/grid-subheaders-alone-with-gutter-no-orphan-prevention.png
new file mode 100644
index 000000000..17bf3fe4f
Binary files /dev/null and b/tests/ref/grid-subheaders-alone-with-gutter-no-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-alone.png b/tests/ref/grid-subheaders-alone.png
new file mode 100644
index 000000000..0e05dda83
Binary files /dev/null and b/tests/ref/grid-subheaders-alone.png differ
diff --git a/tests/ref/grid-subheaders-basic-non-consecutive-with-footer.png b/tests/ref/grid-subheaders-basic-non-consecutive-with-footer.png
new file mode 100644
index 000000000..6f2a57beb
Binary files /dev/null and b/tests/ref/grid-subheaders-basic-non-consecutive-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-basic-non-consecutive.png b/tests/ref/grid-subheaders-basic-non-consecutive.png
new file mode 100644
index 000000000..9f3f84402
Binary files /dev/null and b/tests/ref/grid-subheaders-basic-non-consecutive.png differ
diff --git a/tests/ref/grid-subheaders-basic-replace.png b/tests/ref/grid-subheaders-basic-replace.png
new file mode 100644
index 000000000..2b3baa379
Binary files /dev/null and b/tests/ref/grid-subheaders-basic-replace.png differ
diff --git a/tests/ref/grid-subheaders-basic-with-footer.png b/tests/ref/grid-subheaders-basic-with-footer.png
new file mode 100644
index 000000000..521656146
Binary files /dev/null and b/tests/ref/grid-subheaders-basic-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-basic.png b/tests/ref/grid-subheaders-basic.png
new file mode 100644
index 000000000..5a6468075
Binary files /dev/null and b/tests/ref/grid-subheaders-basic.png differ
diff --git a/tests/ref/grid-subheaders-colorful.png b/tests/ref/grid-subheaders-colorful.png
new file mode 100644
index 000000000..38bb4ad8b
Binary files /dev/null and b/tests/ref/grid-subheaders-colorful.png differ
diff --git a/tests/ref/grid-subheaders-demo.png b/tests/ref/grid-subheaders-demo.png
new file mode 100644
index 000000000..ec1cd998c
Binary files /dev/null and b/tests/ref/grid-subheaders-demo.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-row-right-after-with-footer.png b/tests/ref/grid-subheaders-multi-page-row-right-after-with-footer.png
new file mode 100644
index 000000000..119a2c22b
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-row-right-after-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-row-right-after.png b/tests/ref/grid-subheaders-multi-page-row-right-after.png
new file mode 100644
index 000000000..c9e30869c
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-row-right-after.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-row-with-footer.png b/tests/ref/grid-subheaders-multi-page-row-with-footer.png
new file mode 100644
index 000000000..a440eac40
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-row-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-row.png b/tests/ref/grid-subheaders-multi-page-row.png
new file mode 100644
index 000000000..637ca3fb1
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-row.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-rowspan-gutter.png b/tests/ref/grid-subheaders-multi-page-rowspan-gutter.png
new file mode 100644
index 000000000..53beeb02e
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-rowspan-gutter.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-rowspan-right-after.png b/tests/ref/grid-subheaders-multi-page-rowspan-right-after.png
new file mode 100644
index 000000000..5fe1eacf2
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-rowspan-right-after.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-rowspan-with-footer.png b/tests/ref/grid-subheaders-multi-page-rowspan-with-footer.png
new file mode 100644
index 000000000..b91046675
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-rowspan-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-multi-page-rowspan.png b/tests/ref/grid-subheaders-multi-page-rowspan.png
new file mode 100644
index 000000000..342b05695
Binary files /dev/null and b/tests/ref/grid-subheaders-multi-page-rowspan.png differ
diff --git a/tests/ref/grid-subheaders-non-repeat-replace.png b/tests/ref/grid-subheaders-non-repeat-replace.png
new file mode 100644
index 000000000..e9c254b46
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeat-replace.png differ
diff --git a/tests/ref/grid-subheaders-non-repeat.png b/tests/ref/grid-subheaders-non-repeat.png
new file mode 100644
index 000000000..030f1baae
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeat.png differ
diff --git a/tests/ref/grid-subheaders-non-repeating-header-before-multi-page-row.png b/tests/ref/grid-subheaders-non-repeating-header-before-multi-page-row.png
new file mode 100644
index 000000000..3db97f782
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeating-header-before-multi-page-row.png differ
diff --git a/tests/ref/grid-subheaders-non-repeating-orphan-prevention.png b/tests/ref/grid-subheaders-non-repeating-orphan-prevention.png
new file mode 100644
index 000000000..0f37c5d17
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeating-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-non-repeating-replace-didnt-fit-once.png b/tests/ref/grid-subheaders-non-repeating-replace-didnt-fit-once.png
new file mode 100644
index 000000000..6685125a4
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeating-replace-didnt-fit-once.png differ
diff --git a/tests/ref/grid-subheaders-non-repeating-replace-orphan.png b/tests/ref/grid-subheaders-non-repeating-replace-orphan.png
new file mode 100644
index 000000000..ffa465c42
Binary files /dev/null and b/tests/ref/grid-subheaders-non-repeating-replace-orphan.png differ
diff --git a/tests/ref/grid-subheaders-repeat-gutter.png b/tests/ref/grid-subheaders-repeat-gutter.png
new file mode 100644
index 000000000..f8f7380ed
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-gutter.png differ
diff --git a/tests/ref/grid-subheaders-repeat-non-consecutive.png b/tests/ref/grid-subheaders-repeat-non-consecutive.png
new file mode 100644
index 000000000..2e0fe2364
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-non-consecutive.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-didnt-fit-once.png b/tests/ref/grid-subheaders-repeat-replace-didnt-fit-once.png
new file mode 100644
index 000000000..df984bd60
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-didnt-fit-once.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-double-orphan.png b/tests/ref/grid-subheaders-repeat-replace-double-orphan.png
new file mode 100644
index 000000000..e340e6817
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-double-orphan.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-child.png b/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-child.png
new file mode 100644
index 000000000..80f9b12bc
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-child.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-gutter.png b/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-gutter.png
new file mode 100644
index 000000000..38521e44a
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-gutter-orphan-at-gutter.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-gutter.png b/tests/ref/grid-subheaders-repeat-replace-gutter.png
new file mode 100644
index 000000000..e87e3b5bf
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-gutter.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-multiple-levels.png b/tests/ref/grid-subheaders-repeat-replace-multiple-levels.png
new file mode 100644
index 000000000..d6f691e43
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-multiple-levels.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-orphan.png b/tests/ref/grid-subheaders-repeat-replace-orphan.png
new file mode 100644
index 000000000..c28e9d4ff
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-orphan.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-short-lived.png b/tests/ref/grid-subheaders-repeat-replace-short-lived.png
new file mode 100644
index 000000000..d041888c8
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-short-lived.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-with-footer-orphan.png b/tests/ref/grid-subheaders-repeat-replace-with-footer-orphan.png
new file mode 100644
index 000000000..b50fae716
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-with-footer-orphan.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace-with-footer.png b/tests/ref/grid-subheaders-repeat-replace-with-footer.png
new file mode 100644
index 000000000..7191bfb64
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-repeat-replace.png b/tests/ref/grid-subheaders-repeat-replace.png
new file mode 100644
index 000000000..9fe729401
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-replace.png differ
diff --git a/tests/ref/grid-subheaders-repeat-short-lived-also-replaces.png b/tests/ref/grid-subheaders-repeat-short-lived-also-replaces.png
new file mode 100644
index 000000000..788837c78
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-short-lived-also-replaces.png differ
diff --git a/tests/ref/grid-subheaders-repeat-with-footer.png b/tests/ref/grid-subheaders-repeat-with-footer.png
new file mode 100644
index 000000000..39f8465e7
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat-with-footer.png differ
diff --git a/tests/ref/grid-subheaders-repeat.png b/tests/ref/grid-subheaders-repeat.png
new file mode 100644
index 000000000..c57ed769f
Binary files /dev/null and b/tests/ref/grid-subheaders-repeat.png differ
diff --git a/tests/ref/grid-subheaders-repeating-orphan-prevention.png b/tests/ref/grid-subheaders-repeating-orphan-prevention.png
new file mode 100644
index 000000000..0f37c5d17
Binary files /dev/null and b/tests/ref/grid-subheaders-repeating-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-short-lived-no-orphan-prevention.png b/tests/ref/grid-subheaders-short-lived-no-orphan-prevention.png
new file mode 100644
index 000000000..560670524
Binary files /dev/null and b/tests/ref/grid-subheaders-short-lived-no-orphan-prevention.png differ
diff --git a/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-auto.png b/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-auto.png
new file mode 100644
index 000000000..c7d632ade
Binary files /dev/null and b/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-auto.png differ
diff --git a/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-relative.png b/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-relative.png
new file mode 100644
index 000000000..324787b25
Binary files /dev/null and b/tests/ref/grid-subheaders-too-large-non-repeating-orphan-before-relative.png differ
diff --git a/tests/ref/grid-subheaders-too-large-repeating-orphan-before-auto.png b/tests/ref/grid-subheaders-too-large-repeating-orphan-before-auto.png
new file mode 100644
index 000000000..de77beb29
Binary files /dev/null and b/tests/ref/grid-subheaders-too-large-repeating-orphan-before-auto.png differ
diff --git a/tests/ref/grid-subheaders-too-large-repeating-orphan-before-relative.png b/tests/ref/grid-subheaders-too-large-repeating-orphan-before-relative.png
new file mode 100644
index 000000000..dfcac8500
Binary files /dev/null and b/tests/ref/grid-subheaders-too-large-repeating-orphan-before-relative.png differ
diff --git a/tests/ref/html/multi-header-inside-table.html b/tests/ref/html/multi-header-inside-table.html
new file mode 100644
index 000000000..a4a61a697
--- /dev/null
+++ b/tests/ref/html/multi-header-inside-table.html
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <table>
+      <thead>
+        <tr>
+          <th>First</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Second</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Level 2</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Level 3</th>
+          <th>Header</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td>Body</td>
+          <td>Cells</td>
+        </tr>
+        <tr>
+          <td>Yet</td>
+          <td>More</td>
+        </tr>
+        <tr>
+          <th>Level 2</th>
+          <th>Header Inside</th>
+        </tr>
+        <tr>
+          <th>Level 3</th>
+          <th></th>
+        </tr>
+        <tr>
+          <td>Even</td>
+          <td>More</td>
+        </tr>
+        <tr>
+          <td>Body</td>
+          <td>Cells</td>
+        </tr>
+        <tr>
+          <th>One Last Header</th>
+          <th>For Good Measure</th>
+        </tr>
+      </tbody>
+      <tfoot>
+        <tr>
+          <td>Footer</td>
+          <td>Row</td>
+        </tr>
+        <tr>
+          <td>Ending</td>
+          <td>Table</td>
+        </tr>
+      </tfoot>
+    </table>
+  </body>
+</html>
diff --git a/tests/ref/html/multi-header-table.html b/tests/ref/html/multi-header-table.html
new file mode 100644
index 000000000..8a34ac170
--- /dev/null
+++ b/tests/ref/html/multi-header-table.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <table>
+      <thead>
+        <tr>
+          <th>First</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Second</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Level 2</th>
+          <th>Header</th>
+        </tr>
+        <tr>
+          <th>Level 3</th>
+          <th>Header</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td>Body</td>
+          <td>Cells</td>
+        </tr>
+        <tr>
+          <td>Yet</td>
+          <td>More</td>
+        </tr>
+      </tbody>
+      <tfoot>
+        <tr>
+          <td>Footer</td>
+          <td>Row</td>
+        </tr>
+        <tr>
+          <td>Ending</td>
+          <td>Table</td>
+        </tr>
+      </tfoot>
+    </table>
+  </body>
+</html>
diff --git a/tests/ref/image-exif-rotation.png b/tests/ref/image-exif-rotation.png
new file mode 100644
index 000000000..a319a5c5b
Binary files /dev/null and b/tests/ref/image-exif-rotation.png differ
diff --git a/tests/ref/issue-1433-footnote-in-list.png b/tests/ref/issue-1433-footnote-in-list.png
index a012e2345..19934a709 100644
Binary files a/tests/ref/issue-1433-footnote-in-list.png and b/tests/ref/issue-1433-footnote-in-list.png differ
diff --git a/tests/ref/issue-1597-cite-footnote.png b/tests/ref/issue-1597-cite-footnote.png
index 6ec017c76..e7c076b14 100644
Binary files a/tests/ref/issue-1597-cite-footnote.png and b/tests/ref/issue-1597-cite-footnote.png differ
diff --git a/tests/ref/issue-1617-mat-align.png b/tests/ref/issue-1617-mat-align.png
index bd4ea16fe..73d8ae824 100644
Binary files a/tests/ref/issue-1617-mat-align.png and b/tests/ref/issue-1617-mat-align.png differ
diff --git a/tests/ref/issue-2531-cite-show-set.png b/tests/ref/issue-2531-cite-show-set.png
index 568c77e56..93b69b7d8 100644
Binary files a/tests/ref/issue-2531-cite-show-set.png and b/tests/ref/issue-2531-cite-show-set.png differ
diff --git a/tests/ref/issue-3481-cite-location.png b/tests/ref/issue-3481-cite-location.png
index 01139e25f..110ee4a24 100644
Binary files a/tests/ref/issue-3481-cite-location.png and b/tests/ref/issue-3481-cite-location.png differ
diff --git a/tests/ref/issue-3699-cite-twice-et-al.png b/tests/ref/issue-3699-cite-twice-et-al.png
index 62921dd64..46b98c39d 100644
Binary files a/tests/ref/issue-3699-cite-twice-et-al.png and b/tests/ref/issue-3699-cite-twice-et-al.png differ
diff --git a/tests/ref/issue-3774-math-call-empty-2d-args.png b/tests/ref/issue-3774-math-call-empty-2d-args.png
index c1bf52d00..52472d8db 100644
Binary files a/tests/ref/issue-3774-math-call-empty-2d-args.png and b/tests/ref/issue-3774-math-call-empty-2d-args.png differ
diff --git a/tests/ref/issue-4454-footnote-ref-numbering.png b/tests/ref/issue-4454-footnote-ref-numbering.png
index a517d5fb4..bf23221ae 100644
Binary files a/tests/ref/issue-4454-footnote-ref-numbering.png and b/tests/ref/issue-4454-footnote-ref-numbering.png differ
diff --git a/tests/ref/issue-4618-bibliography-set-heading-level.png b/tests/ref/issue-4618-bibliography-set-heading-level.png
index 3bf2096e3..6de2bed29 100644
Binary files a/tests/ref/issue-4618-bibliography-set-heading-level.png and b/tests/ref/issue-4618-bibliography-set-heading-level.png differ
diff --git a/tests/ref/issue-4828-math-number-multi-char.png b/tests/ref/issue-4828-math-number-multi-char.png
new file mode 100644
index 000000000..b365645d3
Binary files /dev/null and b/tests/ref/issue-4828-math-number-multi-char.png differ
diff --git a/tests/ref/issue-5256-multiple-footnotes-in-footnote.png b/tests/ref/issue-5256-multiple-footnotes-in-footnote.png
index f9c173351..f32d192e6 100644
Binary files a/tests/ref/issue-5256-multiple-footnotes-in-footnote.png and b/tests/ref/issue-5256-multiple-footnotes-in-footnote.png differ
diff --git a/tests/ref/issue-5354-footnote-empty-frame-infinite-loop.png b/tests/ref/issue-5354-footnote-empty-frame-infinite-loop.png
index acad56b68..99da601ae 100644
Binary files a/tests/ref/issue-5354-footnote-empty-frame-infinite-loop.png and b/tests/ref/issue-5354-footnote-empty-frame-infinite-loop.png differ
diff --git a/tests/ref/issue-5359-column-override-stays-inside-footer.png b/tests/ref/issue-5359-column-override-stays-inside-footer.png
new file mode 100644
index 000000000..8339a4090
Binary files /dev/null and b/tests/ref/issue-5359-column-override-stays-inside-footer.png differ
diff --git a/tests/ref/issue-5359-column-override-stays-inside-header.png b/tests/ref/issue-5359-column-override-stays-inside-header.png
new file mode 100644
index 000000000..8339a4090
Binary files /dev/null and b/tests/ref/issue-5359-column-override-stays-inside-header.png differ
diff --git a/tests/ref/issue-5435-footnote-migration-in-floats.png b/tests/ref/issue-5435-footnote-migration-in-floats.png
index 672a5af83..58d71fc72 100644
Binary files a/tests/ref/issue-5435-footnote-migration-in-floats.png and b/tests/ref/issue-5435-footnote-migration-in-floats.png differ
diff --git a/tests/ref/issue-5489-matrix-stray-linebreak.png b/tests/ref/issue-5489-matrix-stray-linebreak.png
new file mode 100644
index 000000000..f4e41bf99
Binary files /dev/null and b/tests/ref/issue-5489-matrix-stray-linebreak.png differ
diff --git a/tests/ref/issue-5496-footnote-in-float-never-fits.png b/tests/ref/issue-5496-footnote-in-float-never-fits.png
index 4ae5903d8..85851f5ad 100644
Binary files a/tests/ref/issue-5496-footnote-in-float-never-fits.png and b/tests/ref/issue-5496-footnote-in-float-never-fits.png differ
diff --git a/tests/ref/issue-5496-footnote-never-fits-multiple.png b/tests/ref/issue-5496-footnote-never-fits-multiple.png
index 24fcf7098..000a10745 100644
Binary files a/tests/ref/issue-5496-footnote-never-fits-multiple.png and b/tests/ref/issue-5496-footnote-never-fits-multiple.png differ
diff --git a/tests/ref/issue-5496-footnote-never-fits.png b/tests/ref/issue-5496-footnote-never-fits.png
index 4ae5903d8..85851f5ad 100644
Binary files a/tests/ref/issue-5496-footnote-never-fits.png and b/tests/ref/issue-5496-footnote-never-fits.png differ
diff --git a/tests/ref/issue-5496-footnote-separator-never-fits.png b/tests/ref/issue-5496-footnote-separator-never-fits.png
index 4fe4fdee3..3b342619c 100644
Binary files a/tests/ref/issue-5496-footnote-separator-never-fits.png and b/tests/ref/issue-5496-footnote-separator-never-fits.png differ
diff --git a/tests/ref/issue-5503-cite-group-interrupted-by-par-align.png b/tests/ref/issue-5503-cite-group-interrupted-by-par-align.png
index 166331587..8c91ad552 100644
Binary files a/tests/ref/issue-5503-cite-group-interrupted-by-par-align.png and b/tests/ref/issue-5503-cite-group-interrupted-by-par-align.png differ
diff --git a/tests/ref/issue-5503-cite-in-align.png b/tests/ref/issue-5503-cite-in-align.png
index aeb72aa0d..eabc4dc3d 100644
Binary files a/tests/ref/issue-5503-cite-in-align.png and b/tests/ref/issue-5503-cite-in-align.png differ
diff --git a/tests/ref/issue-6170-equation-stroke.png b/tests/ref/issue-6170-equation-stroke.png
new file mode 100644
index 000000000..a375931b5
Binary files /dev/null and b/tests/ref/issue-6170-equation-stroke.png differ
diff --git a/tests/ref/issue-622-hide-meta-cite.png b/tests/ref/issue-622-hide-meta-cite.png
index c3c9b188a..1fe3f2519 100644
Binary files a/tests/ref/issue-622-hide-meta-cite.png and b/tests/ref/issue-622-hide-meta-cite.png differ
diff --git a/tests/ref/issue-6242-tight-list-attach-spacing.png b/tests/ref/issue-6242-tight-list-attach-spacing.png
new file mode 100644
index 000000000..48920008b
Binary files /dev/null and b/tests/ref/issue-6242-tight-list-attach-spacing.png differ
diff --git a/tests/ref/issue-6399-grid-cell-colspan-set-rule.png b/tests/ref/issue-6399-grid-cell-colspan-set-rule.png
new file mode 100644
index 000000000..a40eda78d
Binary files /dev/null and b/tests/ref/issue-6399-grid-cell-colspan-set-rule.png differ
diff --git a/tests/ref/issue-6399-grid-cell-rowspan-set-rule.png b/tests/ref/issue-6399-grid-cell-rowspan-set-rule.png
new file mode 100644
index 000000000..a40eda78d
Binary files /dev/null and b/tests/ref/issue-6399-grid-cell-rowspan-set-rule.png differ
diff --git a/tests/ref/issue-758-link-repeat.png b/tests/ref/issue-758-link-repeat.png
index aaec20d23..5db44c314 100644
Binary files a/tests/ref/issue-758-link-repeat.png and b/tests/ref/issue-758-link-repeat.png differ
diff --git a/tests/ref/issue-785-cite-locate.png b/tests/ref/issue-785-cite-locate.png
index d387ed0d5..c80314544 100644
Binary files a/tests/ref/issue-785-cite-locate.png and b/tests/ref/issue-785-cite-locate.png differ
diff --git a/tests/ref/issue-870-image-rotation.png b/tests/ref/issue-870-image-rotation.png
deleted file mode 100644
index c321a1a93..000000000
Binary files a/tests/ref/issue-870-image-rotation.png and /dev/null differ
diff --git a/tests/ref/issue-footnotes-skip-first-page.png b/tests/ref/issue-footnotes-skip-first-page.png
index b7a8ce62c..7e4dbd566 100644
Binary files a/tests/ref/issue-footnotes-skip-first-page.png and b/tests/ref/issue-footnotes-skip-first-page.png differ
diff --git a/tests/ref/linebreak-cite-punctuation.png b/tests/ref/linebreak-cite-punctuation.png
index f544aca4d..8e9e945d0 100644
Binary files a/tests/ref/linebreak-cite-punctuation.png and b/tests/ref/linebreak-cite-punctuation.png differ
diff --git a/tests/ref/linebreak-link-end.png b/tests/ref/linebreak-link-end.png
index bcc88751c..43c771a85 100644
Binary files a/tests/ref/linebreak-link-end.png and b/tests/ref/linebreak-link-end.png differ
diff --git a/tests/ref/linebreak-link-justify.png b/tests/ref/linebreak-link-justify.png
index a80e30743..3175f657c 100644
Binary files a/tests/ref/linebreak-link-justify.png and b/tests/ref/linebreak-link-justify.png differ
diff --git a/tests/ref/linebreak-link.png b/tests/ref/linebreak-link.png
index 19eba3054..2f6b77eaa 100644
Binary files a/tests/ref/linebreak-link.png and b/tests/ref/linebreak-link.png differ
diff --git a/tests/ref/link-basic.png b/tests/ref/link-basic.png
index 0d2bd7533..f53223ffd 100644
Binary files a/tests/ref/link-basic.png and b/tests/ref/link-basic.png differ
diff --git a/tests/ref/link-bracket-balanced.png b/tests/ref/link-bracket-balanced.png
index 8b7e02db2..01bfa8797 100644
Binary files a/tests/ref/link-bracket-balanced.png and b/tests/ref/link-bracket-balanced.png differ
diff --git a/tests/ref/link-bracket-unbalanced-closing.png b/tests/ref/link-bracket-unbalanced-closing.png
index f54ad32c4..dbd418a0a 100644
Binary files a/tests/ref/link-bracket-unbalanced-closing.png and b/tests/ref/link-bracket-unbalanced-closing.png differ
diff --git a/tests/ref/link-show.png b/tests/ref/link-show.png
index ac6df7fef..69e70ac98 100644
Binary files a/tests/ref/link-show.png and b/tests/ref/link-show.png differ
diff --git a/tests/ref/link-to-label.png b/tests/ref/link-to-label.png
index 633ee9881..39433c13c 100644
Binary files a/tests/ref/link-to-label.png and b/tests/ref/link-to-label.png differ
diff --git a/tests/ref/link-to-page.png b/tests/ref/link-to-page.png
index 2dbf76778..d618f066b 100644
Binary files a/tests/ref/link-to-page.png and b/tests/ref/link-to-page.png differ
diff --git a/tests/ref/link-trailing-period.png b/tests/ref/link-trailing-period.png
index b458d201a..80e0bd70a 100644
Binary files a/tests/ref/link-trailing-period.png and b/tests/ref/link-trailing-period.png differ
diff --git a/tests/ref/link-transformed.png b/tests/ref/link-transformed.png
index 4efa32f3c..c391f080b 100644
Binary files a/tests/ref/link-transformed.png and b/tests/ref/link-transformed.png differ
diff --git a/tests/ref/math-accent-bottom-high-base.png b/tests/ref/math-accent-bottom-high-base.png
new file mode 100644
index 000000000..4893575cb
Binary files /dev/null and b/tests/ref/math-accent-bottom-high-base.png differ
diff --git a/tests/ref/math-accent-bottom-sized.png b/tests/ref/math-accent-bottom-sized.png
new file mode 100644
index 000000000..5455b2f5b
Binary files /dev/null and b/tests/ref/math-accent-bottom-sized.png differ
diff --git a/tests/ref/math-accent-bottom-subscript.png b/tests/ref/math-accent-bottom-subscript.png
new file mode 100644
index 000000000..818544445
Binary files /dev/null and b/tests/ref/math-accent-bottom-subscript.png differ
diff --git a/tests/ref/math-accent-bottom-wide-base.png b/tests/ref/math-accent-bottom-wide-base.png
new file mode 100644
index 000000000..fb4a1169b
Binary files /dev/null and b/tests/ref/math-accent-bottom-wide-base.png differ
diff --git a/tests/ref/math-accent-bottom.png b/tests/ref/math-accent-bottom.png
new file mode 100644
index 000000000..bd1b92146
Binary files /dev/null and b/tests/ref/math-accent-bottom.png differ
diff --git a/tests/ref/math-accent-dotless-disabled.png b/tests/ref/math-accent-dotless-disabled.png
new file mode 100644
index 000000000..d75ec4580
Binary files /dev/null and b/tests/ref/math-accent-dotless-disabled.png differ
diff --git a/tests/ref/math-accent-dotless-greedy.png b/tests/ref/math-accent-dotless-greedy.png
new file mode 100644
index 000000000..2c28363a1
Binary files /dev/null and b/tests/ref/math-accent-dotless-greedy.png differ
diff --git a/tests/ref/math-accent-dotless-set-rule.png b/tests/ref/math-accent-dotless-set-rule.png
new file mode 100644
index 000000000..ae5ef017a
Binary files /dev/null and b/tests/ref/math-accent-dotless-set-rule.png differ
diff --git a/tests/ref/math-accent-flattened.png b/tests/ref/math-accent-flattened.png
new file mode 100644
index 000000000..f7764cb74
Binary files /dev/null and b/tests/ref/math-accent-flattened.png differ
diff --git a/tests/ref/math-accent-nested.png b/tests/ref/math-accent-nested.png
new file mode 100644
index 000000000..4b3d58f38
Binary files /dev/null and b/tests/ref/math-accent-nested.png differ
diff --git a/tests/ref/math-accent-wide-base.png b/tests/ref/math-accent-wide-base.png
index af716bf45..793ab30bd 100644
Binary files a/tests/ref/math-accent-wide-base.png and b/tests/ref/math-accent-wide-base.png differ
diff --git a/tests/ref/math-attach-kerning-mixed.png b/tests/ref/math-attach-kerning-mixed.png
index 9d0bea27a..64a546869 100644
Binary files a/tests/ref/math-attach-kerning-mixed.png and b/tests/ref/math-attach-kerning-mixed.png differ
diff --git a/tests/ref/math-attach-limit-long.png b/tests/ref/math-attach-limit-long.png
index b79e6ed4a..555f9c66c 100644
Binary files a/tests/ref/math-attach-limit-long.png and b/tests/ref/math-attach-limit-long.png differ
diff --git a/tests/ref/math-attach-prescripts.png b/tests/ref/math-attach-prescripts.png
index f0d21cb8a..bcd60c0a0 100644
Binary files a/tests/ref/math-attach-prescripts.png and b/tests/ref/math-attach-prescripts.png differ
diff --git a/tests/ref/math-call-symbol.png b/tests/ref/math-call-symbol.png
new file mode 100644
index 000000000..8308bece1
Binary files /dev/null and b/tests/ref/math-call-symbol.png differ
diff --git a/tests/ref/math-cases-gap.png b/tests/ref/math-cases-gap.png
index 746572fac..6bd8e2055 100644
Binary files a/tests/ref/math-cases-gap.png and b/tests/ref/math-cases-gap.png differ
diff --git a/tests/ref/math-cases-linebreaks.png b/tests/ref/math-cases-linebreaks.png
index 543d5384c..65b4e4025 100644
Binary files a/tests/ref/math-cases-linebreaks.png and b/tests/ref/math-cases-linebreaks.png differ
diff --git a/tests/ref/math-cases.png b/tests/ref/math-cases.png
index ed0423def..34567837d 100644
Binary files a/tests/ref/math-cases.png and b/tests/ref/math-cases.png differ
diff --git a/tests/ref/math-equation-font.png b/tests/ref/math-equation-font.png
index eb84634e5..ec3c72311 100644
Binary files a/tests/ref/math-equation-font.png and b/tests/ref/math-equation-font.png differ
diff --git a/tests/ref/math-equation-numbering.png b/tests/ref/math-equation-numbering.png
index b127a9a1d..9606b30dd 100644
Binary files a/tests/ref/math-equation-numbering.png and b/tests/ref/math-equation-numbering.png differ
diff --git a/tests/ref/math-frac-precedence.png b/tests/ref/math-frac-precedence.png
index 973c433e2..bddcb43c3 100644
Binary files a/tests/ref/math-frac-precedence.png and b/tests/ref/math-frac-precedence.png differ
diff --git a/tests/ref/math-linebreaking-after-relation-without-space.png b/tests/ref/math-linebreaking-after-relation-without-space.png
index 7c569ad1f..fb1413768 100644
Binary files a/tests/ref/math-linebreaking-after-relation-without-space.png and b/tests/ref/math-linebreaking-after-relation-without-space.png differ
diff --git a/tests/ref/math-lr-mid-class.png b/tests/ref/math-lr-mid-class.png
new file mode 100644
index 000000000..6487578d7
Binary files /dev/null and b/tests/ref/math-lr-mid-class.png differ
diff --git a/tests/ref/math-lr-mid-size-nested-equation.png b/tests/ref/math-lr-mid-size-nested-equation.png
index df0106689..750ad14c8 100644
Binary files a/tests/ref/math-lr-mid-size-nested-equation.png and b/tests/ref/math-lr-mid-size-nested-equation.png differ
diff --git a/tests/ref/math-lr-mid-size.png b/tests/ref/math-lr-mid-size.png
index 12b4c0868..07d337225 100644
Binary files a/tests/ref/math-lr-mid-size.png and b/tests/ref/math-lr-mid-size.png differ
diff --git a/tests/ref/math-lr-mid.png b/tests/ref/math-lr-mid.png
index 42e6da706..8af85b005 100644
Binary files a/tests/ref/math-lr-mid.png and b/tests/ref/math-lr-mid.png differ
diff --git a/tests/ref/math-mat-align-explicit-alternating.png b/tests/ref/math-mat-align-explicit-alternating.png
index 1ebcc7b68..52a51378b 100644
Binary files a/tests/ref/math-mat-align-explicit-alternating.png and b/tests/ref/math-mat-align-explicit-alternating.png differ
diff --git a/tests/ref/math-mat-align-explicit-left.png b/tests/ref/math-mat-align-explicit-left.png
index cb9819248..09c5cb3d4 100644
Binary files a/tests/ref/math-mat-align-explicit-left.png and b/tests/ref/math-mat-align-explicit-left.png differ
diff --git a/tests/ref/math-mat-align-explicit-mixed.png b/tests/ref/math-mat-align-explicit-mixed.png
index 88ccd6de7..f2b38b3eb 100644
Binary files a/tests/ref/math-mat-align-explicit-mixed.png and b/tests/ref/math-mat-align-explicit-mixed.png differ
diff --git a/tests/ref/math-mat-align-explicit-right.png b/tests/ref/math-mat-align-explicit-right.png
index b537e6571..5db5378f9 100644
Binary files a/tests/ref/math-mat-align-explicit-right.png and b/tests/ref/math-mat-align-explicit-right.png differ
diff --git a/tests/ref/math-mat-align-implicit.png b/tests/ref/math-mat-align-implicit.png
index b184d9140..cd6833155 100644
Binary files a/tests/ref/math-mat-align-implicit.png and b/tests/ref/math-mat-align-implicit.png differ
diff --git a/tests/ref/math-mat-align-signed-numbers.png b/tests/ref/math-mat-align-signed-numbers.png
index c92743797..4463e2fb1 100644
Binary files a/tests/ref/math-mat-align-signed-numbers.png and b/tests/ref/math-mat-align-signed-numbers.png differ
diff --git a/tests/ref/math-mat-align.png b/tests/ref/math-mat-align.png
index 66513dd53..eaa3233d8 100644
Binary files a/tests/ref/math-mat-align.png and b/tests/ref/math-mat-align.png differ
diff --git a/tests/ref/math-mat-augment-set.png b/tests/ref/math-mat-augment-set.png
index c5881b139..1a6676159 100644
Binary files a/tests/ref/math-mat-augment-set.png and b/tests/ref/math-mat-augment-set.png differ
diff --git a/tests/ref/math-mat-augment.png b/tests/ref/math-mat-augment.png
index 0e2a42a24..306c4b199 100644
Binary files a/tests/ref/math-mat-augment.png and b/tests/ref/math-mat-augment.png differ
diff --git a/tests/ref/math-mat-baseline.png b/tests/ref/math-mat-baseline.png
index d2f266213..01928f724 100644
Binary files a/tests/ref/math-mat-baseline.png and b/tests/ref/math-mat-baseline.png differ
diff --git a/tests/ref/math-mat-gap.png b/tests/ref/math-mat-gap.png
index e4f87b59b..90525ff2e 100644
Binary files a/tests/ref/math-mat-gap.png and b/tests/ref/math-mat-gap.png differ
diff --git a/tests/ref/math-mat-gaps.png b/tests/ref/math-mat-gaps.png
index 405358776..95cd6cf11 100644
Binary files a/tests/ref/math-mat-gaps.png and b/tests/ref/math-mat-gaps.png differ
diff --git a/tests/ref/math-mat-linebreaks.png b/tests/ref/math-mat-linebreaks.png
index 52ff0a8bb..6666749da 100644
Binary files a/tests/ref/math-mat-linebreaks.png and b/tests/ref/math-mat-linebreaks.png differ
diff --git a/tests/ref/math-mat-sparse.png b/tests/ref/math-mat-sparse.png
index e9f0d948c..c255fe3e5 100644
Binary files a/tests/ref/math-mat-sparse.png and b/tests/ref/math-mat-sparse.png differ
diff --git a/tests/ref/math-mat-spread.png b/tests/ref/math-mat-spread.png
index dc8b2bf7e..b8f539cca 100644
Binary files a/tests/ref/math-mat-spread.png and b/tests/ref/math-mat-spread.png differ
diff --git a/tests/ref/math-mat-vec-cases-unity.png b/tests/ref/math-mat-vec-cases-unity.png
new file mode 100644
index 000000000..bb85182e4
Binary files /dev/null and b/tests/ref/math-mat-vec-cases-unity.png differ
diff --git a/tests/ref/math-root-frame-size-index.png b/tests/ref/math-root-frame-size-index.png
index 41d4df2e9..f47049568 100644
Binary files a/tests/ref/math-root-frame-size-index.png and b/tests/ref/math-root-frame-size-index.png differ
diff --git a/tests/ref/math-root-large-index.png b/tests/ref/math-root-large-index.png
index 85689823d..29dd478fe 100644
Binary files a/tests/ref/math-root-large-index.png and b/tests/ref/math-root-large-index.png differ
diff --git a/tests/ref/math-shorthands.png b/tests/ref/math-shorthands.png
index 65b35acad..19bdb6be5 100644
Binary files a/tests/ref/math-shorthands.png and b/tests/ref/math-shorthands.png differ
diff --git a/tests/ref/math-vec-align-explicit-alternating.png b/tests/ref/math-vec-align-explicit-alternating.png
index 1ebcc7b68..52a51378b 100644
Binary files a/tests/ref/math-vec-align-explicit-alternating.png and b/tests/ref/math-vec-align-explicit-alternating.png differ
diff --git a/tests/ref/math-vec-align.png b/tests/ref/math-vec-align.png
index 680d0936d..07d58df72 100644
Binary files a/tests/ref/math-vec-align.png and b/tests/ref/math-vec-align.png differ
diff --git a/tests/ref/math-vec-gap.png b/tests/ref/math-vec-gap.png
index e48b3e902..ccfb21711 100644
Binary files a/tests/ref/math-vec-gap.png and b/tests/ref/math-vec-gap.png differ
diff --git a/tests/ref/math-vec-linebreaks.png b/tests/ref/math-vec-linebreaks.png
index 6eeed42b8..6666749da 100644
Binary files a/tests/ref/math-vec-linebreaks.png and b/tests/ref/math-vec-linebreaks.png differ
diff --git a/tests/ref/math-vec-wide.png b/tests/ref/math-vec-wide.png
index 9dc887a8c..000e3cf2a 100644
Binary files a/tests/ref/math-vec-wide.png and b/tests/ref/math-vec-wide.png differ
diff --git a/tests/ref/measure-citation-deeply-nested.png b/tests/ref/measure-citation-deeply-nested.png
index 596c351eb..6711fc732 100644
Binary files a/tests/ref/measure-citation-deeply-nested.png and b/tests/ref/measure-citation-deeply-nested.png differ
diff --git a/tests/ref/measure-citation-in-flow.png b/tests/ref/measure-citation-in-flow.png
index 18617beda..83f92aac4 100644
Binary files a/tests/ref/measure-citation-in-flow.png and b/tests/ref/measure-citation-in-flow.png differ
diff --git a/tests/ref/page-numbering-huge.png b/tests/ref/page-numbering-huge.png
new file mode 100644
index 000000000..4c886faa6
Binary files /dev/null and b/tests/ref/page-numbering-huge.png differ
diff --git a/tests/ref/par-semantic-align.png b/tests/ref/par-semantic-align.png
index eda496411..202236efe 100644
Binary files a/tests/ref/par-semantic-align.png and b/tests/ref/par-semantic-align.png differ
diff --git a/tests/ref/quote-cite-format-author-date.png b/tests/ref/quote-cite-format-author-date.png
index 4931969d5..dbd6a8d8f 100644
Binary files a/tests/ref/quote-cite-format-author-date.png and b/tests/ref/quote-cite-format-author-date.png differ
diff --git a/tests/ref/quote-cite-format-label-or-numeric.png b/tests/ref/quote-cite-format-label-or-numeric.png
index d1dadf0e2..22654a0d7 100644
Binary files a/tests/ref/quote-cite-format-label-or-numeric.png and b/tests/ref/quote-cite-format-label-or-numeric.png differ
diff --git a/tests/ref/quote-cite-format-note.png b/tests/ref/quote-cite-format-note.png
index 0cde539bd..bef078c9f 100644
Binary files a/tests/ref/quote-cite-format-note.png and b/tests/ref/quote-cite-format-note.png differ
diff --git a/tests/ref/quote-inline.png b/tests/ref/quote-inline.png
index c09faa3a8..9205d6839 100644
Binary files a/tests/ref/quote-inline.png and b/tests/ref/quote-inline.png differ
diff --git a/tests/ref/ref-basic.png b/tests/ref/ref-basic.png
index 79655eba9..d9068d93d 100644
Binary files a/tests/ref/ref-basic.png and b/tests/ref/ref-basic.png differ
diff --git a/tests/ref/ref-form-page-unambiguous.png b/tests/ref/ref-form-page-unambiguous.png
index e7baa2f2c..3b37f115b 100644
Binary files a/tests/ref/ref-form-page-unambiguous.png and b/tests/ref/ref-form-page-unambiguous.png differ
diff --git a/tests/ref/ref-form-page.png b/tests/ref/ref-form-page.png
index 52fde86d7..0cc29a4f1 100644
Binary files a/tests/ref/ref-form-page.png and b/tests/ref/ref-form-page.png differ
diff --git a/tests/ref/ref-supplements.png b/tests/ref/ref-supplements.png
index fd715339f..e400c1feb 100644
Binary files a/tests/ref/ref-supplements.png and b/tests/ref/ref-supplements.png differ
diff --git a/tests/ref/show-text-citation-smartquote.png b/tests/ref/show-text-citation-smartquote.png
index 604ecc24f..fc18b5a52 100644
Binary files a/tests/ref/show-text-citation-smartquote.png and b/tests/ref/show-text-citation-smartquote.png differ
diff --git a/tests/ref/show-text-citation.png b/tests/ref/show-text-citation.png
index a0e684935..e5ae8d317 100644
Binary files a/tests/ref/show-text-citation.png and b/tests/ref/show-text-citation.png differ
diff --git a/tests/ref/show-text-in-citation.png b/tests/ref/show-text-in-citation.png
index 392487bc8..6533a4f7c 100644
Binary files a/tests/ref/show-text-in-citation.png and b/tests/ref/show-text-in-citation.png differ
diff --git a/tests/ref/smartquote-disabled-temporarily.png b/tests/ref/smartquote-disabled-temporarily.png
index 4c565c01c..f4d08c4d1 100644
Binary files a/tests/ref/smartquote-disabled-temporarily.png and b/tests/ref/smartquote-disabled-temporarily.png differ
diff --git a/tests/ref/smartquote-fr.png b/tests/ref/smartquote-fr.png
index e28184226..6b7de7abe 100644
Binary files a/tests/ref/smartquote-fr.png and b/tests/ref/smartquote-fr.png differ
diff --git a/tests/ref/smartquote-ru.png b/tests/ref/smartquote-ru.png
index 05c79263f..867121d1e 100644
Binary files a/tests/ref/smartquote-ru.png and b/tests/ref/smartquote-ru.png differ
diff --git a/tests/ref/smartquote-uk.png b/tests/ref/smartquote-uk.png
new file mode 100644
index 000000000..7ac1c032e
Binary files /dev/null and b/tests/ref/smartquote-uk.png differ
diff --git a/tests/ref/smartquote-with-embedding-chars.png b/tests/ref/smartquote-with-embedding-chars.png
index a50042660..e4d33fae5 100644
Binary files a/tests/ref/smartquote-with-embedding-chars.png and b/tests/ref/smartquote-with-embedding-chars.png differ
diff --git a/tests/ref/table-header-citation.png b/tests/ref/table-header-citation.png
index 462198078..b9463b044 100644
Binary files a/tests/ref/table-header-citation.png and b/tests/ref/table-header-citation.png differ
diff --git a/tests/src/collect.rs b/tests/src/collect.rs
index 33f4f7366..173488b01 100644
--- a/tests/src/collect.rs
+++ b/tests/src/collect.rs
@@ -7,7 +7,9 @@ use std::sync::LazyLock;
 
 use ecow::{eco_format, EcoString};
 use typst_syntax::package::PackageVersion;
-use typst_syntax::{is_id_continue, is_ident, is_newline, FileId, Source, VirtualPath};
+use typst_syntax::{
+    is_id_continue, is_ident, is_newline, FileId, Lines, Source, VirtualPath,
+};
 use unscanny::Scanner;
 
 /// Collects all tests from all files.
@@ -30,7 +32,8 @@ pub struct Test {
 
 impl Display for Test {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{} ({})", self.name, self.pos)
+        // underline path
+        write!(f, "{} (\x1B[4m{}\x1B[0m)", self.name, self.pos)
     }
 }
 
@@ -78,6 +81,8 @@ impl Display for FileSize {
 pub struct Note {
     pub pos: FilePos,
     pub kind: NoteKind,
+    /// The file [`Self::range`] belongs to.
+    pub file: FileId,
     pub range: Option<Range<usize>>,
     pub message: String,
 }
@@ -340,9 +345,28 @@ impl<'a> Parser<'a> {
         let kind: NoteKind = head.parse().ok()?;
         self.s.eat_if(' ');
 
+        let mut file = None;
+        if self.s.eat_if('"') {
+            let path = self.s.eat_until(|c| is_newline(c) || c == '"');
+            if !self.s.eat_if('"') {
+                self.error("expected closing quote after file path");
+                return None;
+            }
+
+            let vpath = VirtualPath::new(path);
+            file = Some(FileId::new(None, vpath));
+
+            self.s.eat_if(' ');
+        }
+
         let mut range = None;
         if self.s.at('-') || self.s.at(char::is_numeric) {
-            range = self.parse_range(source);
+            if let Some(file) = file {
+                range = self.parse_range_external(file);
+            } else {
+                range = self.parse_range(source);
+            }
+
             if range.is_none() {
                 self.error("range is malformed");
                 return None;
@@ -358,11 +382,78 @@ impl<'a> Parser<'a> {
         Some(Note {
             pos: FilePos::new(self.path, self.line),
             kind,
+            file: file.unwrap_or(source.id()),
             range,
             message,
         })
     }
 
+    #[cfg(not(feature = "default"))]
+    fn parse_range_external(&mut self, _file: FileId) -> Option<Range<usize>> {
+        panic!("external file ranges are not expected when testing `typst_syntax`");
+    }
+
+    /// Parse a range in an external file, optionally abbreviated as just a position
+    /// if the range is empty.
+    #[cfg(feature = "default")]
+    fn parse_range_external(&mut self, file: FileId) -> Option<Range<usize>> {
+        use typst::foundations::Bytes;
+
+        use crate::world::{read, system_path};
+
+        let path = match system_path(file) {
+            Ok(path) => path,
+            Err(err) => {
+                self.error(err.to_string());
+                return None;
+            }
+        };
+
+        let bytes = match read(&path) {
+            Ok(data) => Bytes::new(data),
+            Err(err) => {
+                self.error(err.to_string());
+                return None;
+            }
+        };
+
+        let start = self.parse_line_col()?;
+        let lines = Lines::try_from(&bytes).expect(
+            "errors shouldn't be annotated for files \
+            that aren't human readable (not valid utf-8)",
+        );
+        let range = if self.s.eat_if('-') {
+            let (line, col) = start;
+            let start = lines.line_column_to_byte(line, col);
+            let (line, col) = self.parse_line_col()?;
+            let end = lines.line_column_to_byte(line, col);
+            Option::zip(start, end).map(|(a, b)| a..b)
+        } else {
+            let (line, col) = start;
+            lines.line_column_to_byte(line, col).map(|i| i..i)
+        };
+        if range.is_none() {
+            self.error("range is out of bounds");
+        }
+        range
+    }
+
+    /// Parses absolute `line:column` indices in an external file.
+    fn parse_line_col(&mut self) -> Option<(usize, usize)> {
+        let line = self.parse_number()?;
+        if !self.s.eat_if(':') {
+            self.error("positions in external files always require both `<line>:<col>`");
+            return None;
+        }
+        let col = self.parse_number()?;
+        if line < 0 || col < 0 {
+            self.error("line and column numbers must be positive");
+            return None;
+        }
+
+        Some(((line as usize).saturating_sub(1), (col as usize).saturating_sub(1)))
+    }
+
     /// Parse a range, optionally abbreviated as just a position if the range
     /// is empty.
     fn parse_range(&mut self, source: &Source) -> Option<Range<usize>> {
@@ -388,13 +479,13 @@ impl<'a> Parser<'a> {
         let line_idx = (line_idx_in_test + comments).checked_add_signed(line_delta)?;
         let column_idx = if column < 0 {
             // Negative column index is from the back.
-            let range = source.line_to_range(line_idx)?;
+            let range = source.lines().line_to_range(line_idx)?;
             text[range].chars().count().saturating_add_signed(column)
         } else {
             usize::try_from(column).ok()?.checked_sub(1)?
         };
 
-        source.line_column_to_byte(line_idx, column_idx)
+        source.lines().line_column_to_byte(line_idx, column_idx)
     }
 
     /// Parse a number.
diff --git a/tests/src/run.rs b/tests/src/run.rs
index 4d08362cf..76ce1299f 100644
--- a/tests/src/run.rs
+++ b/tests/src/run.rs
@@ -10,10 +10,11 @@ use typst::layout::{Abs, Frame, FrameItem, PagedDocument, Transform};
 use typst::visualize::Color;
 use typst::{Document, WorldExt};
 use typst_pdf::PdfOptions;
+use typst_syntax::{FileId, Lines};
 
 use crate::collect::{Attr, FileSize, NoteKind, Test};
 use crate::logger::TestResult;
-use crate::world::TestWorld;
+use crate::world::{system_path, TestWorld};
 
 /// Runs a single test.
 ///
@@ -117,7 +118,7 @@ impl<'a> Runner<'a> {
             if seen {
                 continue;
             }
-            let note_range = self.format_range(&note.range);
+            let note_range = self.format_range(note.file, &note.range);
             if first {
                 log!(self, "not emitted");
                 first = false;
@@ -208,10 +209,6 @@ impl<'a> Runner<'a> {
     /// Compare a subset of notes with a given kind against diagnostics of
     /// that same kind.
     fn check_diagnostic(&mut self, kind: NoteKind, diag: &SourceDiagnostic) {
-        // Ignore diagnostics from other sources than the test file itself.
-        if diag.span.id().is_some_and(|id| id != self.test.source.id()) {
-            return;
-        }
         // TODO: remove this once HTML export is stable
         if diag.message == "html export is under active development and incomplete" {
             return;
@@ -219,11 +216,11 @@ impl<'a> Runner<'a> {
 
         let message = diag.message.replace("\\", "/");
         let range = self.world.range(diag.span);
-        self.validate_note(kind, range.clone(), &message);
+        self.validate_note(kind, diag.span.id(), range.clone(), &message);
 
         // Check hints.
         for hint in &diag.hints {
-            self.validate_note(NoteKind::Hint, range.clone(), hint);
+            self.validate_note(NoteKind::Hint, diag.span.id(), range.clone(), hint);
         }
     }
 
@@ -235,15 +232,18 @@ impl<'a> Runner<'a> {
     fn validate_note(
         &mut self,
         kind: NoteKind,
+        file: Option<FileId>,
         range: Option<Range<usize>>,
         message: &str,
     ) {
         // Try to find perfect match.
+        let file = file.unwrap_or(self.test.source.id());
         if let Some((i, _)) = self.test.notes.iter().enumerate().find(|&(i, note)| {
             !self.seen[i]
                 && note.kind == kind
                 && note.range == range
                 && note.message == message
+                && note.file == file
         }) {
             self.seen[i] = true;
             return;
@@ -257,7 +257,7 @@ impl<'a> Runner<'a> {
                 && (note.range == range || note.message == message)
         }) else {
             // Not even a close match, diagnostic is not annotated.
-            let diag_range = self.format_range(&range);
+            let diag_range = self.format_range(file, &range);
             log!(into: self.not_annotated, "  {kind}: {diag_range} {}", message);
             return;
         };
@@ -267,10 +267,10 @@ impl<'a> Runner<'a> {
 
         // Range is wrong.
         if range != note.range {
-            let note_range = self.format_range(&note.range);
-            let note_text = self.text_for_range(&note.range);
-            let diag_range = self.format_range(&range);
-            let diag_text = self.text_for_range(&range);
+            let note_range = self.format_range(note.file, &note.range);
+            let note_text = self.text_for_range(note.file, &note.range);
+            let diag_range = self.format_range(file, &range);
+            let diag_text = self.text_for_range(file, &range);
             log!(self, "mismatched range ({}):", note.pos);
             log!(self, "  message   | {}", note.message);
             log!(self, "  annotated | {note_range:<9} | {note_text}");
@@ -286,39 +286,58 @@ impl<'a> Runner<'a> {
     }
 
     /// Display the text for a range.
-    fn text_for_range(&self, range: &Option<Range<usize>>) -> String {
+    fn text_for_range(&self, file: FileId, range: &Option<Range<usize>>) -> String {
         let Some(range) = range else { return "No text".into() };
         if range.is_empty() {
-            "(empty)".into()
-        } else {
-            format!("`{}`", self.test.source.text()[range.clone()].replace('\n', "\\n"))
+            return "(empty)".into();
         }
+
+        let lines = self.lookup(file);
+        lines.text()[range.clone()].replace('\n', "\\n").replace('\r', "\\r")
     }
 
     /// Display a byte range as a line:column range.
-    fn format_range(&self, range: &Option<Range<usize>>) -> String {
+    fn format_range(&self, file: FileId, range: &Option<Range<usize>>) -> String {
         let Some(range) = range else { return "No range".into() };
+
+        let mut preamble = String::new();
+        if file != self.test.source.id() {
+            preamble = format!("\"{}\" ", system_path(file).unwrap().display());
+        }
+
         if range.start == range.end {
-            self.format_pos(range.start)
+            format!("{preamble}{}", self.format_pos(file, range.start))
         } else {
-            format!("{}-{}", self.format_pos(range.start,), self.format_pos(range.end,))
+            format!(
+                "{preamble}{}-{}",
+                self.format_pos(file, range.start),
+                self.format_pos(file, range.end)
+            )
         }
     }
 
     /// Display a position as a line:column pair.
-    fn format_pos(&self, pos: usize) -> String {
-        if let (Some(line_idx), Some(column_idx)) =
-            (self.test.source.byte_to_line(pos), self.test.source.byte_to_column(pos))
-        {
-            let line = self.test.pos.line + line_idx;
-            let column = column_idx + 1;
-            if line == 1 {
-                format!("{column}")
-            } else {
-                format!("{line}:{column}")
-            }
+    fn format_pos(&self, file: FileId, pos: usize) -> String {
+        let lines = self.lookup(file);
+
+        let res = lines.byte_to_line_column(pos).map(|(line, col)| (line + 1, col + 1));
+        let Some((line, col)) = res else {
+            return "oob".into();
+        };
+
+        if line == 1 {
+            format!("{col}")
         } else {
-            "oob".into()
+            format!("{line}:{col}")
+        }
+    }
+
+    #[track_caller]
+    fn lookup(&self, file: FileId) -> Lines<String> {
+        if self.test.source.id() == file {
+            self.test.source.lines().clone()
+        } else {
+            self.world.lookup(file)
         }
     }
 }
diff --git a/tests/src/tests.rs b/tests/src/tests.rs
index 26eb63beb..0ed2fa469 100644
--- a/tests/src/tests.rs
+++ b/tests/src/tests.rs
@@ -59,7 +59,9 @@ fn main() {
 fn setup() {
     // Make all paths relative to the workspace. That's nicer for IDEs when
     // clicking on paths printed to the terminal.
-    std::env::set_current_dir("..").unwrap();
+    let workspace_dir =
+        Path::new(env!("CARGO_MANIFEST_DIR")).join(std::path::Component::ParentDir);
+    std::env::set_current_dir(workspace_dir).unwrap();
 
     // Create the storage.
     for ext in ["render", "html", "pdf", "svg"] {
diff --git a/tests/src/world.rs b/tests/src/world.rs
index 5c2678328..6fa1cf60f 100644
--- a/tests/src/world.rs
+++ b/tests/src/world.rs
@@ -20,6 +20,7 @@ use typst::text::{Font, FontBook, TextElem, TextSize};
 use typst::utils::{singleton, LazyHash};
 use typst::visualize::Color;
 use typst::{Feature, Library, World};
+use typst_syntax::Lines;
 
 /// A world that provides access to the tests environment.
 #[derive(Clone)]
@@ -67,7 +68,7 @@ impl World for TestWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        Some(self.base.fonts[index].clone())
+        self.base.fonts.get(index).cloned()
     }
 
     fn today(&self, _: Option<i64>) -> Option<Datetime> {
@@ -84,6 +85,22 @@ impl TestWorld {
         let mut map = self.base.slots.lock();
         f(map.entry(id).or_insert_with(|| FileSlot::new(id)))
     }
+
+    /// Lookup line metadata for a file by id.
+    #[track_caller]
+    pub(crate) fn lookup(&self, id: FileId) -> Lines<String> {
+        self.slot(id, |slot| {
+            if let Some(source) = slot.source.get() {
+                let source = source.as_ref().expect("file is not valid");
+                source.lines().clone()
+            } else if let Some(bytes) = slot.file.get() {
+                let bytes = bytes.as_ref().expect("file is not valid");
+                Lines::try_from(bytes).expect("file is not valid utf-8")
+            } else {
+                panic!("file id does not point to any source file");
+            }
+        })
+    }
 }
 
 /// Shared foundation of all test worlds.
@@ -149,7 +166,7 @@ impl FileSlot {
 }
 
 /// The file system path for a file ID.
-fn system_path(id: FileId) -> FileResult<PathBuf> {
+pub(crate) fn system_path(id: FileId) -> FileResult<PathBuf> {
     let root: PathBuf = match id.package() {
         Some(spec) => format!("tests/packages/{}-{}", spec.name, spec.version).into(),
         None => PathBuf::new(),
@@ -159,7 +176,7 @@ fn system_path(id: FileId) -> FileResult<PathBuf> {
 }
 
 /// Read a file.
-fn read(path: &Path) -> FileResult<Cow<'static, [u8]>> {
+pub(crate) fn read(path: &Path) -> FileResult<Cow<'static, [u8]>> {
     // Resolve asset.
     if let Ok(suffix) = path.strip_prefix("assets/") {
         return typst_dev_assets::get(&suffix.to_string_lossy())
@@ -244,7 +261,7 @@ fn lines(
     engine: &mut Engine,
     context: Tracked<Context>,
     span: Span,
-    count: usize,
+    count: u64,
     #[default(Numbering::Pattern(NumberingPattern::from_str("A").unwrap()))]
     numbering: Numbering,
 ) -> SourceResult<Value> {
diff --git a/tests/suite/foundations/array.typ b/tests/suite/foundations/array.typ
index 6228f471b..0c820d7f2 100644
--- a/tests/suite/foundations/array.typ
+++ b/tests/suite/foundations/array.typ
@@ -179,6 +179,10 @@
 #test((2,).last(), 2)
 #test((1, 2, 3).first(), 1)
 #test((1, 2, 3).last(), 3)
+#test((1, 2).first(default: 99), 1)
+#test(().first(default: 99), 99)
+#test((1, 2).last(default: 99), 2)
+#test(().last(default: 99), 99)
 
 --- array-first-empty ---
 // Error: 2-12 array is empty
@@ -355,6 +359,12 @@
 #test((2, 1, 3, 10, 5, 8, 6, -7, 2).sorted(), (-7, 1, 2, 2, 3, 5, 6, 8, 10))
 #test((2, 1, 3, -10, -5, 8, 6, -7, 2).sorted(key: x => x), (-10, -7, -5, 1, 2, 2, 3, 6, 8))
 #test((2, 1, 3, -10, -5, 8, 6, -7, 2).sorted(key: x => x * x), (1, 2, 2, 3, -5, 6, -7, 8, -10))
+#test(("I", "the", "hi", "text").sorted(by: (x, y) => x.len() < y.len()), ("I", "hi", "the", "text"))
+#test(("I", "the", "hi", "text").sorted(key: x => x.len(), by: (x, y) => y < x), ("text", "the", "hi", "I"))
+
+--- array-sorted-invalid-by-function ---
+// Error: 2-39 expected boolean from `by` function, got string
+#(1, 2, 3).sorted(by: (_, _) => "hmm")
 
 --- array-sorted-key-function-positional-1 ---
 // Error: 12-18 unexpected argument
diff --git a/tests/suite/foundations/eval.typ b/tests/suite/foundations/eval.typ
index f85146b23..85f43911c 100644
--- a/tests/suite/foundations/eval.typ
+++ b/tests/suite/foundations/eval.typ
@@ -52,3 +52,9 @@ _Tiger!_
 #eval(mode: "math", "f(a) = cases(a + b\, space space x >= 3,a + b\, space space x = 5)")
 
 $f(a) = cases(a + b\, space space x >= 3,a + b\, space space x = 5)$
+
+--- issue-6067-eval-warnings ---
+// Test that eval shows warnings from the executed code.
+// Warning: 7-11 no text within stars
+// Hint: 7-11 using multiple consecutive stars (e.g. **) has no additional effect
+#eval("**", mode: "markup")
diff --git a/tests/suite/foundations/float.typ b/tests/suite/foundations/float.typ
index a18e9f09a..0579acaaf 100644
--- a/tests/suite/foundations/float.typ
+++ b/tests/suite/foundations/float.typ
@@ -107,11 +107,11 @@
 #123.E // this is a field access, so is fine syntactically
 #0.e
 #1.E+020
-// Error: 2-10 invalid number: 123.456e
+// Error: 2-10 invalid floating point number: 123.456e
 #123.456e
-// Error: 2-11 invalid number: 123.456e+
+// Error: 2-11 invalid floating point number: 123.456e+
 #123.456e+
-// Error: 2-6 invalid number: .1E-
+// Error: 2-6 invalid floating point number: .1E-
 #.1E-
-// Error: 2-4 invalid number: 0e
+// Error: 2-4 invalid floating point number: 0e
 #0e
diff --git a/tests/suite/introspection/counter.typ b/tests/suite/introspection/counter.typ
index 2f095f2fb..b0657a2ad 100644
--- a/tests/suite/introspection/counter.typ
+++ b/tests/suite/introspection/counter.typ
@@ -164,3 +164,13 @@ B
 #context test(c.get(), (1,))
 #c.step(level: 3)
 #context test(c.get(), (1, 0, 1))
+
+--- counter-huge ---
+// Test values greater than 32-bits
+#let c = counter("c")
+#c.update(100000000001)
+#context test(c.get(), (100000000001,))
+#c.step()
+#context test(c.get(), (100000000002,))
+#c.update(n => n + 2)
+#context test(c.get(), (100000000004,))
diff --git a/tests/suite/layout/grid/colspan.typ b/tests/suite/layout/grid/colspan.typ
index 707a9456b..6e43270c3 100644
--- a/tests/suite/layout/grid/colspan.typ
+++ b/tests/suite/layout/grid/colspan.typ
@@ -140,3 +140,7 @@
   [e], [g], grid.cell(colspan: 2)[eee\ e\ e\ e],
   grid.cell(colspan: 4)[eeee e e e]
 )
+
+--- issue-6399-grid-cell-colspan-set-rule ---
+#set grid.cell(colspan: 2)
+#grid(columns: 3, [hehe])
diff --git a/tests/suite/layout/grid/footers.typ b/tests/suite/layout/grid/footers.typ
index edbb36fb1..c0b03f50a 100644
--- a/tests/suite/layout/grid/footers.typ
+++ b/tests/suite/layout/grid/footers.typ
@@ -83,12 +83,55 @@
   grid.cell(y: 1)[c],
 )
 
---- grid-footer-expand ---
-// Ensure footer properly expands
+--- grid-footer-cell-with-x ---
+#grid(
+  columns: 2,
+  stroke: black,
+  inset: 5pt,
+  grid.cell(x: 1)[a],
+  // Error: 3-56 footer must end at the last row
+  grid.footer(grid.cell(x: 0)[b1], grid.cell(x: 0)[b2]),
+  // This should skip the footer
+  grid.cell(x: 1)[c]
+)
+
+--- grid-footer-no-expand-with-col-and-row-pos-cell ---
 #grid(
   columns: 2,
   [a], [],
   [b], [],
+  fill: (_, y) => if calc.odd(y) { blue } else { red },
+  inset: 5pt,
+  grid.cell(x: 1, y: 3, rowspan: 4)[b],
+  grid.cell(y: 2, rowspan: 2)[a],
+  grid.footer(),
+  // Error: 3-27 cell would conflict with footer spanning the same position
+  // Hint: 3-27 try reducing the cell's rowspan or moving the footer
+  grid.cell(x: 1, y: 7)[d],
+)
+
+--- grid-footer-no-expand-with-row-pos-cell ---
+#grid(
+  columns: 2,
+  [a], [],
+  [b], [],
+  fill: (_, y) => if calc.odd(y) { blue } else { red },
+  inset: 5pt,
+  grid.cell(x: 1, y: 3, rowspan: 4)[b],
+  grid.cell(y: 2, rowspan: 2)[a],
+  grid.footer(),
+  // Error: 3-33 cell would conflict with footer spanning the same position
+  // Hint: 3-33 try reducing the cell's rowspan or moving the footer
+  grid.cell(y: 6, rowspan: 2)[d],
+)
+
+--- grid-footer-moved-to-bottom-of-rowspans ---
+#grid(
+  columns: 2,
+  [a], [],
+  [b], [],
+  stroke: red,
+  inset: 5pt,
   grid.cell(x: 1, y: 3, rowspan: 4)[b],
   grid.cell(y: 2, rowspan: 2)[a],
   grid.footer(),
@@ -113,13 +156,13 @@
 )
 
 --- grid-footer-overlap ---
-// Error: 4:3-4:19 footer would conflict with a cell placed before it at column 1 row 0
-// Hint: 4:3-4:19 try reducing that cell's rowspan or moving the footer
 #grid(
   columns: 2,
   grid.header(),
-  grid.footer([a]),
-  grid.cell(x: 1, y: 0, rowspan: 2)[a],
+  grid.footer(grid.cell(y: 2)[a]),
+  // Error: 3-39 cell would conflict with footer spanning the same position
+  // Hint: 3-39 try reducing the cell's rowspan or moving the footer
+  grid.cell(x: 1, y: 1, rowspan: 2)[a],
 )
 
 --- grid-footer-multiple ---
@@ -346,6 +389,29 @@
   table.footer[a][b][c]
 )
 
+--- grid-footer-repeatable-unbreakable ---
+#set page(height: 8em, width: auto)
+#table(
+  [h],
+  table.footer(
+    [a],
+    [b],
+    [c],
+  )
+)
+
+--- grid-footer-non-repeatable-unbreakable ---
+#set page(height: 8em, width: auto)
+#table(
+  [h],
+  table.footer(
+    [a],
+    [b],
+    [c],
+    repeat: false,
+  )
+)
+
 --- grid-footer-stroke-edge-cases ---
 // Test footer stroke priority edge case
 #set page(height: 10em)
@@ -374,8 +440,8 @@
     table.hline(stroke: red),
     table.vline(stroke: green),
     [b],
+    [c]
   ),
-  table.cell(x: 1, y: 3)[c]
 )
 
 --- grid-footer-hline-and-vline-2 ---
@@ -385,8 +451,8 @@
 #table(
   columns: 3,
   inset: 1.5pt,
-  table.cell(y: 0)[a],
   table.footer(
+    table.cell(y: 0)[a],
     table.hline(stroke: red),
     table.hline(y: 1, stroke: aqua),
     table.cell(y: 0)[b],
@@ -394,6 +460,38 @@
   )
 )
 
+--- grid-footer-top-hlines-with-only-row-pos-cell ---
+// Top hlines should attach to the top of the footer.
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 3,
+  inset: 2.5pt,
+  table.footer(
+    table.hline(stroke: red),
+    table.vline(stroke: blue),
+    table.cell(x: 2, y: 2)[a],
+    table.hline(stroke: 3pt),
+    table.vline(stroke: 3pt),
+  )
+)
+
+--- grid-footer-top-hlines-with-row-and-auto-pos-cell ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 3,
+  inset: 2.5pt,
+  table.footer(
+    table.hline(stroke: red),
+    table.vline(stroke: blue),
+    table.cell(x: 2, y: 2)[a],
+    [b],
+    table.hline(stroke: 3pt),
+    table.vline(stroke: 3pt),
+  )
+)
+
 --- grid-footer-below-rowspans ---
 // Footer should go below the rowspans.
 #set page(margin: 2pt)
@@ -404,3 +502,71 @@
   table.cell(rowspan: 2)[a], table.cell(rowspan: 2)[b],
   table.footer()
 )
+
+--- grid-footer-row-pos-cell-inside-conflicts-with-row-before ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 3,
+  inset: 1.5pt,
+  table.cell(y: 0)[a],
+  table.footer(
+    table.hline(stroke: red),
+    table.hline(y: 1, stroke: aqua),
+    // Error: 5-24 cell would cause footer to expand to non-empty row 0
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 0)[b],
+    [c]
+  )
+)
+
+--- grid-footer-auto-pos-cell-inside-conflicts-with-row-after ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 2,
+  inset: 1.5pt,
+  table.cell(y: 1)[a],
+  table.footer(
+    [b], [c],
+    // Error: 6-7 cell would cause footer to expand to non-empty row 1
+    // Hint: 6-7 try moving its cells to available rows
+    [d],
+  ),
+)
+
+--- grid-footer-row-pos-cell-inside-conflicts-with-row-after ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 2,
+  inset: 1.5pt,
+  table.cell(y: 2)[a],
+  table.footer(
+    [b], [c],
+    // Error: 5-24 cell would cause footer to expand to non-empty row 2
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 3)[d],
+  ),
+)
+
+--- grid-footer-conflicts-with-empty-header ---
+#table(
+  columns: 2,
+  table.header(),
+  table.footer(
+    // Error: 5-24 cell would cause footer to expand to non-empty row 0
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 0)[a]
+  ),
+)
+
+--- issue-5359-column-override-stays-inside-footer ---
+#table(
+  columns: 3,
+  [Outside],
+  table.footer(
+    [A], table.cell(x: 1)[B], [C],
+    table.cell(x: 1)[D],
+  ),
+)
diff --git a/tests/suite/layout/grid/headers.typ b/tests/suite/layout/grid/headers.typ
index cb2633765..ea222ee88 100644
--- a/tests/suite/layout/grid/headers.typ
+++ b/tests/suite/layout/grid/headers.typ
@@ -60,6 +60,16 @@
   grid.cell(y: 2)[c]
 )
 
+--- grid-header-cell-with-x ---
+#grid(
+  columns: 2,
+  stroke: black,
+  inset: 5pt,
+  grid.header(grid.cell(x: 0)[b1], grid.cell(x: 0)[b2]),
+  // This should skip the header
+  grid.cell(x: 1)[c]
+)
+
 --- grid-header-last-child ---
 // When the header is the last grid child, it shouldn't include the gutter row
 // after it, because there is none.
@@ -108,30 +118,81 @@
 )
 
 --- grid-header-not-at-first-row ---
-// Error: 3:3-3:19 header must start at the first row
-// Hint: 3:3-3:19 remove any rows before the header
 #grid(
   [a],
   grid.header([b])
 )
 
 --- grid-header-not-at-first-row-two-columns ---
-// Error: 4:3-4:19 header must start at the first row
-// Hint: 4:3-4:19 remove any rows before the header
 #grid(
   columns: 2,
   [a],
   grid.header([b])
 )
 
---- grow-header-multiple ---
-// Error: 3:3-3:19 cannot have more than one header
+--- grid-header-multiple ---
 #grid(
   grid.header([a]),
   grid.header([b]),
   [a],
 )
 
+--- grid-header-skip ---
+#grid(
+  columns: 2,
+  [x], [y],
+  grid.header([a]),
+  grid.header([b]),
+  grid.cell(x: 1)[c], [d],
+  grid.header([e]),
+  [f], grid.cell(x: 1)[g]
+)
+
+--- grid-header-too-large-non-repeating-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header(
+    [a\ ] * 5,
+    repeat: false,
+  ),
+  [b]
+)
+
+--- grid-header-too-large-repeating-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header(
+    [a\ ] * 5,
+    repeat: true,
+  ),
+  [b]
+)
+
+--- grid-header-too-large-repeating-orphan-with-footer ---
+#set page(height: 8em)
+#grid(
+  grid.header(
+    [a\ ] * 5,
+    repeat: true,
+  ),
+  [b],
+  grid.footer(
+    [c],
+    repeat: true,
+  )
+)
+
+--- grid-header-too-large-repeating-orphan-not-at-first-row ---
+#set page(height: 8em)
+#grid(
+  [b],
+  grid.header(
+    [a\ ] * 5,
+    repeat: true,
+  ),
+  [c],
+)
+
 --- table-header-in-grid ---
 // Error: 2:3-2:20 cannot use `table.header` as a grid header
 // Hint: 2:3-2:20 use `grid.header` instead
@@ -218,6 +279,51 @@
   table.cell(rowspan: 3, lines(15))
 )
 
+--- grid-header-and-rowspan-contiguous-1 ---
+// Block should occupy all space
+#set page(height: 15em)
+
+#table(
+  rows: (auto, 2.5em, 2em, auto),
+  gutter: 3pt,
+  inset: 0pt,
+  table.header(
+    [*H*],
+    [*W*]
+  ),
+  table.cell(rowspan: 3, block(height: 2.5em + 2em + 20em, width: 100%, fill: red))
+)
+
+--- grid-header-and-rowspan-contiguous-2 ---
+// Block should occupy all space
+#set page(height: 15em)
+
+#table(
+  rows: (auto, 2.5em, 10em, 5em, auto),
+  gutter: 3pt,
+  inset: 0pt,
+  table.header(
+    [*H*],
+    [*W*]
+  ),
+  table.cell(rowspan: 3, block(height: 2.5em + 2em + 20em, width: 100%, fill: red))
+)
+
+--- grid-header-and-large-auto-contiguous ---
+// Block should occupy all space
+#set page(height: 15em)
+
+#table(
+  rows: (auto, 4.5em, auto),
+  gutter: 3pt,
+  inset: 0pt,
+  table.header(
+    [*H*],
+    [*W*]
+  ),
+  block(height: 2.5em + 2em + 20em, width: 100%, fill: red)
+)
+
 --- grid-header-lack-of-space ---
 // Test lack of space for header + text.
 #set page(height: 8em)
@@ -245,6 +351,17 @@
   ..([Test], [Test], [Test]) * 20
 )
 
+--- grid-header-non-repeating-orphan-prevention ---
+#set page(height: 5em)
+#v(2em)
+#grid(
+  grid.header(repeat: false)[*Abc*],
+  [a],
+  [b],
+  [c],
+  [d]
+)
+
 --- grid-header-empty ---
 // Empty header should just be a repeated blank row
 #set page(height: 12em)
@@ -273,8 +390,7 @@
 )
 #context count.display()
 
---- grid-header-expand ---
-// Ensure header expands to fit cell placed in it after its declaration
+--- grid-header-no-expand-with-col-and-row-pos-cell ---
 #set page(height: 10em)
 #table(
   columns: 2,
@@ -282,9 +398,24 @@
     [a], [b],
     [c],
   ),
+  // Error: 3-48 cell would conflict with header spanning the same position
+  // Hint: 3-48 try moving the cell or the header
   table.cell(x: 1, y: 1, rowspan: 2, lorem(80))
 )
 
+--- grid-header-no-expand-with-row-pos-cell ---
+#set page(height: 10em)
+#table(
+  columns: 2,
+  table.header(
+    [a], [b],
+    [c],
+  ),
+  // Error: 3-42 cell would conflict with header spanning the same position
+  // Hint: 3-42 try moving the cell or the header
+  table.cell(y: 1, rowspan: 2, lorem(80))
+)
+
 --- grid-nested-with-headers ---
 // Nested table with header should repeat both headers
 #set page(height: 10em)
@@ -315,6 +446,56 @@
   [a\ b]
 )
 
+--- grid-header-not-at-the-top ---
+#set page(height: 5em)
+#v(2em)
+#grid(
+  [a],
+  [b],
+  grid.header[*Abc*],
+  [d],
+  [e],
+  [f],
+)
+
+--- grid-header-replace ---
+#set page(height: 5em)
+#v(1.5em)
+#grid(
+  grid.header[*Abc*],
+  [a],
+  [b],
+  grid.header[*Def*],
+  [d],
+  [e],
+  [f],
+)
+
+--- grid-header-replace-orphan ---
+#set page(height: 5em)
+#grid(
+  grid.header[*Abc*],
+  [a],
+  [b],
+  grid.header[*Def*],
+  [d],
+  [e],
+  [f],
+)
+
+--- grid-header-replace-doesnt-fit ---
+#set page(height: 5em)
+#v(0.8em)
+#grid(
+  grid.header[*Abc*],
+  [a],
+  [b],
+  grid.header[*Def*],
+  [d],
+  [e],
+  [f],
+)
+
 --- grid-header-stroke-edge-cases ---
 // Test header stroke priority edge case (last header row removed)
 #set page(height: 8em)
@@ -368,3 +549,79 @@
     [b]
   )
 )
+
+--- grid-header-row-pos-cell-inside-conflicts-with-row-before ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 3,
+  inset: 1.5pt,
+  table.cell(y: 0)[a],
+  table.header(
+    table.hline(stroke: red),
+    table.hline(y: 1, stroke: aqua),
+    // Error: 5-24 cell would cause header to expand to non-empty row 0
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 0)[b],
+    [c]
+  )
+)
+
+--- grid-header-row-pos-cell-inside-conflicts-with-row-before-after-first-empty-row ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 3,
+  inset: 1.5pt,
+  // Rows: Occupied, Empty, Occupied, Empty, Empty, ...
+  // Should not be able to expand header from the second Empty to the second Occupied.
+  table.cell(y: 0)[a],
+  table.cell(y: 2)[a],
+  table.header(
+    table.hline(stroke: red),
+    table.hline(y: 3, stroke: aqua),
+    // Error: 5-24 cell would cause header to expand to non-empty row 2
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 2)[b],
+  )
+)
+
+--- grid-header-auto-pos-cell-inside-conflicts-with-row-after ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 2,
+  inset: 1.5pt,
+  table.cell(y: 1)[a],
+  table.header(
+    [b], [c],
+    // Error: 6-7 cell would cause header to expand to non-empty row 1
+    // Hint: 6-7 try moving its cells to available rows
+    [d],
+  ),
+)
+
+--- grid-header-row-pos-cell-inside-conflicts-with-row-after ---
+#set page(margin: 2pt)
+#set text(6pt)
+#table(
+  columns: 2,
+  inset: 1.5pt,
+  table.cell(y: 2)[a],
+  table.header(
+    [b], [c],
+    // Error: 5-24 cell would cause header to expand to non-empty row 2
+    // Hint: 5-24 try moving its cells to available rows
+    table.cell(y: 3)[d],
+  ),
+)
+
+--- issue-5359-column-override-stays-inside-header ---
+#table(
+  columns: 3,
+  [Outside],
+  table.header(
+    [A], table.cell(x: 1)[B], [C],
+    table.cell(x: 1)[D],
+  ),
+)
diff --git a/tests/suite/layout/grid/html.typ b/tests/suite/layout/grid/html.typ
index 10345cb06..cf98d4bc5 100644
--- a/tests/suite/layout/grid/html.typ
+++ b/tests/suite/layout/grid/html.typ
@@ -57,3 +57,78 @@
   [d], [e], [f],
   [g], [h], [i]
 )
+
+--- multi-header-table html ---
+#table(
+  columns: 2,
+
+  table.header(
+    [First], [Header]
+  ),
+  table.header(
+    [Second], [Header]
+  ),
+  table.header(
+    [Level 2], [Header],
+    level: 2,
+  ),
+  table.header(
+    [Level 3], [Header],
+    level: 3,
+  ),
+
+  [Body], [Cells],
+  [Yet], [More],
+
+  table.footer(
+    [Footer], [Row],
+    [Ending], [Table],
+  ),
+)
+
+--- multi-header-inside-table html ---
+#table(
+  columns: 2,
+
+  table.header(
+    [First], [Header]
+  ),
+  table.header(
+    [Second], [Header]
+  ),
+  table.header(
+    [Level 2], [Header],
+    level: 2,
+  ),
+  table.header(
+    [Level 3], [Header],
+    level: 3,
+  ),
+
+  [Body], [Cells],
+  [Yet], [More],
+
+  table.header(
+    [Level 2], [Header Inside],
+    level: 2,
+  ),
+  table.header(
+    [Level 3],
+    level: 3,
+  ),
+
+  [Even], [More],
+  [Body], [Cells],
+
+  table.header(
+    [One Last Header],
+    [For Good Measure],
+    repeat: false,
+    level: 4,
+  ),
+
+  table.footer(
+    [Footer], [Row],
+    [Ending], [Table],
+  ),
+)
diff --git a/tests/suite/layout/grid/rowspan.typ b/tests/suite/layout/grid/rowspan.typ
index 88aa34c65..5fc28b9be 100644
--- a/tests/suite/layout/grid/rowspan.typ
+++ b/tests/suite/layout/grid/rowspan.typ
@@ -488,3 +488,7 @@
   table.cell(rowspan: 15, align: horizon, lets-repeat((rotate(-90deg, reflow: true)[*All Tests*]), 3)),
   ..([123], [456], [789]) * 15
 )
+
+--- issue-6399-grid-cell-rowspan-set-rule ---
+#set grid.cell(rowspan: 2)
+#grid(columns: 2, [hehe])
diff --git a/tests/suite/layout/grid/rtl.typ b/tests/suite/layout/grid/rtl.typ
index 7c0e999a2..e79b465ab 100644
--- a/tests/suite/layout/grid/rtl.typ
+++ b/tests/suite/layout/grid/rtl.typ
@@ -193,3 +193,143 @@
   ),
   ..range(0, 10).map(i => ([\##i], table.cell(stroke: green)[123], table.cell(stroke: blue)[456], [789], [?], table.hline(start: 4, end: 5, stroke: red))).flatten()
 )
+
+--- grid-rtl-counter ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  [
+    a: // should produce 1
+    #test.step()
+    #context test.get().first()
+  ],
+  [
+    b: // should produce 2
+    #test.step()
+    #context test.get().first()
+  ],
+)
+
+--- grid-rtl-rowspan-counter-equal ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  grid.cell(rowspan: 2, [
+    a: // should produce 1
+    #test.step()
+    #context test.get().first()
+  ]),
+  grid.cell(rowspan: 2, [
+    b: // should produce 2
+    #test.step()
+    #context test.get().first()
+  ]),
+)
+
+--- grid-rtl-rowspan-counter-unequal-1 ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  grid.cell(rowspan: 5, [
+    b: // will produce 2
+    #test.step()
+    #context test.get().first()
+  ]),
+  grid.cell(rowspan: 2, [
+    a: // will produce 1
+    #test.step()
+    #context test.get().first()
+  ]),
+  grid.cell(rowspan: 3, [
+    c: // will produce 3
+    #test.step()
+    #context test.get().first()
+  ]),
+)
+
+--- grid-rtl-rowspan-counter-unequal-2 ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  grid.cell(rowspan: 2, [
+    a: // will produce 1
+    #test.step()
+    #context test.get().first()
+  ]),
+  grid.cell(rowspan: 5, [
+    b: // will produce 2
+    #test.step()
+    #context test.get().first()
+  ]),
+  grid.cell(rowspan: 3, [
+    c: // will produce 3
+    #test.step()
+    #context test.get().first()
+  ]),
+)
+
+--- grid-rtl-rowspan-counter-mixed-1 ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  [
+    a: // will produce 1
+    #test.step()
+    #context test.get().first()
+  ],
+  grid.cell(rowspan: 2, [
+    b: // will produce 2
+    #test.step()
+    #context test.get().first()
+  ]),
+  [
+    c: // will produce 3
+    #test.step()
+    #context test.get().first()
+  ],
+)
+
+--- grid-rtl-rowspan-counter-mixed-2 ---
+// Test interaction between RTL and counters
+#set text(dir: rtl)
+#let test = counter("test")
+#grid(
+  columns: (1fr, 1fr),
+  inset: 5pt,
+  align: center,
+  grid.cell(rowspan: 2, [
+    b: // will produce 2
+    #test.step()
+    #context test.get().first()
+  ]),
+  [
+    a: // will produce 1
+    #test.step()
+    #context test.get().first()
+  ],
+  [
+    c: // will produce 3
+    #test.step()
+    #context test.get().first()
+  ]
+)
diff --git a/tests/suite/layout/grid/subheaders.typ b/tests/suite/layout/grid/subheaders.typ
new file mode 100644
index 000000000..56bed6a57
--- /dev/null
+++ b/tests/suite/layout/grid/subheaders.typ
@@ -0,0 +1,602 @@
+--- grid-subheaders-demo ---
+#set page(height: 15.2em)
+#table(
+  columns: 2,
+  align: center,
+  table.header(
+    table.cell(colspan: 2)[*Regional User Data*],
+  ),
+  table.header(
+    level: 2,
+    table.cell(colspan: 2)[*Germany*],
+    [*Username*], [*Joined*]
+  ),
+  [john123], [2024],
+  [rob8], [2025],
+  [joe1], [2025],
+  [joe2], [2025],
+  [martha], [2025],
+  [pear], [2025],
+  table.header(
+    level: 2,
+    table.cell(colspan: 2)[*United States*],
+    [*Username*], [*Joined*]
+  ),
+  [cool4], [2023],
+  [roger], [2023],
+  [bigfan55], [2022]
+)
+
+--- grid-subheaders-colorful ---
+#set page(width: auto, height: 12em)
+#let rows(n) = {
+  range(n).map(i => ([John \##i], table.cell(stroke: green)[123], table.cell(stroke: blue)[456], [789], [?], table.hline(start: 4, end: 5, stroke: red))).flatten()
+}
+#table(
+  columns: 5,
+  align: center + horizon,
+  table.header(
+    table.cell(colspan: 5)[*Cool Zone*],
+  ),
+  table.header(
+    level: 2,
+    table.cell(stroke: red)[*Name*], table.cell(stroke: aqua)[*Number*], [*Data 1*], [*Data 2*], [*Etc*],
+    table.hline(start: 2, end: 3, stroke: yellow)
+  ),
+  ..rows(2),
+  table.header(
+    level: 2,
+    table.cell(stroke: red)[*New Name*], table.cell(stroke: aqua, colspan: 4)[*Other Data*],
+    table.hline(start: 2, end: 3, stroke: yellow)
+  ),
+  ..rows(3)
+)
+
+--- grid-subheaders-basic ---
+#grid(
+  grid.header([a]),
+  grid.header(level: 2, [b]),
+  [c]
+)
+
+--- grid-subheaders-basic-non-consecutive ---
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+)
+
+--- grid-subheaders-basic-replace ---
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 2, [c]),
+  [z],
+)
+
+--- grid-subheaders-basic-with-footer ---
+#grid(
+  grid.header([a]),
+  grid.header(level: 2, [b]),
+  [c],
+  grid.footer([d])
+)
+
+--- grid-subheaders-basic-non-consecutive-with-footer ---
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.footer([f])
+)
+
+--- grid-subheaders-repeat ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  grid.header(level: 2, [b]),
+  ..([c],) * 10,
+)
+
+--- grid-subheaders-repeat-non-consecutive ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 10,
+)
+
+--- grid-subheaders-repeat-with-footer ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [m],
+  grid.header(level: 2, [b]),
+  ..([c],) * 10,
+  grid.footer([f])
+)
+
+--- grid-subheaders-repeat-gutter ---
+// Gutter below the header is also repeated
+#set page(height: 8em)
+#grid(
+  inset: (bottom: 0.5pt),
+  stroke: (bottom: 1pt),
+  gutter: (1pt, 6pt, 1pt),
+  grid.header([a]),
+  grid.header(level: 2, [b]),
+  ..([c],) * 10,
+)
+
+--- grid-subheaders-repeat-replace ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 10,
+  grid.header(level: 2, [c]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-repeat-replace-multiple-levels ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  ..([y],) * 10,
+  grid.header(level: 2, [d]),
+  ..([z],) * 6,
+)
+
+--- grid-subheaders-repeat-replace-gutter ---
+#set page(height: 8em)
+#grid(
+  gutter: 3pt,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 8,
+  grid.header(level: 2, [c]),
+  ..([z],) * 4,
+)
+
+--- grid-subheaders-repeat-replace-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 12,
+  grid.header(level: 2, [c]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-repeat-replace-double-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 11,
+  grid.header(level: 2, [c]),
+  grid.header(level: 3, [d]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-repeat-replace-gutter-orphan-at-child ---
+#set page(height: 8em)
+#grid(
+  gutter: 3pt,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 9,
+  grid.header(level: 2, [c]),
+  [z \ z],
+  ..([z],) * 3,
+)
+
+--- grid-subheaders-repeat-replace-gutter-orphan-at-gutter ---
+#set page(height: 8em)
+#grid(
+  gutter: 3pt,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 9,
+  box(height: 3pt),
+  grid.header(level: 2, [c]),
+  ..([z],) * 4,
+)
+
+--- grid-subheaders-repeat-replace-didnt-fit-once ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 10,
+  grid.header(level: 2, [c\ c\ c]),
+  ..([z],) * 4,
+)
+
+--- grid-subheaders-repeat-replace-with-footer ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  ..([y],) * 10,
+  grid.header(level: 2, [d]),
+  ..([z],) * 6,
+  grid.footer([f])
+)
+
+--- grid-subheaders-repeat-replace-with-footer-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 10,
+  grid.header(level: 2, [c]),
+  ..([z],) * 10,
+  grid.footer([f])
+)
+
+--- grid-subheaders-repeat-replace-short-lived ---
+// No orphan prevention for short-lived headers
+// (followed by replacing headers).
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  grid.header(level: 2, [b]),
+  grid.header(level: 2, [c]),
+  grid.header(level: 2, [d]),
+  grid.header(level: 2, [e]),
+  grid.header(level: 2, [f]),
+  grid.header(level: 2, [g]),
+  grid.header(level: 2, [h]),
+  grid.header(level: 2, [i]),
+  grid.header(level: 2, [j]),
+  grid.header(level: 3, [k]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-repeat-short-lived-also-replaces ---
+// Short-lived subheaders must still replace their conflicting predecessors.
+#set page(height: 8em)
+#grid(
+  // This has to go
+  grid.header(level: 3, [a]),
+  [w],
+  grid.header(level: 2, [b]),
+  grid.header(level: 2, [c]),
+  grid.header(level: 2, [d]),
+  grid.header(level: 2, [e]),
+  grid.header(level: 2, [f]),
+  grid.header(level: 2, [g]),
+  grid.header(level: 2, [h]),
+  grid.header(level: 2, [i]),
+  grid.header(level: 2, [j]),
+  grid.header(level: 3, [k]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-multi-page-row ---
+#set page(height: 8em)
+#grid(
+  columns: 2,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 3, [c]),
+  [a], [b],
+  grid.cell(
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [y],
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-non-repeat ---
+#set page(height: 8em)
+#grid(
+  grid.header(repeat: false, [a]),
+  [x],
+  grid.header(level: 2, repeat: false, [b]),
+  ..([y],) * 10,
+)
+
+--- grid-subheaders-non-repeat-replace ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  ..([y],) * 9,
+  grid.header(level: 2, repeat: false, [d]),
+  ..([z],) * 6,
+)
+
+--- grid-subheaders-non-repeating-replace-orphan ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 12,
+  grid.header(level: 2, repeat: false, [c]),
+  ..([z],) * 10,
+)
+
+--- grid-subheaders-non-repeating-replace-didnt-fit-once ---
+#set page(height: 8em)
+#grid(
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  ..([y],) * 10,
+  grid.header(level: 2, repeat: false, [c\ c\ c]),
+  ..([z],) * 4,
+)
+
+--- grid-subheaders-multi-page-rowspan ---
+#set page(height: 8em)
+#grid(
+  columns: 2,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 3, [c]),
+  [z], [z],
+  grid.cell(
+    rowspan: 5,
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [cell],
+  [cell]
+)
+
+--- grid-subheaders-multi-page-row-right-after ---
+#set page(height: 8em)
+#grid(
+  columns: 1,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  grid.cell(
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [done.],
+  [done.]
+)
+
+--- grid-subheaders-multi-page-rowspan-right-after ---
+#set page(height: 8em)
+#grid(
+  columns: 2,
+  grid.header([a]),
+  [x], [y],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  grid.cell(
+    rowspan: 5,
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [cell],
+  [cell],
+  grid.cell(x: 0)[done.],
+  grid.cell(x: 0)[done.]
+)
+
+--- grid-subheaders-multi-page-row-with-footer ---
+#set page(height: 8em)
+#grid(
+  columns: 2,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 3, [c]),
+  [a], [b],
+  grid.cell(
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [y],
+  ..([z],) * 10,
+  grid.footer([f])
+)
+
+--- grid-subheaders-multi-page-rowspan-with-footer ---
+#set page(height: 8em)
+#grid(
+  columns: 2,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 3, [c]),
+  [z], [z],
+  grid.cell(
+    rowspan: 5,
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [cell],
+  [cell],
+  grid.footer([f])
+)
+
+--- grid-subheaders-multi-page-row-right-after-with-footer ---
+#set page(height: 8em)
+#grid(
+  columns: 1,
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  grid.header(level: 3, [c]),
+  grid.cell(
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [done.],
+  [done.],
+  grid.footer([f])
+)
+
+--- grid-subheaders-multi-page-rowspan-gutter ---
+#set page(height: 9em)
+#grid(
+  columns: 2,
+  column-gutter: 4pt,
+  row-gutter: (0pt, 4pt, 8pt, 4pt),
+  inset: (bottom: 0.5pt),
+  stroke: (bottom: 1pt),
+  grid.header([a]),
+  [x],
+  grid.header(level: 2, [b]),
+  [y],
+  grid.header(level: 3, [c]),
+  [z], [z],
+  grid.cell(
+    rowspan: 5,
+    block(fill: red, width: 1.5em, height: 6.4em)
+  ),
+  [cell],
+  [cell],
+  [a\ b],
+  grid.cell(x: 0)[end],
+)
+
+--- grid-subheaders-non-repeating-header-before-multi-page-row ---
+#set page(height: 6em)
+#grid(
+  grid.header(repeat: false, [h]),
+  [row #colbreak() row]
+)
+
+
+--- grid-subheaders-short-lived-no-orphan-prevention ---
+// No orphan prevention for short-lived headers.
+#set page(height: 8em)
+#v(5em)
+#grid(
+  grid.header(level: 2, [b]),
+  grid.header(level: 2, [c]),
+  [d]
+)
+
+--- grid-subheaders-repeating-orphan-prevention ---
+#set page(height: 8em)
+#v(4.5em)
+#grid(
+  grid.header(repeat: true, level: 2, [L2]),
+  grid.header(repeat: true, level: 4, [L4]),
+  [a]
+)
+
+--- grid-subheaders-non-repeating-orphan-prevention ---
+#set page(height: 8em)
+#v(4.5em)
+#grid(
+  grid.header(repeat: false, level: 2, [L2]),
+  grid.header(repeat: false, level: 4, [L4]),
+  [a]
+)
+
+--- grid-subheaders-alone ---
+#table(
+  table.header([a]),
+  table.header(level: 2, [b]),
+)
+
+--- grid-subheaders-alone-no-orphan-prevention ---
+#set page(height: 5.3em)
+#v(2em)
+#grid(
+  grid.header([L1]),
+  grid.header(level: 2, [L2]),
+)
+
+--- grid-subheaders-alone-with-gutter-no-orphan-prevention ---
+#set page(height: 5.3em)
+#v(2em)
+#grid(
+  gutter: 3pt,
+  grid.header([L1]),
+  grid.header(level: 2, [L2]),
+)
+
+--- grid-subheaders-alone-with-footer ---
+#table(
+  table.header([a]),
+  table.header(level: 2, [b]),
+  table.footer([c])
+)
+
+--- grid-subheaders-alone-with-footer-no-orphan-prevention ---
+#set page(height: 5.3em)
+#table(
+  table.header([L1]),
+  table.header(level: 2, [L2]),
+  table.footer([a])
+)
+
+--- grid-subheaders-alone-with-gutter-and-footer-no-orphan-prevention ---
+#set page(height: 5.5em)
+#table(
+  gutter: 4pt,
+  table.header([L1]),
+  table.header(level: 2, [L2]),
+  table.footer([a])
+)
+
+--- grid-subheaders-too-large-non-repeating-orphan-before-auto ---
+#set page(height: 8em)
+#grid(
+  grid.header([1]),
+  grid.header([a\ ] * 2, level: 2, repeat: false),
+  grid.header([2], level: 3),
+  [b\ b\ b],
+)
+
+--- grid-subheaders-too-large-repeating-orphan-before-auto ---
+#set page(height: 8em)
+#grid(
+  grid.header([1]),
+  grid.header([a\ ] * 2, level: 2, repeat: true),
+  grid.header([2], level: 3),
+  rect(width: 10pt, height: 3em, fill: red),
+)
+
+--- grid-subheaders-too-large-repeating-orphan-before-relative ---
+#set page(height: 8em)
+#grid(
+  rows: (auto, auto, auto, 3em),
+  grid.header([1]),
+  grid.header([a\ ] * 2, level: 2, repeat: true),
+  grid.header([2], level: 3),
+  rect(width: 10pt, height: 3em, fill: red),
+)
+
+--- grid-subheaders-too-large-non-repeating-orphan-before-relative ---
+#set page(height: 8em)
+#grid(
+  rows: (auto, auto, auto, 3em),
+  grid.header([1]),
+  grid.header([a\ ] * 2, level: 2, repeat: false),
+  grid.header([2], level: 3),
+  rect(width: 10pt, height: 3em, fill: red),
+)
diff --git a/tests/suite/layout/inline/linebreak.typ b/tests/suite/layout/inline/linebreak.typ
index e4b04b245..86a900252 100644
--- a/tests/suite/layout/inline/linebreak.typ
+++ b/tests/suite/layout/inline/linebreak.typ
@@ -139,3 +139,11 @@ Some texts feature many longer
 words. Those are often exceedingly
 challenging to break in a visually
 pleasing way.
+
+--- issue-5489-matrix-stray-linebreak ---
+#table(
+  columns: (70pt,) * 1,
+  align: horizon + center,
+  stroke: 0.6pt,
+  [$mat(2241/2210,-71/1105;-71/1105,147/1105)$],
+)
diff --git a/tests/suite/layout/length.typ b/tests/suite/layout/length.typ
index 3409614fd..22b016947 100644
--- a/tests/suite/layout/length.typ
+++ b/tests/suite/layout/length.typ
@@ -75,11 +75,25 @@
 // Hint: 2-24 or use `length.abs.inches()` instead to ignore its em component
 #(4.5em + 6in).inches()
 
---- issue-5519-length-base ---
-// Error: 2-9 invalid base-2 prefix
-// Hint: 2-9 numbers with a unit cannot have a base prefix
+--- issue-5519-nondecimal-suffix ---
+// Error: 2-9 binary numbers cannot have a suffix
+// Hint: 2-9 try using a decimal number: 4pt
 #0b100pt
 
+--- nondecimal-suffix-edge-cases ---
+// Error: 2-7 octal numbers cannot have a suffix
+// Hint: 2-7 try using a decimal number: 50%
+#0o62%
+// Error: 2-8 hexadecimal numbers cannot have a suffix
+// Hint: 2-8 try using a decimal number: 2748%
+#0xabc%
+// Error: 2-9 invalid hexadecimal number: 0xabcem
+#0xabcem
+// Error: 2-11 binary numbers cannot have a suffix
+// Hint: 2-11 invalid number suffix: dag
+#0b0101dag
+
+
 --- number-syntax-edge-cases ---
 // Test numeric syntax edge cases with suffixes and which spans of text are
 // highlighted. Valid items are those not annotated with an error comment since
@@ -92,17 +106,23 @@
 #1.2E+0%
 #1.2e-0%
 #0.0e0deg
-#5in%
 #0.%
+// Error: 2-6 invalid number suffix: in%
+#5in%
+// Error: 2-6 invalid number suffix: %in
+#5%in
 // Error: 2-8 invalid number suffix: hello
 #1hello
 // Error: 2-7 invalid number suffix: infr
 #1infr
-// Error: 2-5 invalid number: 2E
+// Error: 2-5 invalid floating point number: 2E
+// Hint: 2-5 invalid number suffix: M
 #2EM
-// Error: 2-8 invalid number: .1E-
+// Error: 2-8 invalid floating point number: .1E-
 #.1E-fr
-// Error: 2-16 invalid number: 0.1E+
+// Error: 2-16 invalid floating point number: 0.1E+
+// Hint: 2-16 invalid number suffix: fr123e456
 #0.1E+fr123e456
-// Error: 2-11 invalid number: .1e-
+// Error: 2-11 invalid floating point number: .1e-
+// Hint: 2-11 invalid number suffix: fr123
 #.1e-fr123.456
diff --git a/tests/suite/layout/page.typ b/tests/suite/layout/page.typ
index a35f19bb3..4df9f9cac 100644
--- a/tests/suite/layout/page.typ
+++ b/tests/suite/layout/page.typ
@@ -246,6 +246,16 @@ Look, ma, no page numbers!
 #set page(header: auto, footer: auto)
 Default page numbers now.
 
+--- page-numbering-huge ---
+#set page(margin: (bottom: 20pt, rest: 0pt))
+#let filler = lines(1)
+
+// Test values greater than 32-bits
+#set page(numbering: "1/1")
+#counter(page).update(100000000001)
+#pagebreak()
+#pagebreak()
+
 --- page-marginal-style-text-set ---
 #set page(numbering: "1", margin: (bottom: 20pt))
 #set text(red)
diff --git a/tests/suite/layout/relative.typ b/tests/suite/layout/relative.typ
index 5a5908920..4b267cf4b 100644
--- a/tests/suite/layout/relative.typ
+++ b/tests/suite/layout/relative.typ
@@ -6,10 +6,11 @@
 #test((100% + 2pt - 2pt).length, 0pt)
 #test((56% + 2pt - 56%).ratio, 0%)
 
---- double-percent ---
+--- double-percent-embedded ---
 // Test for two percent signs in a row.
+// Error: 2-7 invalid number suffix: %%
 #3.1%%
 
---- double-percent-error ---
-// Error: 7-8 the character `%` is not valid in code
+--- double-percent-parens ---
+// Error: 3-8 invalid number suffix: %%
 #(3.1%%)
diff --git a/tests/suite/loading/csv.typ b/tests/suite/loading/csv.typ
index 6f57ec458..046345bec 100644
--- a/tests/suite/loading/csv.typ
+++ b/tests/suite/loading/csv.typ
@@ -18,12 +18,12 @@
 #csv("nope.csv")
 
 --- csv-invalid ---
-// Error: 6-28 failed to parse CSV (found 3 instead of 2 fields in line 3)
+// Error: "/assets/data/bad.csv" 3:1 failed to parse CSV (found 3 instead of 2 fields in line 3)
 #csv("/assets/data/bad.csv")
 
 --- csv-invalid-row-type-dict ---
 // Test error numbering with dictionary rows.
-// Error: 6-28 failed to parse CSV (found 3 instead of 2 fields in line 3)
+// Error: "/assets/data/bad.csv" 3:1 failed to parse CSV (found 3 instead of 2 fields in line 3)
 #csv("/assets/data/bad.csv", row-type: dictionary)
 
 --- csv-invalid-delimiter ---
diff --git a/tests/suite/loading/json.typ b/tests/suite/loading/json.typ
index c8df1ff6e..9e433992d 100644
--- a/tests/suite/loading/json.typ
+++ b/tests/suite/loading/json.typ
@@ -6,7 +6,7 @@
 #test(data.at(2).weight, 150)
 
 --- json-invalid ---
-// Error: 7-30 failed to parse JSON (expected value at line 3 column 14)
+// Error: "/assets/data/bad.json" 3:14 failed to parse JSON (expected value at line 3 column 14)
 #json("/assets/data/bad.json")
 
 --- json-decode-deprecated ---
diff --git a/tests/suite/loading/read.typ b/tests/suite/loading/read.typ
index b5c9c0892..57bfc1d5c 100644
--- a/tests/suite/loading/read.typ
+++ b/tests/suite/loading/read.typ
@@ -8,5 +8,5 @@
 #let data = read("/assets/text/missing.txt")
 
 --- read-invalid-utf-8 ---
-// Error: 18-40 file is not valid utf-8
+// Error: 18-40 failed to convert to string (file is not valid utf-8 in assets/text/bad.txt:1:1)
 #let data = read("/assets/text/bad.txt")
diff --git a/tests/suite/loading/toml.typ b/tests/suite/loading/toml.typ
index a4318a015..9d65da452 100644
--- a/tests/suite/loading/toml.typ
+++ b/tests/suite/loading/toml.typ
@@ -37,7 +37,7 @@
 ))
 
 --- toml-invalid ---
-// Error: 7-30 failed to parse TOML (expected `.`, `=` at line 1 column 16)
+// Error: "/assets/data/bad.toml" 1:16-2:1 failed to parse TOML (expected `.`, `=`)
 #toml("/assets/data/bad.toml")
 
 --- toml-decode-deprecated ---
diff --git a/tests/suite/loading/xml.typ b/tests/suite/loading/xml.typ
index 933f3c480..eed7db0ae 100644
--- a/tests/suite/loading/xml.typ
+++ b/tests/suite/loading/xml.typ
@@ -24,7 +24,7 @@
 ),))
 
 --- xml-invalid ---
-// Error: 6-28 failed to parse XML (found closing tag 'data' instead of 'hello' in line 3)
+// Error: "/assets/data/bad.xml" 3:0 failed to parse XML (found closing tag 'data' instead of 'hello')
 #xml("/assets/data/bad.xml")
 
 --- xml-decode-deprecated ---
diff --git a/tests/suite/loading/yaml.typ b/tests/suite/loading/yaml.typ
index a8089052c..ad171c6ef 100644
--- a/tests/suite/loading/yaml.typ
+++ b/tests/suite/loading/yaml.typ
@@ -13,7 +13,7 @@
 #test(data.at("1"), "ok")
 
 --- yaml-invalid ---
-// Error: 7-30 failed to parse YAML (did not find expected ',' or ']' at line 2 column 1, while parsing a flow sequence at line 1 column 18)
+// Error: "/assets/data/bad.yaml" 2:1 failed to parse YAML (did not find expected ',' or ']' at line 2 column 1, while parsing a flow sequence at line 1 column 18)
 #yaml("/assets/data/bad.yaml")
 
 --- yaml-decode-deprecated ---
diff --git a/tests/suite/math/accent.typ b/tests/suite/math/accent.typ
index 5be4f576f..0aef41e20 100644
--- a/tests/suite/math/accent.typ
+++ b/tests/suite/math/accent.typ
@@ -42,3 +42,53 @@ $tilde(U, size: #1.1em), x^tilde(U, size: #1.1em), sscript(tilde(U, size: #1.1em
   macron(bb(#c)), dot(cal(#c)), diaer(upright(#c)), breve(bold(#c)),
   circle(bold(upright(#c))), caron(upright(sans(#c))), arrow(bold(frak(#c)))$
 $test(i) \ test(j)$
+
+--- math-accent-dotless-disabled ---
+// Test disabling the dotless glyph variants.
+$hat(i), hat(i, dotless: #false), accent(j, tilde), accent(j, tilde, dotless: #false)$
+
+--- math-accent-dotless-set-rule ---
+#set math.accent(dotless: false)
+$ hat(i) $
+
+--- math-accent-dotless-greedy ---
+// Currently the dotless style propogates to everything in the accent's base,
+// even though it shouldn't.
+$ arrow(P_(c, i dot j) P_(1, i) j) \
+  arrow(P_(c, i dot j) P_(1, i) j, dotless: #false) $
+
+--- math-accent-flattened ---
+// Test flattened accent glyph variants.
+#show math.equation: set text(font: "STIX Two Math")
+$hat(a) hat(A)$
+$tilde(w) tilde(W)$
+$grave(i) grave(j)$
+$grave(I) grave(J)$
+
+--- math-accent-bottom ---
+// Test bottom accents.
+$accent(a, \u{20EE}), accent(T, \u{0323}), accent(xi, \u{0332}),
+  accent(f, \u{20ED}), accent(F, \u{20E8}), accent(y, \u{032E}),
+  accent(!, \u{032F}), accent(J, \u{0333}), accent(p, \u{0331})$
+
+--- math-accent-bottom-wide-base ---
+// Test wide base with bottom accents.
+$accent(x + y, \u{20EF}), accent(sum, \u{032D})$
+
+--- math-accent-bottom-subscript ---
+// Test effect of bottom accent on subscript.
+$q_x != accent(q, \u{032C})_x != accent(accent(q, \u{032C}), \u{032C})_x$
+
+--- math-accent-bottom-high-base ---
+// Test high base with bottom accents.
+$ accent(integral, \u{20EC}), accent(integral, \u{20EC})_a^b, accent(integral_a^b, \u{20EC}) $
+
+--- math-accent-bottom-sized ---
+// Test bottom accent size.
+$accent(sum, \u{0330}), accent(sum, \u{0330}, size: #50%), accent(H, \u{032D}, size: #200%)$
+
+--- math-accent-nested ---
+// Test nested top and bottom accents.
+$hat(accent(L, \u{0330})), accent(circle(p), \u{0323}),
+  macron(accent(caron(accent(A, \u{20ED})), \u{0333})) \
+  breve(accent(eta, \u{032E})) = accent(breve(eta), \u{032E})$
diff --git a/tests/suite/math/call.typ b/tests/suite/math/call.typ
index 5caacfac6..54b97ceb0 100644
--- a/tests/suite/math/call.typ
+++ b/tests/suite/math/call.typ
@@ -221,6 +221,15 @@ $
 // Hint: 4-6 or if you meant to display this as text, try placing it in quotes: `"ab"`
 $ 5ab $
 
+--- math-call-symbol ---
+$ phi(x) $
+$ phi(x, y) $
+$ phi(1,2,,3,) $
+
+--- math-call-symbol-named-argument ---
+// Error: 10-18 unexpected argument: alpha
+$ phi(x, alpha: y) $
+
 --- issue-3774-math-call-empty-2d-args ---
 $ mat(;,) $
 // Add some whitespace/trivia:
diff --git a/tests/suite/math/cases.typ b/tests/suite/math/cases.typ
index 1c7b4a6b4..306c1ae80 100644
--- a/tests/suite/math/cases.typ
+++ b/tests/suite/math/cases.typ
@@ -17,6 +17,6 @@ $ x = cases(1, 2) $
 $ cases(a, b, c) $
 
 --- math-cases-linebreaks ---
-// Currently linebreaks are equivalent to commas, though this behaviour may
-// change in the future.
+// Warning: 40-49 linebreaks are ignored in branches
+// Hint: 40-49 use commas instead to separate each line
 $ cases(a, b, c) cases(reverse: #true, a \ b \ c) $
diff --git a/tests/suite/math/delimited.typ b/tests/suite/math/delimited.typ
index 794ffd8aa..b8656151b 100644
--- a/tests/suite/math/delimited.typ
+++ b/tests/suite/math/delimited.typ
@@ -77,6 +77,14 @@ $ lr(body) quad
   lr(size: #1em, body) quad
   lr(size: #(1em+20%), body) $
 
+--- math-lr-mid-class ---
+// Test that `mid` creates a Relation, but that can be overridden.
+$ (a | b) $
+$ (a mid(|) b) $
+$ (a class("unary", |) b) $
+$ (a class("unary", mid(|)) b) $
+$ (a mid(class("unary", |)) b) $
+
 --- math-lr-unbalanced ---
 // Test unbalanced delimiters.
 $ 1/(2 (x) $
diff --git a/tests/suite/math/equation.typ b/tests/suite/math/equation.typ
index 148a49d02..189f6e6db 100644
--- a/tests/suite/math/equation.typ
+++ b/tests/suite/math/equation.typ
@@ -297,3 +297,10 @@ Looks at the @quadratic formula.
 #set page(width: 150pt)
 #set text(lang: "he")
 תהא סדרה $a_n$: $[a_n: 1, 1/2, 1/3, dots]$
+
+--- issue-6170-equation-stroke ---
+// In this bug stroke settings did not apply to math content.
+// We expect all of these to have a green stroke.
+#set text(stroke: green + 0.5pt)
+
+A $B^2$ $ grave(C)' $
diff --git a/tests/suite/math/frac.typ b/tests/suite/math/frac.typ
index 7f513930a..3bd00eab2 100644
--- a/tests/suite/math/frac.typ
+++ b/tests/suite/math/frac.typ
@@ -37,8 +37,8 @@ $ 1/2/3 = (1/2)/3 = 1/(2/3) $
 // Test precedence.
 $ a_1/b_2, 1/f(x), zeta(x)/2, "foo"[|x|]/2 \
   1.2/3.7, 2.3^3.4 \
-  🏳️‍🌈[x]/2, f [x]/2, phi [x]/2, 🏳️‍🌈 [x]/2 \
-  +[x]/2, 1(x)/2, 2[x]/2 \
+  f [x]/2, phi [x]/2 \
+  +[x]/2, 1(x)/2, 2[x]/2, 🏳️‍🌈[x]/2 \
   (a)b/2, b(a)[b]/2 \
   n!/2, 5!/2, n !/2, 1/n!, 1/5! $
 
diff --git a/tests/suite/math/mat.typ b/tests/suite/math/mat.typ
index b7d6a6871..80f190605 100644
--- a/tests/suite/math/mat.typ
+++ b/tests/suite/math/mat.typ
@@ -256,10 +256,17 @@ $ mat(delim: #(none, "["), 1, 2; 3, 4) $
 $ mat(delim: #(sym.angle.r, sym.bracket.double.r), 1, 2; 3, 4) $
 
 --- math-mat-linebreaks ---
-// Unlike cases and vectors, linebreaks are discarded in matrices. This
-// behaviour may change in the future.
+// Warning: 20-29 linebreaks are ignored in cells
+// Hint: 20-29 use commas instead to separate each line
 $ mat(a; b; c) mat(a \ b \ c) $
 
+--- math-mat-vec-cases-unity ---
+// Test that matrices, vectors, and cases are all laid out the same.
+$ mat(z_(n_p); a^2)
+  vec(z_(n_p), a^2) 
+  cases(reverse: #true, delim: \(, z_(n_p), a^2)
+  cases(delim: \(, z_(n_p), a^2) $
+
 --- issue-1617-mat-align ---
 #set page(width: auto)
 $ mat(a, b; c, d) mat(x; y) $
diff --git a/tests/suite/math/multiline.typ b/tests/suite/math/multiline.typ
index 34e66b99c..70838dd8c 100644
--- a/tests/suite/math/multiline.typ
+++ b/tests/suite/math/multiline.typ
@@ -99,6 +99,9 @@ Multiple trailing line breaks.
 #let hrule(x) = box(line(length: x))
 #hrule(90pt)$<;$\
 #hrule(95pt)$<;$\
+// We don't linebreak before a closing paren, but do before an opening paren.
+#hrule(90pt)$<($\
+#hrule(95pt)$<($
 #hrule(90pt)$<)$\
 #hrule(95pt)$<)$
 
diff --git a/tests/suite/math/syntax.typ b/tests/suite/math/syntax.typ
index 7091d908c..32b9c098c 100644
--- a/tests/suite/math/syntax.typ
+++ b/tests/suite/math/syntax.typ
@@ -28,6 +28,10 @@ $ dot \ dots \ ast \ tilde \ star $
 $floor(phi.alt.)$
 $floor(phi.alt. )$
 
+--- issue-4828-math-number-multi-char ---
+// Numbers should parse the same regardless of number of characters.
+$1/2(x)$ vs. $1/10(x)$
+
 --- math-unclosed ---
 // Error: 1-2 unclosed delimiter
 $a
diff --git a/tests/suite/math/vec.typ b/tests/suite/math/vec.typ
index 5de7eca94..e5ee409ec 100644
--- a/tests/suite/math/vec.typ
+++ b/tests/suite/math/vec.typ
@@ -51,6 +51,6 @@ $ vec(1, 2) $
 #set math.vec(delim: (none, "%"))
 
 --- math-vec-linebreaks ---
-// Currently linebreaks are equivalent to commas, though this behaviour may
-// change in the future.
+// Warning: 20-29 linebreaks are ignored in elements
+// Hint: 20-29 use commas instead to separate each line
 $ vec(a, b, c) vec(a \ b \ c) $
diff --git a/tests/suite/model/bibliography.typ b/tests/suite/model/bibliography.typ
index 6de44e240..23576c156 100644
--- a/tests/suite/model/bibliography.typ
+++ b/tests/suite/model/bibliography.typ
@@ -71,6 +71,10 @@ Now we have multiple bibliographies containing @glacier-melt @keshav2007read
 
 #bibliography("/assets/bib/works_too.bib", style: "mla")
 
+--- bibliography-style-not-suitable ---
+// Error: 2-62 CSL style "Alphanumeric" is not suitable for bibliographies
+#bibliography("/assets/bib/works.bib", style: "alphanumeric")
+
 --- issue-4618-bibliography-set-heading-level ---
 // Test that the bibliography block's heading is set to 2 by the show rule,
 // and therefore should be rendered like a level-2 heading. Notably, this
diff --git a/tests/suite/model/enum.typ b/tests/suite/model/enum.typ
index 7176b04e2..7ee4dc20c 100644
--- a/tests/suite/model/enum.typ
+++ b/tests/suite/model/enum.typ
@@ -134,6 +134,11 @@ a + 0.
 // Error: 22-28 invalid numbering pattern
 #set enum(numbering: "(())")
 
+--- enum-numbering-huge ---
+// Test values greater than 32-bits
+100000000001. A
++             B
+
 --- enum-number-align-unaffected ---
 // Alignment shouldn't affect number
 #set align(horizon)
diff --git a/tests/suite/model/list.typ b/tests/suite/model/list.typ
index 9bed930bb..796a7b069 100644
--- a/tests/suite/model/list.typ
+++ b/tests/suite/model/list.typ
@@ -304,3 +304,11 @@ World
   - C
 - = D
   E
+
+--- issue-6242-tight-list-attach-spacing ---
+// Nested tight lists should be uniformly spaced when list spacing is set.
+#set list(spacing: 1.2em)
+- A
+  - B
+  - C
+- C
diff --git a/tests/suite/model/numbering.typ b/tests/suite/model/numbering.typ
index ccd7cfc18..2d6a3d6a6 100644
--- a/tests/suite/model/numbering.typ
+++ b/tests/suite/model/numbering.typ
@@ -19,49 +19,32 @@
 // Greek.
 #t(
   pat: "α",
-  "𐆊", "αʹ", "βʹ", "γʹ", "δʹ", "εʹ", "ϛʹ", "ζʹ", "ηʹ", "θʹ", "ιʹ",
-  "ιαʹ", "ιβʹ", "ιγʹ", "ιδʹ", "ιεʹ", "ιϛʹ", "ιζʹ", "ιηʹ", "ιθʹ", "κʹ",
-  241, "σμαʹ",
-  999, "ϡϙθʹ",
+  "𐆊", "α", "β", "γ", "δ", "ε", "ϛ", "ζ", "η", "θ", "ι",
+  "ια", "ιβ", "ιγ", "ιδ", "ιε", "ιϛ", "ιζ", "ιη", "ιθ", "κ",
+  241, "σμα",
+  999, "ϡϟθ",
   1005, "͵αε",
-  1999, "͵αϡϙθ",
-  2999, "͵βϡϙθ",
+  1999, "͵αϡϟθ",
+  2999, "͵βϡϟθ",
   3000, "͵γ",
-  3398, "͵γτϙη",
+  3398, "͵γτϟη",
   4444, "͵δυμδ",
   5683, "͵εχπγ",
   9184, "͵θρπδ",
-  9999, "͵θϡϙθ",
-  20000, "αΜβʹ",
-  20001, "αΜβʹ, αʹ",
-  97554, "αΜθʹ, ͵ζφνδ",
-  99999, "αΜθʹ, ͵θϡϙθ",
-  1000000, "αΜρʹ",
-  1000001, "αΜρʹ, αʹ",
-  1999999, "αΜρϙθʹ, ͵θϡϙθ",
-  2345678, "αΜσλδʹ, ͵εχοη",
-  9999999, "αΜϡϙθʹ, ͵θϡϙθ",
-  10000000, "αΜ͵α",
-  90000001, "αΜ͵θ, αʹ",
-  100000000, "βΜαʹ",
-  1000000000, "βΜιʹ",
-  2000000000, "βΜκʹ",
-  2000000001, "βΜκʹ, αʹ",
-  2000010001, "βΜκʹ, αΜαʹ, αʹ",
-  2056839184, "βΜκʹ, αΜ͵εχπγ, ͵θρπδ",
+  9999, "͵θϡϟθ",
 )
 #t(
   pat: sym.Alpha,
-  "𐆊", "Αʹ", "Βʹ", "Γʹ", "Δʹ", "Εʹ", "Ϛʹ", "Ζʹ", "Ηʹ", "Θʹ", "Ιʹ",
-  "ΙΑʹ", "ΙΒʹ", "ΙΓʹ", "ΙΔʹ", "ΙΕʹ", "ΙϚʹ", "ΙΖʹ", "ΙΗʹ", "ΙΘʹ", "Κʹ",
-  241, "ΣΜΑʹ",
+  "𐆊", "Α", "Β", "Γ", "Δ", "Ε", "Ϛ", "Ζ", "Η", "Θ", "Ι",
+  "ΙΑ", "ΙΒ", "ΙΓ", "ΙΔ", "ΙΕ", "ΙϚ", "ΙΖ", "ΙΗ", "ΙΘ", "Κ",
+  241, "ΣΜΑ",
 )
 
 // Symbols.
 #t(pat: "*", "-", "*", "†", "‡", "§", "¶", "‖", "**")
 
 // Hebrew.
-#t(pat: "א", step: 2, 9, "ט׳", "י״א", "י״ג")
+#t(pat: "א", step: 2, 9, "ט", "יא", "יג", 15, "טו", 16, "טז")
 
 // Chinese.
 #t(pat: "一", step: 2, 9, "九", "十一", "十三", "十五", "十七", "十九")
diff --git a/tests/suite/scripting/import.typ b/tests/suite/scripting/import.typ
index 49b66ee56..382e444cc 100644
--- a/tests/suite/scripting/import.typ
+++ b/tests/suite/scripting/import.typ
@@ -334,6 +334,7 @@
 
 --- import-cyclic-in-other-file ---
 // Cyclic import in other file.
+// Error: "tests/suite/scripting/modules/cycle2.typ" 2:9-2:21 cyclic import
 #import "./modules/cycle1.typ": *
 
 This is never reached.
diff --git a/tests/suite/styling/show.typ b/tests/suite/styling/show.typ
index e8ddf5534..f3d9efd55 100644
--- a/tests/suite/styling/show.typ
+++ b/tests/suite/styling/show.typ
@@ -258,3 +258,11 @@ I am *strong*, I am _emphasized_, and I am #[special<special>].
 
 = Hello
 *strong*
+
+--- issue-5690-oom-par-box ---
+// Error: 3:6-5:1 maximum grouping depth exceeded
+#show par: box
+
+Hello
+
+World
diff --git a/tests/suite/text/font.typ b/tests/suite/text/font.typ
index 60a1cd94d..6e21dfd23 100644
--- a/tests/suite/text/font.typ
+++ b/tests/suite/text/font.typ
@@ -149,3 +149,7 @@ The number 123.
 #set text(-1pt)
 
 a
+
+--- empty-text-font-array ---
+// Error: 17-19 font fallback list must not be empty
+#set text(font: ())
diff --git a/tests/suite/text/smartquote.typ b/tests/suite/text/smartquote.typ
index 4940d11b2..6eab35076 100644
--- a/tests/suite/text/smartquote.typ
+++ b/tests/suite/text/smartquote.typ
@@ -46,6 +46,10 @@
 #set text(lang: "ru")
 "Лошадь не ест салат из огурцов" - это была первая фраза, сказанная по 'телефону'.
 
+--- smartquote-uk ---
+#set text(lang: "uk")
+"Кінь не їсть огірковий салат" — перше речення, коли-небудь вимовлене по 'телефону'.
+
 --- smartquote-it ---
 #set text(lang: "it")
 "Il cavallo non mangia insalata di cetrioli" è stata la prima frase pronunciata al 'telefono'.
@@ -99,7 +103,7 @@ He's told some books contain questionable "example text".
 
 --- smartquote-disabled-temporarily ---
 // Test changing properties within text.
-"She suddenly started speaking french: #text(lang: "fr")['Je suis une banane.']" Roman told me.
+"She suddenly started speaking french: #text(lang: "fr", region: "CH")['Je suis une banane.']" Roman told me.
 
 Some people's thought on this would be #[#set smartquote(enabled: false); "strange."]
 
diff --git a/tests/suite/visualize/image.typ b/tests/suite/visualize/image.typ
index 7ce0c8c0a..45c70c4b8 100644
--- a/tests/suite/visualize/image.typ
+++ b/tests/suite/visualize/image.typ
@@ -167,7 +167,7 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 #image("/assets/plugins/hello.wasm")
 
 --- image-bad-svg ---
-// Error: 2-33 failed to parse SVG (found closing tag 'g' instead of 'style' in line 4)
+// Error: "/assets/images/bad.svg" 4:3 failed to parse SVG (found closing tag 'g' instead of 'style')
 #image("/assets/images/bad.svg")
 
 --- image-decode-svg ---
@@ -176,7 +176,7 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 #image.decode(`<svg xmlns="http://www.w3.org/2000/svg" height="140" width="500"><ellipse cx="200" cy="80" rx="100" ry="50" style="fill:yellow;stroke:purple;stroke-width:2" /></svg>`.text, format: "svg")
 
 --- image-decode-bad-svg ---
-// Error: 2-168 failed to parse SVG (missing root node)
+// Error: 15-152 failed to parse SVG (missing root node at 1:1)
 // Warning: 8-14 `image.decode` is deprecated, directly pass bytes to `image` instead
 #image.decode(`<svg height="140" width="500"><ellipse cx="200" cy="80" rx="100" ry="50" style="fill:yellow;stroke:purple;stroke-width:2" /></svg>`.text, format: "svg")
 
@@ -243,16 +243,10 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 --- image-png-but-pixmap-format ---
 #image(
   read("/assets/images/tiger.jpg", encoding: none),
-  // Error: 11-18 expected "png", "jpg", "gif", dictionary, "svg", or auto
+  // Error: 11-18 expected "png", "jpg", "gif", "webp", dictionary, "svg", or auto
   format: "rgba8",
 )
 
---- issue-870-image-rotation ---
-// Ensure that EXIF rotation is applied.
-// https://github.com/image-rs/image/issues/1045
-// File is from https://magnushoff.com/articles/jpeg-orientation/
-#image("/assets/images/f2t.jpg", width: 10pt)
-
 --- issue-measure-image ---
 // Test that image measurement doesn't turn `inf / some-value` into 0pt.
 #context {
@@ -267,3 +261,16 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 --- issue-3733-dpi-svg ---
 #set page(width: 200pt, height: 200pt, margin: 0pt)
 #image("/assets/images/relative.svg")
+
+--- image-exif-rotation ---
+#let data = read("/assets/images/f2t.jpg", encoding: none)
+
+#let rotations = range(1, 9)
+#let rotated(v) = image(data.slice(0, 49) + bytes((v,)) + data.slice(50), width: 10pt)
+
+#set page(width: auto)
+#table(
+  columns: rotations.len(),
+  ..rotations.map(v => raw(str(v), lang: "typc")),
+  ..rotations.map(rotated)
+)