diff --git a/Cargo.lock b/Cargo.lock
index a92c0d228..f238f4f56 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2790,7 +2790,6 @@ dependencies = [
  "typst-assets",
  "typst-macros",
  "typst-timing",
- "unicode-properties",
  "unscanny",
  "xmp-writer",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index e26f058ea..098900620 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -114,7 +114,6 @@ typed-arena = "2"
 unicode-bidi = "0.3.13"
 unicode-ident = "1.0"
 unicode-math-class = "0.1"
-unicode-properties = "0.1"
 unicode-script = "0.5"
 unicode-segmentation = "1"
 unscanny = "0.1"
diff --git a/crates/typst-cli/src/compile.rs b/crates/typst-cli/src/compile.rs
index d15264255..cc85d9209 100644
--- a/crates/typst-cli/src/compile.rs
+++ b/crates/typst-cli/src/compile.rs
@@ -10,10 +10,9 @@ use parking_lot::RwLock;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use typst::diag::{bail, Severity, SourceDiagnostic, StrResult, Warned};
 use typst::foundations::{Datetime, Smart};
-use typst::layout::{Frame, PageRanges};
+use typst::layout::{Frame, Page, PageRanges};
 use typst::model::Document;
 use typst::syntax::{FileId, Source, Span};
-use typst::visualize::Color;
 use typst::WorldExt;
 
 use crate::args::{
@@ -269,7 +268,7 @@ fn export_image(
                 Output::Stdout => Output::Stdout,
             };
 
-            export_image_page(command, &page.frame, &output, fmt)?;
+            export_image_page(command, page, &output, fmt)?;
             Ok(())
         })
         .collect::<Result<Vec<()>, EcoString>>()?;
@@ -309,13 +308,13 @@ mod output_template {
 /// Export single image.
 fn export_image_page(
     command: &CompileCommand,
-    frame: &Frame,
+    page: &Page,
     output: &Output,
     fmt: ImageExportFormat,
 ) -> StrResult<()> {
     match fmt {
         ImageExportFormat::Png => {
-            let pixmap = typst_render::render(frame, command.ppi / 72.0, Color::WHITE);
+            let pixmap = typst_render::render(page, command.ppi / 72.0);
             let buf = pixmap
                 .encode_png()
                 .map_err(|err| eco_format!("failed to encode PNG file ({err})"))?;
@@ -324,7 +323,7 @@ fn export_image_page(
                 .map_err(|err| eco_format!("failed to write PNG file ({err})"))?;
         }
         ImageExportFormat::Svg => {
-            let svg = typst_svg::svg(frame);
+            let svg = typst_svg::svg(page);
             output
                 .write(svg.as_bytes())
                 .map_err(|err| eco_format!("failed to write SVG file ({err})"))?;
diff --git a/crates/typst-cli/src/download.rs b/crates/typst-cli/src/download.rs
index 38b160081..63a2e4163 100644
--- a/crates/typst-cli/src/download.rs
+++ b/crates/typst-cli/src/download.rs
@@ -8,7 +8,7 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use native_tls::{Certificate, TlsConnector};
-use once_cell::sync::Lazy;
+use once_cell::sync::OnceCell;
 use ureq::Response;
 
 use crate::terminal;
@@ -16,13 +16,22 @@ use crate::terminal;
 /// Keep track of this many download speed samples.
 const SPEED_SAMPLES: usize = 5;
 
-/// Lazily loads a custom CA certificate if present, but if there's an error
-/// loading certificate, it just uses the default configuration.
-static CERT: Lazy<Option<Certificate>> = Lazy::new(|| {
-    let path = crate::ARGS.cert.as_ref()?;
-    let pem = std::fs::read(path).ok()?;
-    Certificate::from_pem(&pem).ok()
-});
+/// Load a certificate from the file system if the `--cert` argument or
+/// `TYPST_CERT` environment variable is present. The certificate is cached for
+/// efficiency.
+///
+/// - Returns `None` if `--cert` and `TYPST_CERT` are not set.
+/// - Returns `Some(Ok(cert))` if the certificate was loaded successfully.
+/// - Returns `Some(Err(err))` if an error occurred while loading the certificate.
+fn cert() -> Option<Result<&'static Certificate, io::Error>> {
+    static CERT: OnceCell<Certificate> = OnceCell::new();
+    crate::ARGS.cert.as_ref().map(|path| {
+        CERT.get_or_try_init(|| {
+            let pem = std::fs::read(path)?;
+            Certificate::from_pem(&pem).map_err(io::Error::other)
+        })
+    })
+}
 
 /// Download binary data and display its progress.
 #[allow(clippy::result_large_err)]
@@ -49,8 +58,8 @@ pub fn download(url: &str) -> Result<ureq::Response, ureq::Error> {
     }
 
     // Apply a custom CA certificate if present.
-    if let Some(cert) = &*CERT {
-        tls.add_root_certificate(cert.clone());
+    if let Some(cert) = cert() {
+        tls.add_root_certificate(cert?.clone());
     }
 
     // Configure native TLS.
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index f6c96d001..d534f55cc 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -5,8 +5,8 @@ use ecow::{eco_format, EcoString};
 use if_chain::if_chain;
 use serde::{Deserialize, Serialize};
 use typst::foundations::{
-    fields_on, format_str, mutable_methods_on, repr, AutoValue, CastInfo, Func, Label,
-    NoneValue, Repr, Scope, StyleChain, Styles, Type, Value,
+    fields_on, format_str, repr, AutoValue, CastInfo, Func, Label, NoneValue, Repr,
+    Scope, StyleChain, Styles, Type, Value,
 };
 use typst::model::Document;
 use typst::syntax::{
@@ -396,19 +396,6 @@ fn field_access_completions(
         }
     }
 
-    for &(method, args) in mutable_methods_on(value.ty()) {
-        ctx.completions.push(Completion {
-            kind: CompletionKind::Func,
-            label: method.into(),
-            apply: Some(if args {
-                eco_format!("{method}(${{}})")
-            } else {
-                eco_format!("{method}()${{}}")
-            }),
-            detail: None,
-        })
-    }
-
     for &field in fields_on(value.ty()) {
         // Complete the field name along with its value. Notes:
         // 1. No parentheses since function fields cannot currently be called
@@ -1394,7 +1381,7 @@ mod tests {
     }
 
     #[test]
-    fn test_whitespace_in_autocomplete() {
+    fn test_autocomplete_whitespace() {
         //Check that extra space before '.' is handled correctly.
         test("#() .", 5, &[], &["insert", "remove", "len", "all"]);
         test("#{() .}", 6, &["insert", "remove", "len", "all"], &["foo"]);
@@ -1404,10 +1391,16 @@ mod tests {
     }
 
     #[test]
-    fn test_before_window_char_boundary() {
+    fn test_autocomplete_before_window_char_boundary() {
         // Check that the `before_window` doesn't slice into invalid byte
         // boundaries.
         let s = "😀😀     #text(font: \"\")";
         test(s, s.len() - 2, &[], &[]);
     }
+
+    #[test]
+    fn test_autocomplete_mutable_method() {
+        let s = "#{ let x = (1, 2, 3); x. }";
+        test(s, s.len() - 2, &["at", "push", "pop"], &[]);
+    }
 }
diff --git a/crates/typst-pdf/Cargo.toml b/crates/typst-pdf/Cargo.toml
index d2dcd5f5c..a3a693f38 100644
--- a/crates/typst-pdf/Cargo.toml
+++ b/crates/typst-pdf/Cargo.toml
@@ -29,7 +29,6 @@ pdf-writer = { workspace = true }
 subsetter = { workspace = true }
 svg2pdf = { workspace = true }
 ttf-parser = { workspace = true }
-unicode-properties = { workspace = true }
 unscanny = { workspace = true }
 xmp-writer = { workspace = true }
 
diff --git a/crates/typst-pdf/src/color_font.rs b/crates/typst-pdf/src/color_font.rs
index 201915b19..4889d9151 100644
--- a/crates/typst-pdf/src/color_font.rs
+++ b/crates/typst-pdf/src/color_font.rs
@@ -243,7 +243,7 @@ impl ColorFontMap<()> {
             let width =
                 font.advance(gid).unwrap_or(Em::new(0.0)).get() * font.units_per_em();
             let instructions =
-                content::build(&mut self.resources, &frame, Some(width as f32));
+                content::build(&mut self.resources, &frame, None, Some(width as f32));
             color_font.glyphs.push(ColorGlyph { gid, instructions });
             color_font.glyph_indices.insert(gid, index);
 
diff --git a/crates/typst-pdf/src/content.rs b/crates/typst-pdf/src/content.rs
index da9e4ed44..e88769449 100644
--- a/crates/typst-pdf/src/content.rs
+++ b/crates/typst-pdf/src/content.rs
@@ -16,7 +16,8 @@ use typst::model::Destination;
 use typst::text::{color::is_color_glyph, Font, TextItem, TextItemView};
 use typst::utils::{Deferred, Numeric, SliceExt};
 use typst::visualize::{
-    FixedStroke, Geometry, Image, LineCap, LineJoin, Paint, Path, PathItem, Shape,
+    FillRule, FixedStroke, Geometry, Image, LineCap, LineJoin, Paint, Path, PathItem,
+    Shape,
 };
 
 use crate::color_font::ColorFontMap;
@@ -36,6 +37,7 @@ use crate::{deflate_deferred, AbsExt, EmExt};
 pub fn build(
     resources: &mut Resources<()>,
     frame: &Frame,
+    fill: Option<Paint>,
     color_glyph_width: Option<f32>,
 ) -> Encoded {
     let size = frame.size();
@@ -53,6 +55,11 @@ pub fn build(
             .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);
 
@@ -630,11 +637,13 @@ fn write_shape(ctx: &mut Builder, pos: Point, shape: &Shape) {
         }
     }
 
-    match (&shape.fill, stroke) {
-        (None, None) => unreachable!(),
-        (Some(_), None) => ctx.content.fill_nonzero(),
-        (None, Some(_)) => ctx.content.stroke(),
-        (Some(_), Some(_)) => ctx.content.fill_nonzero_and_stroke(),
+    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(),
     };
 }
 
diff --git a/crates/typst-pdf/src/font.rs b/crates/typst-pdf/src/font.rs
index fd719799d..c88c2bfde 100644
--- a/crates/typst-pdf/src/font.rs
+++ b/crates/typst-pdf/src/font.rs
@@ -12,7 +12,6 @@ use subsetter::GlyphRemapper;
 use ttf_parser::{name_id, GlyphId, Tag};
 use typst::text::Font;
 use typst::utils::SliceExt;
-use unicode_properties::{GeneralCategory, UnicodeGeneralCategory};
 
 use crate::{deflate, EmExt, PdfChunk, WithGlobalRefs};
 
@@ -226,38 +225,6 @@ pub(crate) fn subset_tag<T: Hash>(glyphs: &T) -> EcoString {
     std::str::from_utf8(&letter).unwrap().into()
 }
 
-/// For glyphs that have codepoints mapping to them in the font's cmap table, we
-/// prefer them over pre-existing text mappings from the document. Only things
-/// that don't have a corresponding codepoint (or only a private-use one) like
-/// the "Th" in Linux Libertine get the text of their first occurrences in the
-/// document instead.
-///
-/// This function replaces as much copepoints from the document with ones from
-/// the cmap table as possible.
-pub fn improve_glyph_sets(glyph_sets: &mut HashMap<Font, BTreeMap<u16, EcoString>>) {
-    for (font, glyph_set) in glyph_sets {
-        let ttf = font.ttf();
-
-        for subtable in ttf.tables().cmap.into_iter().flat_map(|table| table.subtables) {
-            if !subtable.is_unicode() {
-                continue;
-            }
-
-            subtable.codepoints(|n| {
-                let Some(c) = std::char::from_u32(n) else { return };
-                if c.general_category() == GeneralCategory::PrivateUse {
-                    return;
-                }
-
-                let Some(GlyphId(g)) = ttf.glyph_index(c) else { return };
-                if glyph_set.contains_key(&g) {
-                    glyph_set.insert(g, c.into());
-                }
-            });
-        }
-    }
-}
-
 /// Create a compressed `/ToUnicode` CMap.
 #[comemo::memoize]
 #[typst_macros::time(name = "create cmap")]
diff --git a/crates/typst-pdf/src/page.rs b/crates/typst-pdf/src/page.rs
index 2983f504f..1001d8992 100644
--- a/crates/typst-pdf/src/page.rs
+++ b/crates/typst-pdf/src/page.rs
@@ -8,12 +8,12 @@ use pdf_writer::{
 };
 use typst::foundations::Label;
 use typst::introspection::Location;
-use typst::layout::{Abs, Frame};
+use typst::layout::{Abs, Page};
 use typst::model::{Destination, Numbering};
 use typst::text::Case;
 
+use crate::Resources;
 use crate::{content, AbsExt, PdfChunk, WithDocument, WithRefs, WithResources};
-use crate::{font::improve_glyph_sets, Resources};
 
 /// Construct page objects.
 #[typst_macros::time(name = "construct pages")]
@@ -33,7 +33,7 @@ pub fn traverse_pages(
             pages.push(None);
             skipped_pages += 1;
         } else {
-            let mut encoded = construct_page(&mut resources, &page.frame);
+            let mut encoded = construct_page(&mut resources, page);
             encoded.label = page
                 .numbering
                 .as_ref()
@@ -52,17 +52,13 @@ pub fn traverse_pages(
         }
     }
 
-    improve_glyph_sets(&mut resources.glyph_sets);
-    improve_glyph_sets(&mut resources.color_glyph_sets);
-
     (PdfChunk::new(), (pages, resources))
 }
 
 /// Construct a page object.
 #[typst_macros::time(name = "construct page")]
-fn construct_page(out: &mut Resources<()>, frame: &Frame) -> EncodedPage {
-    let content = content::build(out, frame, None);
-
+fn construct_page(out: &mut Resources<()>, page: &Page) -> EncodedPage {
+    let content = content::build(out, &page.frame, page.fill_or_transparent(), None);
     EncodedPage { content, label: None }
 }
 
diff --git a/crates/typst-pdf/src/pattern.rs b/crates/typst-pdf/src/pattern.rs
index e06c04f87..d4f5a6e08 100644
--- a/crates/typst-pdf/src/pattern.rs
+++ b/crates/typst-pdf/src/pattern.rs
@@ -103,7 +103,7 @@ fn register_pattern(
     };
 
     // Render the body.
-    let content = content::build(&mut patterns.resources, pattern.frame(), None);
+    let content = content::build(&mut patterns.resources, pattern.frame(), None, None);
 
     let pdf_pattern = PdfPattern {
         transform,
diff --git a/crates/typst-pdf/src/resources.rs b/crates/typst-pdf/src/resources.rs
index a2cf56878..32b6612ff 100644
--- a/crates/typst-pdf/src/resources.rs
+++ b/crates/typst-pdf/src/resources.rs
@@ -77,11 +77,16 @@ pub struct Resources<R = Ref> {
     pub languages: BTreeMap<Lang, usize>,
 
     /// For each font a mapping from used glyphs to their text representation.
-    /// May contain multiple chars in case of ligatures or similar things. The
-    /// same glyph can have a different text representation within one document,
-    /// then we just save the first one. The resulting strings are used for the
-    /// PDF's /ToUnicode map for glyphs that don't have an entry in the font's
-    /// cmap. This is important for copy-paste and searching.
+    /// 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>>,
diff --git a/crates/typst-render/src/lib.rs b/crates/typst-render/src/lib.rs
index 305dcd1fc..d5eeacce8 100644
--- a/crates/typst-render/src/lib.rs
+++ b/crates/typst-render/src/lib.rs
@@ -7,45 +7,49 @@ mod text;
 
 use tiny_skia as sk;
 use typst::layout::{
-    Abs, Axes, Frame, FrameItem, FrameKind, GroupItem, Point, Size, Transform,
+    Abs, Axes, Frame, FrameItem, FrameKind, GroupItem, Page, Point, Size, Transform,
 };
 use typst::model::Document;
-use typst::visualize::Color;
+use typst::visualize::{Color, Geometry, Paint};
 
-/// Export a frame into a raster image.
+/// Export a page into a raster image.
 ///
-/// This renders the frame at the given number of pixels per point and returns
+/// This renders the page at the given number of pixels per point and returns
 /// the resulting `tiny-skia` pixel buffer.
 #[typst_macros::time(name = "render")]
-pub fn render(frame: &Frame, pixel_per_pt: f32, fill: Color) -> sk::Pixmap {
-    let size = frame.size();
+pub fn render(page: &Page, pixel_per_pt: f32) -> sk::Pixmap {
+    let size = page.frame.size();
     let pxw = (pixel_per_pt * size.x.to_f32()).round().max(1.0) as u32;
     let pxh = (pixel_per_pt * size.y.to_f32()).round().max(1.0) as u32;
 
-    let mut canvas = sk::Pixmap::new(pxw, pxh).unwrap();
-    canvas.fill(paint::to_sk_color(fill));
-
     let ts = sk::Transform::from_scale(pixel_per_pt, pixel_per_pt);
-    render_frame(&mut canvas, State::new(size, ts, pixel_per_pt), frame);
+    let state = State::new(size, ts, pixel_per_pt);
+
+    let mut canvas = sk::Pixmap::new(pxw, pxh).unwrap();
+
+    if let Some(fill) = page.fill_or_white() {
+        if let Paint::Solid(color) = fill {
+            canvas.fill(paint::to_sk_color(color));
+        } else {
+            let rect = Geometry::Rect(page.frame.size()).filled(fill);
+            shape::render_shape(&mut canvas, state, &rect);
+        }
+    }
+
+    render_frame(&mut canvas, state, &page.frame);
 
     canvas
 }
 
 /// Export a document with potentially multiple pages into a single raster image.
-///
-/// The gap will be added between the individual frames.
 pub fn render_merged(
     document: &Document,
     pixel_per_pt: f32,
-    frame_fill: Color,
     gap: Abs,
-    gap_fill: Color,
+    fill: Option<Color>,
 ) -> sk::Pixmap {
-    let pixmaps: Vec<_> = document
-        .pages
-        .iter()
-        .map(|page| render(&page.frame, pixel_per_pt, frame_fill))
-        .collect();
+    let pixmaps: Vec<_> =
+        document.pages.iter().map(|page| render(page, pixel_per_pt)).collect();
 
     let gap = (pixel_per_pt * gap.to_f32()).round() as u32;
     let pxw = pixmaps.iter().map(sk::Pixmap::width).max().unwrap_or_default();
@@ -53,7 +57,9 @@ pub fn render_merged(
         + gap * pixmaps.len().saturating_sub(1) as u32;
 
     let mut canvas = sk::Pixmap::new(pxw, pxh).unwrap();
-    canvas.fill(paint::to_sk_color(gap_fill));
+    if let Some(fill) = fill {
+        canvas.fill(paint::to_sk_color(fill));
+    }
 
     let mut y = 0;
     for pixmap in pixmaps {
diff --git a/crates/typst-render/src/shape.rs b/crates/typst-render/src/shape.rs
index 360c2a4f8..f31262eff 100644
--- a/crates/typst-render/src/shape.rs
+++ b/crates/typst-render/src/shape.rs
@@ -1,7 +1,8 @@
 use tiny_skia as sk;
 use typst::layout::{Abs, Axes, Point, Ratio, Size};
 use typst::visualize::{
-    DashPattern, FixedStroke, Geometry, LineCap, LineJoin, Path, PathItem, Shape,
+    DashPattern, FillRule, FixedStroke, Geometry, LineCap, LineJoin, Path, PathItem,
+    Shape,
 };
 
 use crate::{paint, AbsExt, State};
@@ -51,7 +52,10 @@ pub fn render_shape(canvas: &mut sk::Pixmap, state: State, shape: &Shape) -> Opt
             paint.anti_alias = false;
         }
 
-        let rule = sk::FillRule::default();
+        let rule = match shape.fill_rule {
+            FillRule::NonZero => sk::FillRule::Winding,
+            FillRule::EvenOdd => sk::FillRule::EvenOdd,
+        };
         canvas.fill_path(&path, &paint, rule, ts, state.mask);
     }
 
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index 01ed3faee..145e23f86 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -11,11 +11,11 @@ use std::fmt::{self, Display, Formatter, Write};
 use ecow::EcoString;
 use ttf_parser::OutlineBuilder;
 use typst::layout::{
-    Abs, Frame, FrameItem, FrameKind, GroupItem, Point, Ratio, Size, Transform,
+    Abs, Frame, FrameItem, FrameKind, GroupItem, Page, Point, Ratio, Size, Transform,
 };
 use typst::model::Document;
 use typst::utils::hash128;
-use typst::visualize::{Gradient, Pattern};
+use typst::visualize::{Geometry, Gradient, Pattern};
 use xmlwriter::XmlWriter;
 
 use crate::paint::{GradientRef, PatternRef, SVGSubGradient};
@@ -23,12 +23,12 @@ use crate::text::RenderedGlyph;
 
 /// Export a frame into a SVG file.
 #[typst_macros::time(name = "svg")]
-pub fn svg(frame: &Frame) -> String {
+pub fn svg(page: &Page) -> String {
     let mut renderer = SVGRenderer::new();
-    renderer.write_header(frame.size());
+    renderer.write_header(page.frame.size());
 
-    let state = State::new(frame.size(), Transform::identity());
-    renderer.render_frame(state, Transform::identity(), frame);
+    let state = State::new(page.frame.size(), Transform::identity());
+    renderer.render_page(state, Transform::identity(), page);
     renderer.finalize()
 }
 
@@ -57,7 +57,7 @@ pub fn svg_merged(document: &Document, padding: Abs) -> String {
     for page in &document.pages {
         let ts = Transform::translate(x, y);
         let state = State::new(page.frame.size(), Transform::identity());
-        renderer.render_frame(state, ts, &page.frame);
+        renderer.render_page(state, ts, page);
         y += page.frame.height() + padding;
     }
 
@@ -176,6 +176,16 @@ impl SVGRenderer {
         self.xml.write_attribute("xmlns:h5", "http://www.w3.org/1999/xhtml");
     }
 
+    /// Render a page with the given transform.
+    fn render_page(&mut self, state: State, ts: Transform, page: &Page) {
+        if let Some(fill) = page.fill_or_white() {
+            let shape = Geometry::Rect(page.frame.size()).filled(fill);
+            self.render_shape(state, &shape);
+        }
+
+        self.render_frame(state, ts, &page.frame);
+    }
+
     /// Render a frame with the given transform.
     fn render_frame(&mut self, state: State, ts: Transform, frame: &Frame) {
         self.xml.start_element("g");
diff --git a/crates/typst-svg/src/paint.rs b/crates/typst-svg/src/paint.rs
index a382bd9d0..364cdd234 100644
--- a/crates/typst-svg/src/paint.rs
+++ b/crates/typst-svg/src/paint.rs
@@ -5,7 +5,7 @@ use ttf_parser::OutlineBuilder;
 use typst::foundations::Repr;
 use typst::layout::{Angle, Axes, Frame, Quadrant, Ratio, Size, Transform};
 use typst::utils::hash128;
-use typst::visualize::{Color, Gradient, Paint, Pattern, RatioOrAngle};
+use typst::visualize::{Color, FillRule, Gradient, Paint, Pattern, RatioOrAngle};
 use xmlwriter::XmlWriter;
 
 use crate::{Id, SVGRenderer, State, SvgMatrix, SvgPathBuilder};
@@ -31,7 +31,13 @@ impl SVGRenderer {
     }
 
     /// Write a fill attribute.
-    pub(super) fn write_fill(&mut self, fill: &Paint, size: Size, ts: Transform) {
+    pub(super) fn write_fill(
+        &mut self,
+        fill: &Paint,
+        fill_rule: FillRule,
+        size: Size,
+        ts: Transform,
+    ) {
         match fill {
             Paint::Solid(color) => self.xml.write_attribute("fill", &color.encode()),
             Paint::Gradient(gradient) => {
@@ -43,6 +49,10 @@ impl SVGRenderer {
                 self.xml.write_attribute_fmt("fill", format_args!("url(#{id})"));
             }
         }
+        match fill_rule {
+            FillRule::NonZero => self.xml.write_attribute("fill-rule", "nonzero"),
+            FillRule::EvenOdd => self.xml.write_attribute("fill-rule", "evenodd"),
+        }
     }
 
     /// Pushes a gradient to the list of gradients to write SVG file.
diff --git a/crates/typst-svg/src/shape.rs b/crates/typst-svg/src/shape.rs
index 4caae2fdc..12be2e22d 100644
--- a/crates/typst-svg/src/shape.rs
+++ b/crates/typst-svg/src/shape.rs
@@ -17,6 +17,7 @@ impl SVGRenderer {
         if let Some(paint) = &shape.fill {
             self.write_fill(
                 paint,
+                shape.fill_rule,
                 self.shape_fill_size(state, paint, shape),
                 self.shape_paint_transform(state, paint, shape),
             );
diff --git a/crates/typst-svg/src/text.rs b/crates/typst-svg/src/text.rs
index 04b75123b..6af933988 100644
--- a/crates/typst-svg/src/text.rs
+++ b/crates/typst-svg/src/text.rs
@@ -6,7 +6,7 @@ use ttf_parser::GlyphId;
 use typst::layout::{Abs, Point, Ratio, Size, Transform};
 use typst::text::{Font, TextItem};
 use typst::utils::hash128;
-use typst::visualize::{Image, Paint, RasterFormat, RelativeTo};
+use typst::visualize::{FillRule, Image, Paint, RasterFormat, RelativeTo};
 
 use crate::{SVGRenderer, State, SvgMatrix, SvgPathBuilder};
 
@@ -138,6 +138,7 @@ impl SVGRenderer {
         self.xml.write_attribute_fmt("x", format_args!("{x_offset}"));
         self.write_fill(
             &text.fill,
+            FillRule::default(),
             Size::new(Abs::pt(width), Abs::pt(height)),
             self.text_paint_transform(state, &text.fill),
         );
diff --git a/crates/typst/src/foundations/func.rs b/crates/typst/src/foundations/func.rs
index dc5ea8dfc..4cc4a6bab 100644
--- a/crates/typst/src/foundations/func.rs
+++ b/crates/typst/src/foundations/func.rs
@@ -81,6 +81,10 @@ pub use typst_macros::func;
 /// body evaluates to the result of joining all expressions preceding the
 /// `return`.
 ///
+/// Functions that don't return any meaningful value return [`none`] instead.
+/// The return type of such functions is not explicitly specified in the
+/// documentation. (An example of this is [`array.push`]).
+///
 /// ```example
 /// #let alert(body, fill: red) = {
 ///   set text(white)
diff --git a/crates/typst/src/foundations/int.rs b/crates/typst/src/foundations/int.rs
index 40f896188..eb9246494 100644
--- a/crates/typst/src/foundations/int.rs
+++ b/crates/typst/src/foundations/int.rs
@@ -3,7 +3,9 @@ use std::num::{NonZeroI64, NonZeroIsize, NonZeroU64, NonZeroUsize, ParseIntError
 use ecow::{eco_format, EcoString};
 
 use crate::diag::StrResult;
-use crate::foundations::{cast, func, repr, scope, ty, Repr, Str, Value};
+use crate::foundations::{
+    bail, cast, func, repr, scope, ty, Bytes, Cast, Repr, Str, Value,
+};
 
 /// A whole number.
 ///
@@ -145,7 +147,6 @@ impl i64 {
     #[func(title = "Bitwise Left Shift")]
     pub fn bit_lshift(
         self,
-
         /// The amount of bits to shift. Must not be negative.
         shift: u32,
     ) -> StrResult<i64> {
@@ -168,7 +169,6 @@ impl i64 {
     #[func(title = "Bitwise Right Shift")]
     pub fn bit_rshift(
         self,
-
         /// The amount of bits to shift. Must not be negative.
         ///
         /// Shifts larger than 63 are allowed and will cause the return value to
@@ -178,7 +178,6 @@ impl i64 {
         /// just applying this operation multiple times. Therefore, the shift will
         /// always succeed.
         shift: u32,
-
         /// Toggles whether a logical (unsigned) right shift should be performed
         /// instead of arithmetic right shift.
         /// If this is `true`, negative operands will not preserve their sign bit,
@@ -214,6 +213,126 @@ impl i64 {
             self >> shift
         }
     }
+
+    /// Converts bytes to an integer.
+    ///
+    /// ```example
+    /// #int.from-bytes(bytes((0, 0, 0, 0, 0, 0, 0, 1))) \
+    /// #int.from-bytes(bytes((1, 0, 0, 0, 0, 0, 0, 0)), endian: "big")
+    /// ```
+    #[func]
+    pub fn from_bytes(
+        /// The bytes that should be converted to an integer.
+        ///
+        /// Must be of length at most 8 so that the result fits into a 64-bit
+        /// signed integer.
+        bytes: Bytes,
+        /// The endianness of the conversion.
+        #[named]
+        #[default(Endianness::Little)]
+        endian: Endianness,
+        /// Whether the bytes should be treated as a signed integer. If this is
+        /// `{true}` and the most significant bit is set, the resulting number
+        /// will negative.
+        #[named]
+        #[default(true)]
+        signed: bool,
+    ) -> StrResult<i64> {
+        let len = bytes.len();
+        if len == 0 {
+            return Ok(0);
+        } else if len > 8 {
+            bail!("too many bytes to convert to a 64 bit number");
+        }
+
+        // `decimal` will hold the part of the buffer that should be filled with
+        // the input bytes, `rest` will remain as is or be filled with 0xFF for
+        // negative numbers if signed is true.
+        //
+        // – big-endian: `decimal` will be the rightmost bytes of the buffer.
+        // - little-endian: `decimal` will be the leftmost bytes of the buffer.
+        let mut buf = [0u8; 8];
+        let (rest, decimal) = match endian {
+            Endianness::Big => buf.split_at_mut(8 - len),
+            Endianness::Little => {
+                let (first, second) = buf.split_at_mut(len);
+                (second, first)
+            }
+        };
+
+        decimal.copy_from_slice(bytes.as_ref());
+
+        // Perform sign-extension if necessary.
+        if signed {
+            let most_significant_byte = match endian {
+                Endianness::Big => decimal[0],
+                Endianness::Little => decimal[len - 1],
+            };
+
+            if most_significant_byte & 0b1000_0000 != 0 {
+                rest.fill(0xFF);
+            }
+        }
+
+        Ok(match endian {
+            Endianness::Big => i64::from_be_bytes(buf),
+            Endianness::Little => i64::from_le_bytes(buf),
+        })
+    }
+
+    /// Converts an integer to bytes.
+    ///
+    /// ```example
+    /// #array(10000.to-bytes(endian: "big")) \
+    /// #array(10000.to-bytes(size: 4))
+    /// ```
+    #[func]
+    pub fn to_bytes(
+        self,
+        /// The endianness of the conversion.
+        #[named]
+        #[default(Endianness::Little)]
+        endian: Endianness,
+        /// The size in bytes of the resulting bytes (must be at least zero). If
+        /// the integer is too large to fit in the specified size, the
+        /// conversion will truncate the remaining bytes based on the
+        /// endianness. To keep the same resulting value, if the endianness is
+        /// big-endian, the truncation will happen at the rightmost bytes.
+        /// Otherwise, if the endianness is little-endian, the truncation will
+        /// happen at the leftmost bytes.
+        ///
+        /// Be aware that if the integer is negative and the size is not enough
+        /// to make the number fit, when passing the resulting bytes to
+        /// `int.from-bytes`, the resulting number might be positive, as the
+        /// most significant bit might not be set to 1.
+        #[named]
+        #[default(8)]
+        size: usize,
+    ) -> Bytes {
+        let array = match endian {
+            Endianness::Big => self.to_be_bytes(),
+            Endianness::Little => self.to_le_bytes(),
+        };
+
+        let mut buf = vec![0u8; size];
+        match endian {
+            Endianness::Big => {
+                // Copy the bytes from the array to the buffer, starting from
+                // the end of the buffer.
+                let buf_start = size.saturating_sub(8);
+                let array_start = 8usize.saturating_sub(size);
+                buf[buf_start..].copy_from_slice(&array[array_start..])
+            }
+            Endianness::Little => {
+                // Copy the bytes from the array to the buffer, starting from
+                // the beginning of the buffer.
+                let end = size.min(8);
+                buf[..end].copy_from_slice(&array[..end])
+            }
+        }
+
+        Bytes::from(buf)
+    }
 }
 
 impl Repr for i64 {
@@ -222,6 +341,15 @@ impl Repr for i64 {
     }
 }
 
+/// Represents the byte order used for converting integers to bytes and vice versa.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
+pub enum Endianness {
+    /// Big-endian byte order: the highest-value byte is at the beginning of the bytes.
+    Big,
+    /// Little-endian byte order: the lowest-value byte is at the beginning of the bytes.
+    Little,
+}
+
 /// A value that can be cast to an integer.
 pub struct ToInt(i64);
 
diff --git a/crates/typst/src/foundations/methods.rs b/crates/typst/src/foundations/methods.rs
index 287a49c69..945b7c507 100644
--- a/crates/typst/src/foundations/methods.rs
+++ b/crates/typst/src/foundations/methods.rs
@@ -1,28 +1,9 @@
 //! Handles special built-in methods on values.
 
 use crate::diag::{At, SourceResult};
-use crate::foundations::{Args, Array, Dict, Str, Type, Value};
+use crate::foundations::{Args, Str, Type, Value};
 use crate::syntax::Span;
 
-/// List the available methods for a type and whether they take arguments.
-pub fn mutable_methods_on(ty: Type) -> &'static [(&'static str, bool)] {
-    if ty == Type::of::<Array>() {
-        &[
-            ("first", false),
-            ("last", false),
-            ("at", true),
-            ("pop", false),
-            ("push", true),
-            ("insert", true),
-            ("remove", true),
-        ]
-    } else if ty == Type::of::<Dict>() {
-        &[("at", true), ("insert", true), ("remove", true)]
-    } else {
-        &[]
-    }
-}
-
 /// Whether a specific method is mutating.
 pub(crate) fn is_mutating_method(method: &str) -> bool {
     matches!(method, "push" | "pop" | "insert" | "remove")
diff --git a/crates/typst/src/foundations/mod.rs b/crates/typst/src/foundations/mod.rs
index b7783dda9..f9dfff4f5 100644
--- a/crates/typst/src/foundations/mod.rs
+++ b/crates/typst/src/foundations/mod.rs
@@ -49,7 +49,7 @@ pub use self::float::*;
 pub use self::func::*;
 pub use self::int::*;
 pub use self::label::*;
-pub use self::methods::*;
+pub(crate) use self::methods::*;
 pub use self::module::*;
 pub use self::none::*;
 pub use self::plugin::*;
diff --git a/crates/typst/src/foundations/styles.rs b/crates/typst/src/foundations/styles.rs
index 42be89229..48009c8c3 100644
--- a/crates/typst/src/foundations/styles.rs
+++ b/crates/typst/src/foundations/styles.rs
@@ -7,7 +7,7 @@ use comemo::{Track, Tracked};
 use ecow::{eco_vec, EcoString, EcoVec};
 use smallvec::SmallVec;
 
-use crate::diag::{SourceResult, Trace, Tracepoint};
+use crate::diag::{warning, SourceResult, Trace, Tracepoint};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, ty, Content, Context, Element, Func, NativeElement, Packed, Repr,
@@ -33,6 +33,8 @@ use crate::utils::LazyHash;
 /// ```
 #[func]
 pub fn style(
+    /// The engine.
+    engine: &mut Engine,
     /// The call site span.
     span: Span,
     /// A function to call with the styles. Its return value is displayed
@@ -43,6 +45,11 @@ pub fn style(
     /// content that depends on the style context it appears in.
     func: Func,
 ) -> Content {
+    engine.sink.warn(warning!(
+        span, "`style` is deprecated";
+        hint: "use a `context` expression instead"
+    ));
+
     StyleElem::new(func).pack().spanned(span)
 }
 
diff --git a/crates/typst/src/introspection/counter.rs b/crates/typst/src/introspection/counter.rs
index 13ea4d142..2aefb68ec 100644
--- a/crates/typst/src/introspection/counter.rs
+++ b/crates/typst/src/introspection/counter.rs
@@ -5,7 +5,7 @@ use comemo::{Track, Tracked, TrackedMut};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
 use smallvec::{smallvec, SmallVec};
 
-use crate::diag::{bail, At, HintedStrResult, SourceResult};
+use crate::diag::{bail, warning, At, HintedStrResult, SourceResult};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Args, Array, Construct, Content, Context,
@@ -464,6 +464,11 @@ impl Counter {
         if let Ok(loc) = context.location() {
             self.display_impl(engine, loc, numbering, both, context.styles().ok())
         } else {
+            engine.sink.warn(warning!(
+                span, "`counter.display` without context is deprecated";
+                hint: "use it in a `context` expression instead"
+            ));
+
             Ok(CounterDisplayElem::new(self, numbering, both)
                 .pack()
                 .spanned(span)
@@ -508,13 +513,19 @@ impl Counter {
         context: Tracked<Context>,
         /// The callsite span.
         span: Span,
-        /// _Compatibility:_ This argument only exists for compatibility with
-        /// Typst 0.10 and lower and shouldn't be used anymore.
+        /// _Compatibility:_ This argument is deprecated. It only exists for
+        /// compatibility with Typst 0.10 and lower and shouldn't be used
+        /// anymore.
         #[default]
         location: Option<Location>,
     ) -> SourceResult<CounterState> {
         if location.is_none() {
             context.location().at(span)?;
+        } else {
+            engine.sink.warn(warning!(
+                span, "calling `counter.final` with a location is deprecated";
+                hint: "try removing the location argument"
+            ));
         }
 
         let sequence = self.sequence(engine)?;
diff --git a/crates/typst/src/introspection/locate.rs b/crates/typst/src/introspection/locate.rs
index 373b1fe27..8991ae9be 100644
--- a/crates/typst/src/introspection/locate.rs
+++ b/crates/typst/src/introspection/locate.rs
@@ -1,6 +1,6 @@
 use comemo::{Track, Tracked};
 
-use crate::diag::{HintedStrResult, SourceResult};
+use crate::diag::{warning, HintedStrResult, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, Content, Context, Func, LocatableSelector, NativeElement, Packed,
@@ -29,11 +29,12 @@ use crate::syntax::Span;
 ///
 /// # Compatibility
 /// In Typst 0.10 and lower, the `locate` function took a closure that made the
-/// current location in the document available (like [`here`] does now).
-/// Compatibility with the old way will remain for a while to give package
-/// authors time to upgrade. To that effect, `locate` detects whether it
-/// received a selector or a user-defined function and adjusts its semantics
-/// accordingly. This behaviour will be removed in the future.
+/// current location in the document available (like [`here`] does now). This
+/// usage pattern is deprecated. Compatibility with the old way will remain for
+/// a while to give package authors time to upgrade. To that effect, `locate`
+/// detects whether it received a selector or a user-defined function and
+/// adjusts its semantics accordingly. This behaviour will be removed in the
+/// future.
 #[func(contextual)]
 pub fn locate(
     /// The engine.
@@ -56,6 +57,11 @@ pub fn locate(
             LocateOutput::Location(selector.resolve_unique(engine.introspector, context)?)
         }
         LocateInput::Func(func) => {
+            engine.sink.warn(warning!(
+                span, "`locate` with callback function is deprecated";
+                hint: "use a `context` expression instead"
+            ));
+
             LocateOutput::Content(LocateElem::new(func).pack().spanned(span))
         }
     })
diff --git a/crates/typst/src/introspection/query.rs b/crates/typst/src/introspection/query.rs
index e416bfc9d..07f761a8d 100644
--- a/crates/typst/src/introspection/query.rs
+++ b/crates/typst/src/introspection/query.rs
@@ -1,9 +1,10 @@
 use comemo::Tracked;
 
-use crate::diag::HintedStrResult;
+use crate::diag::{warning, HintedStrResult};
 use crate::engine::Engine;
 use crate::foundations::{func, Array, Context, LocatableSelector, Value};
 use crate::introspection::Location;
+use crate::syntax::Span;
 
 /// Finds elements in the document.
 ///
@@ -141,6 +142,8 @@ pub fn query(
     engine: &mut Engine,
     /// The callsite context.
     context: Tracked<Context>,
+    /// The span of the `query` call.
+    span: Span,
     /// Can be
     /// - an element function like a `heading` or `figure`,
     /// - a `{<label>}`,
@@ -149,13 +152,18 @@ pub fn query(
     ///
     /// Only [locatable]($location/#locatable) element functions are supported.
     target: LocatableSelector,
-    /// _Compatibility:_ This argument only exists for compatibility with
-    /// Typst 0.10 and lower and shouldn't be used anymore.
+    /// _Compatibility:_ This argument is deprecated. It only exists for
+    /// compatibility with Typst 0.10 and lower and shouldn't be used anymore.
     #[default]
     location: Option<Location>,
 ) -> HintedStrResult<Array> {
     if location.is_none() {
         context.introspect()?;
+    } else {
+        engine.sink.warn(warning!(
+            span, "calling `query` with a location is deprecated";
+            hint: "try removing the location argument"
+        ));
     }
 
     let vec = engine.introspector.query(&target.0);
diff --git a/crates/typst/src/introspection/state.rs b/crates/typst/src/introspection/state.rs
index be114c86f..a88ed526a 100644
--- a/crates/typst/src/introspection/state.rs
+++ b/crates/typst/src/introspection/state.rs
@@ -1,7 +1,7 @@
 use comemo::{Track, Tracked, TrackedMut};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
 
-use crate::diag::{bail, At, SourceResult};
+use crate::diag::{bail, warning, At, SourceResult};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Args, Construct, Content, Context, Func,
@@ -325,13 +325,19 @@ impl State {
         context: Tracked<Context>,
         /// The callsite span.
         span: Span,
-        /// _Compatibility:_ This argument only exists for compatibility with
-        /// Typst 0.10 and lower and shouldn't be used anymore.
+        /// _Compatibility:_ This argument is deprecated. It only exists for
+        /// compatibility with Typst 0.10 and lower and shouldn't be used
+        /// anymore.
         #[default]
         location: Option<Location>,
     ) -> SourceResult<Value> {
         if location.is_none() {
             context.location().at(span)?;
+        } else {
+            engine.sink.warn(warning!(
+                span, "calling `state.final` with a location is deprecated";
+                hint: "try removing the location argument"
+            ));
         }
 
         let sequence = self.sequence(engine)?;
@@ -365,6 +371,8 @@ impl State {
     #[func]
     pub fn display(
         self,
+        /// The engine.
+        engine: &mut Engine,
         /// The span of the `display` call.
         span: Span,
         /// A function which receives the value of the state and can return
@@ -373,6 +381,11 @@ impl State {
         #[default]
         func: Option<Func>,
     ) -> Content {
+        engine.sink.warn(warning!(
+            span, "`state.display` is deprecated";
+            hint: "use `state.get` in a `context` expression instead"
+        ));
+
         StateDisplayElem::new(self, func).pack().spanned(span)
     }
 }
diff --git a/crates/typst/src/layout/inline/line.rs b/crates/typst/src/layout/inline/line.rs
index 12162ab16..bf1662ce3 100644
--- a/crates/typst/src/layout/inline/line.rs
+++ b/crates/typst/src/layout/inline/line.rs
@@ -133,7 +133,7 @@ pub fn line<'a>(
         || (p.justify && breakpoint != Breakpoint::Mandatory);
 
     // Process dashes.
-    let dash = if breakpoint == Breakpoint::Hyphen || full.ends_with(SHY) {
+    let dash = if breakpoint.is_hyphen() || full.ends_with(SHY) {
         Some(Dash::Soft)
     } else if full.ends_with(HYPHEN) {
         Some(Dash::Hard)
diff --git a/crates/typst/src/layout/inline/linebreak.rs b/crates/typst/src/layout/inline/linebreak.rs
index 075d24b33..defb5f81c 100644
--- a/crates/typst/src/layout/inline/linebreak.rs
+++ b/crates/typst/src/layout/inline/linebreak.rs
@@ -1,5 +1,6 @@
 use std::ops::{Add, Sub};
 
+use az::SaturatingAs;
 use icu_properties::maps::{CodePointMapData, CodePointMapDataBorrowed};
 use icu_properties::sets::CodePointSetData;
 use icu_properties::LineBreak;
@@ -21,10 +22,15 @@ use crate::text::{Lang, TextElem};
 type Cost = f64;
 
 // Cost parameters.
-const DEFAULT_HYPH_COST: Cost = 0.5;
-const DEFAULT_RUNT_COST: Cost = 0.5;
-const CONSECUTIVE_DASH_COST: Cost = 0.3;
-const MAX_COST: Cost = 1_000_000.0;
+//
+// We choose higher costs than the Knuth-Plass paper (which would be 50) because
+// it hyphenates way to eagerly in Typst otherwise. Could be related to the
+// ratios coming out differently since Typst doesn't have the concept of glue,
+// so things work a bit differently.
+const DEFAULT_HYPH_COST: Cost = 135.0;
+const DEFAULT_RUNT_COST: Cost = 100.0;
+
+// Other parameters.
 const MIN_RATIO: f64 = -1.0;
 const MIN_APPROX_RATIO: f64 = -0.5;
 const BOUND_EPS: f64 = 1e-3;
@@ -65,8 +71,9 @@ pub enum Breakpoint {
     Normal,
     /// A mandatory breakpoint (after '\n' or at the end of the text).
     Mandatory,
-    /// An opportunity for hyphenating.
-    Hyphen,
+    /// An opportunity for hyphenating and how many chars are before/after it
+    /// in the word.
+    Hyphen(u8, u8),
 }
 
 impl Breakpoint {
@@ -95,9 +102,14 @@ impl Breakpoint {
             }
 
             // Trim nothing further.
-            Self::Hyphen => line,
+            Self::Hyphen(..) => line,
         }
     }
+
+    /// Whether this is a hyphen breakpoint.
+    pub fn is_hyphen(self) -> bool {
+        matches!(self, Self::Hyphen(..))
+    }
 }
 
 /// Breaks the paragraph into lines.
@@ -254,7 +266,6 @@ fn linebreak_optimized_bounded<'a>(
                 width,
                 &pred.line,
                 &attempt,
-                end,
                 breakpoint,
                 unbreakable,
             );
@@ -374,8 +385,6 @@ fn linebreak_optimized_approximate(
     let mut prev_end = 0;
 
     breakpoints(p, |end, breakpoint| {
-        let at_end = end == p.text.len();
-
         // Find the optimal predecessor.
         let mut best: Option<Entry> = None;
         for (pred_index, pred) in table.iter().enumerate().skip(active) {
@@ -384,13 +393,12 @@ fn linebreak_optimized_approximate(
 
             // Whether the line is justified. This is not 100% accurate w.r.t
             // to line()'s behaviour, but good enough.
-            let justify = p.justify && !at_end && breakpoint != Breakpoint::Mandatory;
+            let justify = p.justify && breakpoint != Breakpoint::Mandatory;
 
             // We don't really know whether the line naturally ends with a dash
             // here, so we can miss that case, but it's ok, since all of this
             // just an estimate.
-            let consecutive_dash =
-                pred.breakpoint == Breakpoint::Hyphen && breakpoint == Breakpoint::Hyphen;
+            let consecutive_dash = pred.breakpoint.is_hyphen() && breakpoint.is_hyphen();
 
             // Estimate how much the line's spaces would need to be stretched to
             // make it the desired width. We trim at the end to not take into
@@ -401,7 +409,7 @@ fn linebreak_optimized_approximate(
                 p,
                 width,
                 estimates.widths.estimate(start..trimmed_end)
-                    + if breakpoint == Breakpoint::Hyphen {
+                    + if breakpoint.is_hyphen() {
                         metrics.approx_hyphen_width
                     } else {
                         Abs::zero()
@@ -416,7 +424,6 @@ fn linebreak_optimized_approximate(
                 metrics,
                 breakpoint,
                 line_ratio,
-                at_end,
                 justify,
                 unbreakable,
                 consecutive_dash,
@@ -474,17 +481,8 @@ fn linebreak_optimized_approximate(
         let Entry { end, breakpoint, unbreakable, .. } = table[idx];
 
         let attempt = line(engine, p, start..end, breakpoint, Some(&pred));
-
-        let (_, line_cost) = ratio_and_cost(
-            p,
-            metrics,
-            width,
-            &pred,
-            &attempt,
-            end,
-            breakpoint,
-            unbreakable,
-        );
+        let (_, line_cost) =
+            ratio_and_cost(p, metrics, width, &pred, &attempt, breakpoint, unbreakable);
 
         pred = attempt;
         start = end;
@@ -502,7 +500,6 @@ fn ratio_and_cost(
     available_width: Abs,
     pred: &Line,
     attempt: &Line,
-    end: usize,
     breakpoint: Breakpoint,
     unbreakable: bool,
 ) -> (f64, Cost) {
@@ -519,7 +516,6 @@ fn ratio_and_cost(
         metrics,
         breakpoint,
         ratio,
-        end == p.text.len(),
         attempt.justify,
         unbreakable,
         pred.dash.is_some() && attempt.dash.is_some(),
@@ -569,57 +565,64 @@ fn raw_ratio(
 }
 
 /// Compute the cost of a line given raw metrics.
-#[allow(clippy::too_many_arguments)]
+///
+/// This mostly follows the formula in the Knuth-Plass paper, but there are some
+/// adjustments.
 fn raw_cost(
     metrics: &CostMetrics,
     breakpoint: Breakpoint,
     ratio: f64,
-    at_end: bool,
     justify: bool,
     unbreakable: bool,
     consecutive_dash: bool,
     approx: bool,
 ) -> Cost {
-    // Determine the cost of the line.
-    let mut cost = if ratio < metrics.min_ratio(approx) {
+    // Determine the stretch/shrink cost of the line.
+    let badness = if ratio < metrics.min_ratio(approx) {
         // Overfull line always has maximum cost.
-        MAX_COST
-    } else if breakpoint == Breakpoint::Mandatory || at_end {
-        // - If ratio < 0, we always need to shrink the line (even the last one).
-        // - If ratio > 0, we need to stretch the line only when it is justified
-        //   (last line is not justified by default even if `p.justify` is true).
-        if ratio < 0.0 || (ratio > 0.0 && justify) {
-            ratio.powi(3).abs()
-        } else {
-            0.0
-        }
+        1_000_000.0
+    } else if justify || ratio < 0.0 {
+        // If the line shall be justified or needs shrinking, it has normal
+        // badness with cost 100|ratio|^3. We limit the ratio to 10 as to not
+        // get to close to our maximum cost.
+        100.0 * ratio.abs().min(10.0).powi(3)
     } else {
-        // Normal line with cost of |ratio^3|.
-        ratio.powi(3).abs()
+        // If the line shouldn't be justified and doesn't need shrink, we don't
+        // pay any cost.
+        0.0
     };
 
-    // Penalize runts (lone words in the last line).
-    if unbreakable && at_end {
-        cost += metrics.runt_cost;
+    // Compute penalties.
+    let mut penalty = 0.0;
+
+    // Penalize runts (lone words before a mandatory break / at the end).
+    if unbreakable && breakpoint == Breakpoint::Mandatory {
+        penalty += metrics.runt_cost;
     }
 
     // Penalize hyphenation.
-    if breakpoint == Breakpoint::Hyphen {
-        cost += metrics.hyph_cost;
+    if let Breakpoint::Hyphen(l, r) = breakpoint {
+        // We penalize hyphenations close to the edges of the word (< LIMIT
+        // chars) extra. For each step of distance from the limit, we add 15%
+        // to the cost.
+        const LIMIT: u8 = 5;
+        let steps = LIMIT.saturating_sub(l) + LIMIT.saturating_sub(r);
+        let extra = 0.15 * steps as f64;
+        penalty += (1.0 + extra) * metrics.hyph_cost;
     }
 
-    // In the Knuth paper, cost = (1 + 100|r|^3 + p)^2 + a,
-    // where r is the ratio, p=50 is the penalty, and a=3000 is
-    // consecutive the penalty. We divide the whole formula by 10,
-    // resulting (0.01 + |r|^3 + p)^2 + a, where p=0.5 and a=0.3
-    let mut cost = (0.01 + cost).powi(2);
-
-    // Penalize two consecutive dashes (not necessarily hyphens) extra.
+    // Penalize two consecutive dashes extra (not necessarily hyphens).
+    // Knuth-Plass does this separately after the squaring, with a higher cost,
+    // but I couldn't find any explanation as to why.
     if consecutive_dash {
-        cost += CONSECUTIVE_DASH_COST;
+        penalty += metrics.hyph_cost;
     }
 
-    cost
+    // From the Knuth-Plass Paper: $ (1 + beta_j + pi_j)^2 $.
+    //
+    // We add one to minimize the number of lines when everything else is more
+    // or less equal.
+    (1.0 + badness + penalty).powi(2)
 }
 
 /// Calls `f` for all possible points in the text where lines can broken.
@@ -655,9 +658,9 @@ fn breakpoints(p: &Preparation, mut f: impl FnMut(usize, Breakpoint)) {
         let (head, tail) = text.split_at(last);
         if head.ends_with("://") || tail.starts_with("www.") {
             let (link, _) = link_prefix(tail);
-            let end = last + link.len();
             linebreak_link(link, |i| f(last + i, Breakpoint::Normal));
-            while iter.peek().is_some_and(|&p| p < end) {
+            last += link.len();
+            while iter.peek().is_some_and(|&p| p < last) {
                 iter.next();
             }
         }
@@ -687,19 +690,17 @@ fn breakpoints(p: &Preparation, mut f: impl FnMut(usize, Breakpoint)) {
         };
 
         // Hyphenate between the last and current breakpoint.
-        if hyphenate {
-            let mut offset = last;
+        if hyphenate && last < point {
             for segment in text[last..point].split_word_bounds() {
                 if !segment.is_empty() && segment.chars().all(char::is_alphabetic) {
-                    hyphenations(p, &lb, offset, segment, &mut f);
+                    hyphenations(p, &lb, last, segment, &mut f);
                 }
-                offset += segment.len();
+                last += segment.len();
             }
         }
 
         // Call `f` for the UAX #14 break opportunity.
         f(point, breakpoint);
-
         last = point;
     }
 }
@@ -713,10 +714,13 @@ fn hyphenations(
     mut f: impl FnMut(usize, Breakpoint),
 ) {
     let Some(lang) = lang_at(p, offset) else { return };
+    let count = word.chars().count();
     let end = offset + word.len();
 
+    let mut chars = 0;
     for syllable in hypher::hyphenate(word, lang) {
         offset += syllable.len();
+        chars += syllable.chars().count();
 
         // Don't hyphenate after the final syllable.
         if offset == end {
@@ -737,8 +741,12 @@ fn hyphenations(
             continue;
         }
 
+        // Determine the number of codepoints before and after the hyphenation.
+        let l = chars.saturating_as::<u8>();
+        let r = (count - chars).saturating_as::<u8>();
+
         // Call `f` for the word-internal hyphenation opportunity.
-        f(offset, Breakpoint::Hyphen);
+        f(offset, Breakpoint::Hyphen(l, r));
     }
 }
 
@@ -827,9 +835,9 @@ fn lang_at(p: &Preparation, offset: usize) -> Option<hypher::Lang> {
 struct CostMetrics {
     min_ratio: f64,
     min_approx_ratio: f64,
+    approx_hyphen_width: Abs,
     hyph_cost: Cost,
     runt_cost: Cost,
-    approx_hyphen_width: Abs,
 }
 
 impl CostMetrics {
@@ -839,10 +847,11 @@ impl CostMetrics {
             // When justifying, we may stretch spaces below their natural width.
             min_ratio: if p.justify { MIN_RATIO } else { 0.0 },
             min_approx_ratio: if p.justify { MIN_APPROX_RATIO } else { 0.0 },
-            hyph_cost: DEFAULT_HYPH_COST * p.costs.hyphenation().get(),
-            runt_cost: DEFAULT_RUNT_COST * p.costs.runt().get(),
             // Approximate hyphen width for estimates.
             approx_hyphen_width: Em::new(0.33).at(p.size),
+            // Costs.
+            hyph_cost: DEFAULT_HYPH_COST * p.costs.hyphenation().get(),
+            runt_cost: DEFAULT_RUNT_COST * p.costs.runt().get(),
         }
     }
 
diff --git a/crates/typst/src/layout/measure.rs b/crates/typst/src/layout/measure.rs
index af093f243..cb08e5913 100644
--- a/crates/typst/src/layout/measure.rs
+++ b/crates/typst/src/layout/measure.rs
@@ -1,6 +1,6 @@
 use comemo::Tracked;
 
-use crate::diag::{At, SourceResult};
+use crate::diag::{warning, At, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     dict, func, Content, Context, Dict, Resolve, Smart, StyleChain, Styles,
@@ -76,13 +76,19 @@ pub fn measure(
     height: Smart<Length>,
     /// The content whose size to measure.
     content: Content,
-    /// _Compatibility:_ This argument only exists for compatibility with
-    /// Typst 0.10 and lower and shouldn't be used anymore.
+    /// _Compatibility:_ This argument is deprecated. It only exists for
+    /// compatibility with Typst 0.10 and lower and shouldn't be used anymore.
     #[default]
     styles: Option<Styles>,
 ) -> SourceResult<Dict> {
     let styles = match &styles {
-        Some(styles) => StyleChain::new(styles),
+        Some(styles) => {
+            engine.sink.warn(warning!(
+                span, "calling `measure` with a styles argument is deprecated";
+                hint: "try removing the styles argument"
+            ));
+            StyleChain::new(styles)
+        }
         None => context.styles().at(span)?,
     };
 
diff --git a/crates/typst/src/layout/page.rs b/crates/typst/src/layout/page.rs
index cf8989175..ca2a0ce91 100644
--- a/crates/typst/src/layout/page.rs
+++ b/crates/typst/src/layout/page.rs
@@ -24,7 +24,7 @@ use crate::layout::{
 use crate::model::Numbering;
 use crate::text::TextElem;
 use crate::utils::{NonZeroExt, Numeric, Scalar};
-use crate::visualize::Paint;
+use crate::visualize::{Color, Paint};
 
 /// Layouts its child onto one or multiple pages.
 ///
@@ -178,12 +178,20 @@ pub struct PageElem {
     #[default(NonZeroUsize::ONE)]
     pub columns: NonZeroUsize,
 
-    /// The page's background color.
+    /// The page's background fill.
     ///
-    /// This instructs the printer to color the complete page with the given
-    /// color. If you are considering larger production runs, it may be more
-    /// environmentally friendly and cost-effective to source pre-dyed pages and
-    /// not set this property.
+    /// Setting this to something non-transparent instructs the printer to color
+    /// the complete page. If you are considering larger production runs, it may
+    /// be more environmentally friendly and cost-effective to source pre-dyed
+    /// pages and not set this property.
+    ///
+    /// When set to `{none}`, the background becomes transparent. Note that PDF
+    /// pages will still appear with a (usually white) background in viewers,
+    /// but they are conceptually transparent. (If you print them, no color is
+    /// used for the background.)
+    ///
+    /// The default of `{auto}` results in `{none}` for PDF output, and
+    /// `{white}` for PNG and SVG.
     ///
     /// ```example
     /// #set page(fill: rgb("444352"))
@@ -191,7 +199,7 @@ pub struct PageElem {
     /// *Dark mode enabled.*
     /// ```
     #[borrowed]
-    pub fill: Option<Paint>,
+    pub fill: Smart<Option<Paint>>,
 
     /// How to [number]($numbering) the pages.
     ///
@@ -555,13 +563,10 @@ impl PageLayout<'_> {
                 }
             }
 
-            if let Some(fill) = fill {
-                frame.fill(fill.clone());
-            }
-
             page_counter.visit(engine, &frame)?;
             pages.push(Page {
                 frame,
+                fill: fill.clone(),
                 numbering: numbering.clone(),
                 number: page_counter.logical(),
             });
@@ -578,6 +583,15 @@ impl PageLayout<'_> {
 pub struct Page {
     /// The frame that defines the page.
     pub frame: Frame,
+    /// How the page is filled.
+    ///
+    /// - When `None`, the background is transparent.
+    /// - When `Auto`, the background is transparent for PDF and white
+    ///   for raster and SVG targets.
+    ///
+    /// Exporters should access the resolved value of this property through
+    /// `fill_or_transparent()` or `fill_or_white()`.
+    pub fill: Smart<Option<Paint>>,
     /// The page's numbering.
     pub numbering: Option<Numbering>,
     /// The logical page number (controlled by `counter(page)` and may thus not
@@ -585,6 +599,22 @@ pub struct Page {
     pub number: usize,
 }
 
+impl Page {
+    /// Get the configured background or `None` if it is `Auto`.
+    ///
+    /// This is used in PDF export.
+    pub fn fill_or_transparent(&self) -> Option<Paint> {
+        self.fill.clone().unwrap_or(None)
+    }
+
+    /// Get the configured background or white if it is `Auto`.
+    ///
+    /// This is used in raster and SVG export.
+    pub fn fill_or_white(&self) -> Option<Paint> {
+        self.fill.clone().unwrap_or_else(|| Some(Color::WHITE.into()))
+    }
+}
+
 /// Specification of the page's margins.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Margin {
diff --git a/crates/typst/src/layout/ratio.rs b/crates/typst/src/layout/ratio.rs
index 2d791f2d4..020d689aa 100644
--- a/crates/typst/src/layout/ratio.rs
+++ b/crates/typst/src/layout/ratio.rs
@@ -70,7 +70,7 @@ impl Ratio {
 
 impl Debug for Ratio {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{:?}%", self.get())
+        write!(f, "{:?}%", self.get() * 100.0)
     }
 }
 
diff --git a/crates/typst/src/layout/transform.rs b/crates/typst/src/layout/transform.rs
index 7172466f3..dcb178fdb 100644
--- a/crates/typst/src/layout/transform.rs
+++ b/crates/typst/src/layout/transform.rs
@@ -1,13 +1,18 @@
-use crate::diag::SourceResult;
+use std::ops::Div;
+
+use once_cell::unsync::Lazy;
+
+use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, Resolve, Show, StyleChain,
+    cast, elem, Content, NativeElement, Packed, Resolve, Show, Smart, StyleChain,
 };
 use crate::introspection::Locator;
 use crate::layout::{
     Abs, Alignment, Angle, Axes, BlockElem, FixedAlignment, Frame, HAlignment, Length,
     Point, Ratio, Region, Regions, Rel, Size, VAlignment,
 };
+use crate::utils::Numeric;
 
 /// Moves content without affecting layout.
 ///
@@ -149,12 +154,11 @@ fn layout_rotate(
     let align = elem.origin(styles).resolve(styles);
 
     // Compute the new region's approximate size.
-    let size = region
-        .size
-        .to_point()
-        .transform_inf(Transform::rotate(angle))
-        .map(Abs::abs)
-        .to_size();
+    let size = if region.size.is_finite() {
+        compute_bounding_box(region.size, Transform::rotate(-angle)).1
+    } else {
+        Size::splat(Abs::inf())
+    };
 
     measure_and_layout(
         engine,
@@ -188,15 +192,15 @@ pub struct ScaleElem {
         let all = args.find()?;
         args.named("x")?.or(all)
     )]
-    #[default(Ratio::one())]
-    pub x: Ratio,
+    #[default(Smart::Custom(ScaleAmount::Ratio(Ratio::one())))]
+    pub x: Smart<ScaleAmount>,
 
     /// The vertical scaling factor.
     ///
     /// The body will be mirrored vertically if the parameter is negative.
     #[parse(args.named("y")?.or(all))]
-    #[default(Ratio::one())]
-    pub y: Ratio,
+    #[default(Smart::Custom(ScaleAmount::Ratio(Ratio::one())))]
+    pub y: Smart<ScaleAmount>,
 
     /// The origin of the transformation.
     ///
@@ -242,12 +246,12 @@ fn layout_scale(
     styles: StyleChain,
     region: Region,
 ) -> SourceResult<Frame> {
-    let sx = elem.x(styles);
-    let sy = elem.y(styles);
-    let align = elem.origin(styles).resolve(styles);
-
     // Compute the new region's approximate size.
-    let size = region.size.zip_map(Axes::new(sx, sy), |r, s| s.of(r)).map(Abs::abs);
+    let scale = elem.resolve_scale(engine, locator.relayout(), region.size, styles)?;
+    let size = region
+        .size
+        .zip_map(scale, |r, s| if r.is_finite() { Ratio::new(1.0 / s).of(r) } else { r })
+        .map(Abs::abs);
 
     measure_and_layout(
         engine,
@@ -256,12 +260,84 @@ fn layout_scale(
         size,
         styles,
         elem.body(),
-        Transform::scale(sx, sy),
-        align,
+        Transform::scale(scale.x, scale.y),
+        elem.origin(styles).resolve(styles),
         elem.reflow(styles),
     )
 }
 
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+enum ScaleAmount {
+    Ratio(Ratio),
+    Length(Length),
+}
+
+impl Packed<ScaleElem> {
+    /// Resolves scale parameters, preserving aspect ratio if one of the scales is set to `auto`.
+    fn resolve_scale(
+        &self,
+        engine: &mut Engine,
+        locator: Locator,
+        container: Size,
+        styles: StyleChain,
+    ) -> SourceResult<Axes<Ratio>> {
+        fn resolve_axis(
+            axis: Smart<ScaleAmount>,
+            body: impl Fn() -> SourceResult<Abs>,
+            styles: StyleChain,
+        ) -> SourceResult<Smart<Ratio>> {
+            Ok(match axis {
+                Smart::Auto => Smart::Auto,
+                Smart::Custom(amt) => Smart::Custom(match amt {
+                    ScaleAmount::Ratio(ratio) => ratio,
+                    ScaleAmount::Length(length) => {
+                        let length = length.resolve(styles);
+                        Ratio::new(length.div(body()?))
+                    }
+                }),
+            })
+        }
+
+        let size = Lazy::new(|| {
+            let pod = Regions::one(container, Axes::splat(false));
+            let frame = self.body().layout(engine, locator, styles, pod)?.into_frame();
+            SourceResult::Ok(frame.size())
+        });
+
+        let x = resolve_axis(
+            self.x(styles),
+            || size.as_ref().map(|size| size.x).map_err(Clone::clone),
+            styles,
+        )?;
+
+        let y = resolve_axis(
+            self.y(styles),
+            || size.as_ref().map(|size| size.y).map_err(Clone::clone),
+            styles,
+        )?;
+
+        match (x, y) {
+            (Smart::Auto, Smart::Auto) => {
+                bail!(self.span(), "x and y cannot both be auto")
+            }
+            (Smart::Custom(x), Smart::Custom(y)) => Ok(Axes::new(x, y)),
+            (Smart::Auto, Smart::Custom(v)) | (Smart::Custom(v), Smart::Auto) => {
+                Ok(Axes::splat(v))
+            }
+        }
+    }
+}
+
+cast! {
+    ScaleAmount,
+    self => match self {
+        ScaleAmount::Ratio(ratio) => ratio.into_value(),
+        ScaleAmount::Length(length) => length.into_value(),
+    },
+    ratio: Ratio => ScaleAmount::Ratio(ratio),
+    length: Length => ScaleAmount::Length(length),
+}
+
 /// A scale-skew-translate transformation.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Transform {
@@ -416,7 +492,7 @@ fn measure_and_layout(
             .pre_concat(Transform::translate(-x, -y));
 
         // Compute the bounding box and offset and wrap in a new frame.
-        let (offset, size) = compute_bounding_box(&frame, ts);
+        let (offset, size) = compute_bounding_box(frame.size(), ts);
         frame.transform(ts);
         frame.translate(offset);
         frame.set_size(size);
@@ -439,20 +515,20 @@ fn measure_and_layout(
     }
 }
 
-/// Computes the bounding box and offset of a transformed frame.
-fn compute_bounding_box(frame: &Frame, ts: Transform) -> (Point, Size) {
+/// Computes the bounding box and offset of a transformed area.
+fn compute_bounding_box(size: Size, ts: Transform) -> (Point, Size) {
     let top_left = Point::zero().transform_inf(ts);
-    let top_right = Point::new(frame.width(), Abs::zero()).transform_inf(ts);
-    let bottom_left = Point::new(Abs::zero(), frame.height()).transform_inf(ts);
-    let bottom_right = Point::new(frame.width(), frame.height()).transform_inf(ts);
+    let top_right = Point::with_x(size.x).transform_inf(ts);
+    let bottom_left = Point::with_y(size.y).transform_inf(ts);
+    let bottom_right = size.to_point().transform_inf(ts);
 
-    // We first compute the new bounding box of the rotated frame.
+    // We first compute the new bounding box of the rotated area.
     let min_x = top_left.x.min(top_right.x).min(bottom_left.x).min(bottom_right.x);
     let min_y = top_left.y.min(top_right.y).min(bottom_left.y).min(bottom_right.y);
     let max_x = top_left.x.max(top_right.x).max(bottom_left.x).max(bottom_right.x);
     let max_y = top_left.y.max(top_right.y).max(bottom_left.y).max(bottom_right.y);
 
-    // Then we compute the new size of the frame.
+    // Then we compute the new size of the area.
     let width = max_x - min_x;
     let height = max_y - min_y;
 
diff --git a/crates/typst/src/math/matrix.rs b/crates/typst/src/math/matrix.rs
index 34e0611a6..514490470 100644
--- a/crates/typst/src/math/matrix.rs
+++ b/crates/typst/src/math/matrix.rs
@@ -18,7 +18,7 @@ use crate::symbols::Symbol;
 use crate::syntax::{Span, Spanned};
 use crate::text::TextElem;
 use crate::utils::Numeric;
-use crate::visualize::{FixedStroke, Geometry, LineCap, Shape, Stroke};
+use crate::visualize::{FillRule, FixedStroke, Geometry, LineCap, Shape, Stroke};
 
 use super::delimiter_alignment;
 
@@ -458,6 +458,12 @@ fn layout_mat_body(
     gap: Axes<Rel<Abs>>,
     span: Span,
 ) -> SourceResult<Frame> {
+    let ncols = rows.first().map_or(0, |row| row.len());
+    let nrows = rows.len();
+    if ncols == 0 || nrows == 0 {
+        return Ok(Frame::soft(Size::zero()));
+    }
+
     let gap = gap.zip_map(ctx.regions.base(), Rel::relative_to);
     let half_gap = gap * 0.5;
 
@@ -483,12 +489,6 @@ fn layout_mat_body(
         _ => (AugmentOffsets::default(), AugmentOffsets::default(), default_stroke),
     };
 
-    let ncols = rows.first().map_or(0, |row| row.len());
-    let nrows = rows.len();
-    if ncols == 0 || nrows == 0 {
-        return Ok(Frame::soft(Size::zero()));
-    }
-
     // 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.
@@ -597,6 +597,7 @@ fn line_item(length: Abs, vertical: bool, stroke: FixedStroke, span: Span) -> Fr
         Shape {
             geometry: line_geom,
             fill: None,
+            fill_rule: FillRule::default(),
             stroke: Some(stroke),
         },
         span,
diff --git a/crates/typst/src/math/stretch.rs b/crates/typst/src/math/stretch.rs
index cc71ced6d..749773e3c 100644
--- a/crates/typst/src/math/stretch.rs
+++ b/crates/typst/src/math/stretch.rs
@@ -39,7 +39,13 @@ fn stretch_glyph(
     short_fall: Abs,
     horizontal: bool,
 ) -> VariantFragment {
+    // If the base glyph is good enough, use it.
+    let advance = if horizontal { base.width } else { 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
@@ -55,12 +61,6 @@ fn stretch_glyph(
         })
         .unwrap_or(GlyphConstruction { assembly: None, variants: LazyArray16::new(&[]) });
 
-    // If the base glyph is good enough, use it.
-    let advance = if horizontal { base.width } else { base.height() };
-    if short_target <= advance {
-        return base.into_variant();
-    }
-
     // Search for a pre-made variant with a good advance.
     let mut best_id = base.id;
     let mut best_advance = base.width;
diff --git a/crates/typst/src/text/mod.rs b/crates/typst/src/text/mod.rs
index 0bf572e5f..125b09877 100644
--- a/crates/typst/src/text/mod.rs
+++ b/crates/typst/src/text/mod.rs
@@ -513,11 +513,6 @@ pub struct TextElem {
     /// default of `auto`, prevents them. More nuanced cost specification for
     /// these modifications is planned for the future.)
     ///
-    /// The default costs are an acceptable balance, but some may find that it
-    /// hyphenates or avoids runs too eagerly, breaking the flow of dense prose.
-    /// A cost of 600% (six times the normal cost) may work better for such
-    /// contexts.
-    ///
     /// ```example
     /// #set text(hyphenate: true, size: 11.4pt)
     /// #set par(justify: true)
diff --git a/crates/typst/src/visualize/path.rs b/crates/typst/src/visualize/path.rs
index df9114267..0ba412cde 100644
--- a/crates/typst/src/visualize/path.rs
+++ b/crates/typst/src/visualize/path.rs
@@ -10,7 +10,7 @@ use crate::introspection::Locator;
 use crate::layout::{
     Abs, Axes, BlockElem, Frame, FrameItem, Length, Point, Region, Rel, Size,
 };
-use crate::visualize::{FixedStroke, Geometry, Paint, Shape, Stroke};
+use crate::visualize::{FillRule, FixedStroke, Geometry, Paint, Shape, Stroke};
 
 use PathVertex::{AllControlPoints, MirroredControlPoint, Vertex};
 
@@ -33,11 +33,12 @@ pub struct PathElem {
     ///
     /// When setting a fill, the default stroke disappears. To create a
     /// rectangle with both fill and stroke, you have to configure both.
-    ///
-    /// Currently all paths are filled according to the [non-zero winding
-    /// rule](https://en.wikipedia.org/wiki/Nonzero-rule).
     pub fill: Option<Paint>,
 
+    /// The rule used to fill the path.
+    #[default]
+    pub fill_rule: FillRule,
+
     /// How to [stroke] the path. This can be:
     ///
     /// Can be set to  `{none}` to disable the stroke or to `{auto}` for a
@@ -147,6 +148,7 @@ fn layout_path(
 
     // Prepare fill and stroke.
     let fill = elem.fill(styles);
+    let fill_rule = elem.fill_rule(styles);
     let stroke = match elem.stroke(styles) {
         Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
         Smart::Auto => None,
@@ -154,7 +156,12 @@ fn layout_path(
     };
 
     let mut frame = Frame::soft(size);
-    let shape = Shape { geometry: Geometry::Path(path), stroke, fill };
+    let shape = Shape {
+        geometry: Geometry::Path(path),
+        stroke,
+        fill,
+        fill_rule,
+    };
     frame.push(Point::zero(), FrameItem::Shape(shape, elem.span()));
     Ok(frame)
 }
diff --git a/crates/typst/src/visualize/polygon.rs b/crates/typst/src/visualize/polygon.rs
index 120f41fcb..deb5e1009 100644
--- a/crates/typst/src/visualize/polygon.rs
+++ b/crates/typst/src/visualize/polygon.rs
@@ -9,7 +9,7 @@ use crate::introspection::Locator;
 use crate::layout::{Axes, BlockElem, Em, Frame, FrameItem, Length, Point, Region, Rel};
 use crate::syntax::Span;
 use crate::utils::Numeric;
-use crate::visualize::{FixedStroke, Geometry, Paint, Path, Shape, Stroke};
+use crate::visualize::{FillRule, FixedStroke, Geometry, Paint, Path, Shape, Stroke};
 
 /// A closed polygon.
 ///
@@ -32,11 +32,12 @@ pub struct PolygonElem {
     ///
     /// When setting a fill, the default stroke disappears. To create a
     /// rectangle with both fill and stroke, you have to configure both.
-    ///
-    /// Currently all polygons are filled according to the
-    /// [non-zero winding rule](https://en.wikipedia.org/wiki/Nonzero-rule).
     pub fill: Option<Paint>,
 
+    /// The rule used to fill the polygon.
+    #[default]
+    pub fill_rule: FillRule,
+
     /// How to [stroke] the polygon. This can be:
     ///
     /// Can be set to  `{none}` to disable the stroke or to `{auto}` for a
@@ -161,6 +162,7 @@ fn layout_polygon(
 
     // Prepare fill and stroke.
     let fill = elem.fill(styles);
+    let fill_rule = elem.fill_rule(styles);
     let stroke = match elem.stroke(styles) {
         Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
         Smart::Auto => None,
@@ -175,7 +177,12 @@ fn layout_polygon(
     }
     path.close_path();
 
-    let shape = Shape { geometry: Geometry::Path(path), stroke, fill };
+    let shape = Shape {
+        geometry: Geometry::Path(path),
+        stroke,
+        fill,
+        fill_rule,
+    };
     frame.push(Point::zero(), FrameItem::Shape(shape, elem.span()));
     Ok(frame)
 }
diff --git a/crates/typst/src/visualize/shape.rs b/crates/typst/src/visualize/shape.rs
index 8564e1ddf..e8a68fe38 100644
--- a/crates/typst/src/visualize/shape.rs
+++ b/crates/typst/src/visualize/shape.rs
@@ -2,7 +2,9 @@ use std::f64::consts::SQRT_2;
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
-use crate::foundations::{elem, Content, NativeElement, Packed, Show, Smart, StyleChain};
+use crate::foundations::{
+    elem, Cast, Content, NativeElement, Packed, Show, Smart, StyleChain,
+};
 use crate::introspection::Locator;
 use crate::layout::{
     Abs, Axes, BlockElem, Corner, Corners, Frame, FrameItem, Length, Point, Ratio,
@@ -583,10 +585,22 @@ pub struct Shape {
     pub geometry: Geometry,
     /// The shape's background fill.
     pub fill: Option<Paint>,
+    /// The shape's fill rule.
+    pub fill_rule: FillRule,
     /// The shape's border stroke.
     pub stroke: Option<FixedStroke>,
 }
 
+/// A path filling rule.
+#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Cast)]
+pub enum FillRule {
+    /// Specifies that "inside" is computed by a non-zero sum of signed edge crossings.
+    #[default]
+    NonZero,
+    /// Specifies that "inside" is computed by an odd number of edge crossings.
+    EvenOdd,
+}
+
 /// A shape's geometry.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub enum Geometry {
@@ -601,12 +615,22 @@ pub enum Geometry {
 impl Geometry {
     /// Fill the geometry without a stroke.
     pub fn filled(self, fill: Paint) -> Shape {
-        Shape { geometry: self, fill: Some(fill), stroke: None }
+        Shape {
+            geometry: self,
+            fill: Some(fill),
+            fill_rule: FillRule::default(),
+            stroke: None,
+        }
     }
 
     /// Stroke the geometry without a fill.
     pub fn stroked(self, stroke: FixedStroke) -> Shape {
-        Shape { geometry: self, fill: None, stroke: Some(stroke) }
+        Shape {
+            geometry: self,
+            fill: None,
+            fill_rule: FillRule::default(),
+            stroke: Some(stroke),
+        }
     }
 
     /// The bounding box of the geometry.
@@ -641,7 +665,12 @@ pub(crate) fn ellipse(
     path.cubic_to(point(rx, my), point(mx, ry), point(z, ry));
     path.cubic_to(point(-mx, ry), point(-rx, my), point(-rx, z));
 
-    Shape { geometry: Geometry::Path(path), stroke, fill }
+    Shape {
+        geometry: Geometry::Path(path),
+        stroke,
+        fill,
+        fill_rule: FillRule::default(),
+    }
 }
 
 /// Creates a new rectangle as a path.
@@ -704,7 +733,12 @@ fn simple_rect(
     fill: Option<Paint>,
     stroke: Option<FixedStroke>,
 ) -> Vec<Shape> {
-    vec![Shape { geometry: Geometry::Rect(size), fill, stroke }]
+    vec![Shape {
+        geometry: Geometry::Rect(size),
+        fill,
+        stroke,
+        fill_rule: FillRule::default(),
+    }]
 }
 
 fn corners_control_points(
@@ -779,6 +813,7 @@ fn segmented_rect(
         res.push(Shape {
             geometry: Geometry::Path(path),
             fill: Some(fill),
+            fill_rule: FillRule::default(),
             stroke: None,
         });
         stroke_insert += 1;
@@ -916,6 +951,7 @@ fn stroke_segment(
         geometry: Geometry::Path(path),
         stroke: Some(stroke),
         fill: None,
+        fill_rule: FillRule::default(),
     }
 }
 
@@ -1014,6 +1050,7 @@ fn fill_segment(
         geometry: Geometry::Path(path),
         stroke: None,
         fill: Some(stroke.paint.clone()),
+        fill_rule: FillRule::default(),
     }
 }
 
diff --git a/docs/src/main.rs b/docs/src/main.rs
index f4414b109..3f53dfc84 100644
--- a/docs/src/main.rs
+++ b/docs/src/main.rs
@@ -3,7 +3,6 @@ use std::path::{Path, PathBuf};
 
 use clap::Parser;
 use typst::model::Document;
-use typst::visualize::Color;
 use typst_docs::{provide, Html, Resolver};
 use typst_render::render;
 
@@ -35,8 +34,8 @@ impl<'a> Resolver for CliResolver<'a> {
             );
         }
 
-        let frame = &document.pages.first().expect("page 0").frame;
-        let pixmap = render(frame, 2.0, Color::WHITE);
+        let page = document.pages.first().expect("page 0");
+        let pixmap = render(page, 2.0);
         let filename = format!("{hash:x}.png");
         let path = self.assets_dir.join(&filename);
         fs::create_dir_all(path.parent().expect("parent")).expect("create dir");
diff --git a/flake.lock b/flake.lock
index cdc4e5deb..594b8138b 100644
--- a/flake.lock
+++ b/flake.lock
@@ -39,11 +39,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1706371002,
-        "narHash": "sha256-dwuorKimqSYgyu8Cw6ncKhyQjUDOyuXoxDTVmAXq88s=",
+        "lastModified": 1720957393,
+        "narHash": "sha256-oedh2RwpjEa+TNxhg5Je9Ch6d3W1NKi7DbRO1ziHemA=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "c002c6aa977ad22c60398daaa9be52f2203d0006",
+        "rev": "693bc46d169f5af9c992095736e82c3488bf7dbb",
         "type": "github"
       },
       "original": {
diff --git a/tests/fuzz/src/compile.rs b/tests/fuzz/src/compile.rs
index c9536150f..fa9397814 100644
--- a/tests/fuzz/src/compile.rs
+++ b/tests/fuzz/src/compile.rs
@@ -6,7 +6,6 @@ use typst::foundations::{Bytes, Datetime};
 use typst::syntax::{FileId, Source};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
-use typst::visualize::Color;
 use typst::{Library, World};
 
 struct FuzzWorld {
@@ -68,7 +67,7 @@ fuzz_target!(|text: &str| {
     let world = FuzzWorld::new(text);
     if let Ok(document) = typst::compile(&world).output {
         if let Some(page) = document.pages.first() {
-            std::hint::black_box(typst_render::render(&page.frame, 1.0, Color::WHITE));
+            std::hint::black_box(typst_render::render(page, 1.0));
         }
     }
     comemo::evict(10);
diff --git a/tests/ref/issue-hyphenate-in-link.png b/tests/ref/issue-hyphenate-in-link.png
new file mode 100644
index 000000000..932c23ae9
Binary files /dev/null and b/tests/ref/issue-hyphenate-in-link.png differ
diff --git a/tests/ref/justify-avoid-runts.png b/tests/ref/justify-avoid-runts.png
index 70513939c..a0c84eec5 100644
Binary files a/tests/ref/justify-avoid-runts.png and b/tests/ref/justify-avoid-runts.png differ
diff --git a/tests/ref/justify-chinese.png b/tests/ref/justify-chinese.png
index 0284e8b9d..ed9a86f38 100644
Binary files a/tests/ref/justify-chinese.png and b/tests/ref/justify-chinese.png differ
diff --git a/tests/ref/page-fill-none.png b/tests/ref/page-fill-none.png
new file mode 100644
index 000000000..d225135f4
Binary files /dev/null and b/tests/ref/page-fill-none.png differ
diff --git a/tests/ref/path.png b/tests/ref/path.png
index 9643a476c..5aa3b8821 100644
Binary files a/tests/ref/path.png and b/tests/ref/path.png differ
diff --git a/tests/ref/pattern-relative-self.png b/tests/ref/pattern-relative-self.png
index 284080811..617e7dd6f 100644
Binary files a/tests/ref/pattern-relative-self.png and b/tests/ref/pattern-relative-self.png differ
diff --git a/tests/ref/polygon.png b/tests/ref/polygon.png
index 1dc110831..05090e1ea 100644
Binary files a/tests/ref/polygon.png and b/tests/ref/polygon.png differ
diff --git a/tests/ref/transform-scale-abs-and-auto.png b/tests/ref/transform-scale-abs-and-auto.png
new file mode 100644
index 000000000..9b50396d6
Binary files /dev/null and b/tests/ref/transform-scale-abs-and-auto.png differ
diff --git a/tests/ref/transform-scale-relative-sizing.png b/tests/ref/transform-scale-relative-sizing.png
index d10bd3ff4..a6c18a98e 100644
Binary files a/tests/ref/transform-scale-relative-sizing.png and b/tests/ref/transform-scale-relative-sizing.png differ
diff --git a/tests/ref/transform-scale.png b/tests/ref/transform-scale.png
index c95b90f1d..ea113aa1b 100644
Binary files a/tests/ref/transform-scale.png and b/tests/ref/transform-scale.png differ
diff --git a/tests/src/run.rs b/tests/src/run.rs
index 3db03ba43..9681ae4cc 100644
--- a/tests/src/run.rs
+++ b/tests/src/run.rs
@@ -359,13 +359,8 @@ fn render(document: &Document, pixel_per_pt: f32) -> sk::Pixmap {
     }
 
     let gap = Abs::pt(1.0);
-    let mut pixmap = typst_render::render_merged(
-        document,
-        pixel_per_pt,
-        Color::WHITE,
-        gap,
-        Color::BLACK,
-    );
+    let mut pixmap =
+        typst_render::render_merged(document, pixel_per_pt, gap, Some(Color::BLACK));
 
     let gap = (pixel_per_pt * gap.to_pt() as f32).round();
 
diff --git a/tests/suite/foundations/context.typ b/tests/suite/foundations/context.typ
index fea9f544c..0906fb1e4 100644
--- a/tests/suite/foundations/context.typ
+++ b/tests/suite/foundations/context.typ
@@ -43,10 +43,16 @@
   #s.update(x =>
     eval(expr.replace("x", str(x)))
   )
+  // Warning: 17-28 `state.display` is deprecated
+  // Hint: 17-28 use `state.get` in a `context` expression instead
   New value is #s.display().
 ]
 
+// Warning: 1:2-6:3 `locate` with callback function is deprecated
+// Hint: 1:2-6:3 use a `context` expression instead
 #locate(loc => {
+  // Warning: 14-32 calling `query` with a location is deprecated
+  // Hint: 14-32 try removing the location argument
   let elem = query(<here>, loc).first()
   test(s.at(elem.location()), 13)
 })
@@ -58,8 +64,15 @@
 #compute("x - 5")
 
 --- context-compatibility-styling ---
+// Warning: 2-53 `style` is deprecated
+// Hint: 2-53 use a `context` expression instead
+// Warning: 18-39 calling `measure` with a styles argument is deprecated
+// Hint: 18-39 try removing the styles argument
 #style(styles => measure([it], styles).width < 20pt)
 
 --- context-compatibility-counter-display ---
 #counter(heading).update(10)
+
+// Warning: 2-44 `counter.display` without context is deprecated
+// Hint: 2-44 use it in a `context` expression instead
 #counter(heading).display(n => test(n, 10))
diff --git a/tests/suite/foundations/int.typ b/tests/suite/foundations/int.typ
index 0c85dcaba..1744ef881 100644
--- a/tests/suite/foundations/int.typ
+++ b/tests/suite/foundations/int.typ
@@ -38,6 +38,24 @@
 #test(int(10.0).signum(), 1)
 #test(int(-10.0).signum(), -1)
 
+--- int-from-and-to-bytes ---
+// Test `int.from-bytes` and `int.to-bytes`.
+#test(int.from-bytes(bytes(())), 0)
+#test(int.from-bytes(bytes((1, 0, 0, 0, 0, 0, 0, 0)), endian: "little", signed: true), 1)
+#test(int.from-bytes(bytes((1, 0, 0, 0, 0, 0, 0, 0)), endian: "big", signed: true), 72057594037927936)
+#test(int.from-bytes(bytes((1, 0, 0, 0, 0, 0, 0, 0)), endian: "little", signed: false), 1)
+#test(int.from-bytes(bytes((255,)), endian: "big", signed: true), -1)
+#test(int.from-bytes(bytes((255,)), endian: "big", signed: false), 255)
+#test(int.from-bytes((-1000).to-bytes(endian: "big", size: 5), endian: "big", signed: true), -1000)
+#test(int.from-bytes((-1000).to-bytes(endian: "little", size: 5), endian: "little", signed: true), -1000)
+#test(int.from-bytes(1000.to-bytes(endian: "big", size: 5), endian: "big", signed: true), 1000)
+#test(int.from-bytes(1000.to-bytes(endian: "little", size: 5), endian: "little", signed: true), 1000)
+#test(int.from-bytes(1000.to-bytes(endian: "little", size: 5), endian: "little", signed: false), 1000)
+
+--- int-from-and-to-bytes-too-many ---
+// Error: 2-34 too many bytes to convert to a 64 bit number
+#int.from-bytes(bytes((0,) * 16))
+
 --- int-repr ---
 // Test the `repr` function with integers.
 #repr(12) \
diff --git a/tests/suite/introspection/counter.typ b/tests/suite/introspection/counter.typ
index c0b179211..be17d7e06 100644
--- a/tests/suite/introspection/counter.typ
+++ b/tests/suite/introspection/counter.typ
@@ -79,7 +79,7 @@ At Beta, it was #context {
 
 --- issue-2480-counter-reset ---
 #let q = counter("question")
-#let step-show =  q.step() + q.display("1")
+#let step-show =  q.step() + context q.display("1")
 #let g = grid(step-show, step-show, gutter: 2pt)
 
 #g
diff --git a/tests/suite/layout/grid/footers.typ b/tests/suite/layout/grid/footers.typ
index 7cd09003c..edbb36fb1 100644
--- a/tests/suite/layout/grid/footers.typ
+++ b/tests/suite/layout/grid/footers.typ
@@ -282,17 +282,17 @@
   rows: (auto, 2em, auto, auto),
   table.header(
     [eeec],
-    table.cell(rowspan: 2, count.step() + count.display()),
+    table.cell(rowspan: 2, count.step() + context count.display()),
   ),
   [d],
   block(width: 5em, fill: yellow, lorem(7)),
   [d],
   table.footer(
     [eeec],
-    table.cell(rowspan: 2, count.step() + count.display()),
+    table.cell(rowspan: 2, count.step() + context count.display()),
   )
 )
-#count.display()
+#context count.display()
 
 --- grid-nested-with-footers ---
 // Nested table with footer should repeat both footers
diff --git a/tests/suite/layout/grid/headers.typ b/tests/suite/layout/grid/headers.typ
index 78a2540f4..c9c95e134 100644
--- a/tests/suite/layout/grid/headers.typ
+++ b/tests/suite/layout/grid/headers.typ
@@ -265,13 +265,13 @@
   rows: (auto, 2em, auto, auto),
   table.header(
     [eeec],
-    table.cell(rowspan: 2, count.step() + count.display()),
+    table.cell(rowspan: 2, count.step() + context count.display()),
   ),
   [d],
   block(width: 5em, fill: yellow, lorem(15)),
   [d]
 )
-#count.display()
+#context count.display()
 
 --- grid-header-expand ---
 // Ensure header expands to fit cell placed in it after its declaration
diff --git a/tests/suite/layout/grid/rowspan.typ b/tests/suite/layout/grid/rowspan.typ
index f7a377b6e..e5c8bbc8c 100644
--- a/tests/suite/layout/grid/rowspan.typ
+++ b/tests/suite/layout/grid/rowspan.typ
@@ -163,7 +163,7 @@
 #let count = counter("count")
 #show grid.cell: it => {
   count.step()
-  count.display()
+  context count.display()
 }
 
 #grid(
diff --git a/tests/suite/layout/inline/linebreak.typ b/tests/suite/layout/inline/linebreak.typ
index 2fa29b6ce..7e959352b 100644
--- a/tests/suite/layout/inline/linebreak.typ
+++ b/tests/suite/layout/inline/linebreak.typ
@@ -107,3 +107,11 @@ For info see #link("https://myhost.tld").
 #set page(width: 50pt, height: auto)
 #h(99%) 🏳️‍🌈
 🏳️‍🌈
+
+--- issue-hyphenate-in-link ---
+#set par(justify: true)
+
+// The `linebreak()` function accidentally generated out-of-order breakpoints
+// for links because it now splits on word boundaries. We avoid the link markup
+// syntax because it's show rule interferes.
+#"http://creativecommons.org/licenses/by-nc-sa/4.0/"
diff --git a/tests/suite/layout/page.typ b/tests/suite/layout/page.typ
index f833af59b..0e1f77295 100644
--- a/tests/suite/layout/page.typ
+++ b/tests/suite/layout/page.typ
@@ -66,7 +66,13 @@
 // Test page fill.
 #set page(width: 80pt, height: 40pt, fill: eastern)
 #text(15pt, font: "Roboto", fill: white, smallcaps[Typst])
-#page(width: 40pt, fill: none, margin: (top: 10pt, rest: auto))[Hi]
+#page(width: 40pt, fill: auto, margin: (top: 10pt, rest: auto))[Hi]
+
+--- page-fill-none ---
+// Test disabling page fill.
+// The PNG is filled with black anyway due to the test runner.
+#set page(fill: none)
+#rect(fill: green)
 
 --- page-margin-uniform ---
 // Set all margins at once.
diff --git a/tests/suite/layout/spacing.typ b/tests/suite/layout/spacing.typ
index c32e6c8f9..f59389956 100644
--- a/tests/suite/layout/spacing.typ
+++ b/tests/suite/layout/spacing.typ
@@ -34,7 +34,7 @@ Totally #h() ignored
   h(1em)
   counter(heading).update(4)
   [Hello ]
-  counter(heading).display()
+  context counter(heading).display()
 }
 
 --- trim-weak-space-line-beginning ---
diff --git a/tests/suite/layout/transform.typ b/tests/suite/layout/transform.typ
index 50a6d417f..3604b72f7 100644
--- a/tests/suite/layout/transform.typ
+++ b/tests/suite/layout/transform.typ
@@ -74,7 +74,7 @@ Hello #rotated[World]!\
 Hello #rotated[World]!
 
 --- transform-scale ---
-// Test that scaling impact layout.
+// Test that scaling impacts layout.
 #set page(width: 200pt)
 #set text(size: 32pt)
 #let scaled(body) = box(scale(
@@ -104,3 +104,14 @@ Hello #scaled[World]!\
 
 #set scale(reflow: true)
 Hello #scaled[World]!
+
+--- transform-scale-abs-and-auto ---
+// Test scaling by absolute lengths and auto.
+#set page(width: 200pt, height: 200pt)
+#let cylinder = image("/assets/images/cylinder.svg")
+
+#cylinder
+#scale(x: 100pt, y: 50pt, reflow: true, cylinder)
+#scale(x: auto, y: 50pt, reflow: true, cylinder)
+#scale(x: 100pt, y: auto, reflow: true, cylinder)
+#scale(x: 150%, y: auto, reflow: true, cylinder)
diff --git a/tests/suite/styling/fold.typ b/tests/suite/styling/fold.typ
index 26fe991b2..4b77f9d52 100644
--- a/tests/suite/styling/fold.typ
+++ b/tests/suite/styling/fold.typ
@@ -12,8 +12,13 @@ fi
 --- fold-vec-order-meta ---
 #let c = counter("mycounter")
 #c.update(1)
+
+// Warning: 1:2-7:3 `locate` with callback function is deprecated
+// Hint: 1:2-7:3 use a `context` expression instead
 #locate(loc => [
   #c.update(2)
   #c.at(loc) \
+  // Warning: 12-36 `locate` with callback function is deprecated
+  // Hint: 12-36 use a `context` expression instead
   Second: #locate(loc => c.at(loc))
 ])
diff --git a/tests/suite/visualize/path.typ b/tests/suite/visualize/path.typ
index bdd3dc726..95f7a803c 100644
--- a/tests/suite/visualize/path.typ
+++ b/tests/suite/visualize/path.typ
@@ -1,10 +1,10 @@
 // Test paths.
 
 --- path ---
-#set page(height: 200pt, width: 200pt)
+#set page(height: 300pt, width: 200pt)
 #table(
   columns: (1fr, 1fr),
-  rows: (1fr, 1fr),
+  rows: (1fr, 1fr, 1fr),
   align: center + horizon,
   path(
     fill: red,
@@ -37,6 +37,26 @@
     (30pt, 30pt),
     (15pt, 0pt),
   ),
+  path(
+    fill: red,
+    fill-rule: "non-zero",
+    closed: true,
+    (25pt, 0pt),
+    (10pt, 50pt),
+    (50pt, 20pt),
+    (0pt, 20pt),
+    (40pt, 50pt),
+  ),
+  path(
+    fill: red,
+    fill-rule: "even-odd",
+    closed: true,
+    (25pt, 0pt),
+    (10pt, 50pt),
+    (50pt, 20pt),
+    (0pt, 20pt),
+    (40pt, 50pt),
+  ),
 )
 
 --- path-bad-vertex ---
diff --git a/tests/suite/visualize/pattern.typ b/tests/suite/visualize/pattern.typ
index 08051ed20..b0c92efaf 100644
--- a/tests/suite/visualize/pattern.typ
+++ b/tests/suite/visualize/pattern.typ
@@ -21,24 +21,30 @@
 --- pattern-relative-self ---
 // Test with relative set to `"self"`
 #let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
+  #set line(stroke: green)
   #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
   #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
 ]
 
 #set page(fill: pat(), width: 100pt, height: 100pt)
-
-#rect(fill: pat(relative: "self"), width: 100%, height: 100%, stroke: 1pt)
+#rect(
+  width: 100%,
+  height: 100%,
+  fill: pat(relative: "self"),
+  stroke: 1pt + green,
+)
 
 --- pattern-relative-parent ---
 // Test with relative set to `"parent"`
-#let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
+#let pat(fill, ..args) = pattern(size: (30pt, 30pt), ..args)[
+  #rect(width: 100%, height: 100%, fill: fill, stroke: none)
   #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
   #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
 ]
 
-#set page(fill: pat(), width: 100pt, height: 100pt)
+#set page(fill: pat(white), width: 100pt, height: 100pt)
 
-#rect(fill: pat(relative: "parent"), width: 100%, height: 100%, stroke: 1pt)
+#rect(fill: pat(none, relative: "parent"), width: 100%, height: 100%, stroke: 1pt)
 
 --- pattern-small ---
 // Tests small patterns for pixel accuracy.
diff --git a/tests/suite/visualize/polygon.typ b/tests/suite/visualize/polygon.typ
index a3f4c8ef1..7d8342c8e 100644
--- a/tests/suite/visualize/polygon.typ
+++ b/tests/suite/visualize/polygon.typ
@@ -27,6 +27,8 @@
 
 // Self-intersections
 #polygon((0pt, 10pt), (30pt, 20pt), (0pt, 30pt), (20pt, 0pt), (20pt, 35pt))
+#polygon(fill-rule: "non-zero", (0pt, 10pt), (30pt, 20pt), (0pt, 30pt), (20pt, 0pt), (20pt, 35pt))
+#polygon(fill-rule: "even-odd", (0pt, 10pt), (30pt, 20pt), (0pt, 30pt), (20pt, 0pt), (20pt, 35pt))
 
 // Regular polygon; should have equal side lengths
 #for k in range(3, 9) {polygon.regular(size: 30pt, vertices: k,)}