Protect Vm

29 files changed, 69 insertions, 69 deletions

diff --git a/library/src/base/calc.rs b/library/src/base/calc.rs
index 355e5c02..db40df06 100644
--- a/library/src/base/calc.rs
+++ b/library/src/base/calc.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use crate::prelude::*;
 
 /// Convert a value to an integer.
-pub fn int(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn int(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Int(match v {
         Value::Bool(v) => v as i64,
@@ -18,7 +18,7 @@ pub fn int(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// Convert a value to a float.
-pub fn float(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn float(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Float(match v {
         Value::Int(v) => v as f64,
@@ -32,7 +32,7 @@ pub fn float(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// The absolute value of a numeric value.
-pub fn abs(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn abs(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect("numeric value")?;
     Ok(match v {
         Value::Int(v) => Value::Int(v.abs()),
@@ -48,12 +48,12 @@ pub fn abs(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// The minimum of a sequence of values.
-pub fn min(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn min(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     minmax(args, Ordering::Less)
 }
 
 /// The maximum of a sequence of values.
-pub fn max(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn max(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     minmax(args, Ordering::Greater)
 }
 
@@ -79,17 +79,17 @@ fn minmax(args: &mut Args, goal: Ordering) -> SourceResult<Value> {
 }
 
 /// Whether an integer is even.
-pub fn even(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn even(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     Ok(Value::Bool(args.expect::<i64>("integer")? % 2 == 0))
 }
 
 /// Whether an integer is odd.
-pub fn odd(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn odd(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     Ok(Value::Bool(args.expect::<i64>("integer")? % 2 != 0))
 }
 
 /// The modulo of two numbers.
-pub fn mod_(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn mod_(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v: v1, span: span1 } = args.expect("integer or float")?;
     let Spanned { v: v2, span: span2 } = args.expect("integer or float")?;
 
@@ -117,7 +117,7 @@ pub fn mod_(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// Create a sequence of numbers.
-pub fn range(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn range(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let first = args.expect::<i64>("end")?;
     let (start, end) = match args.eat::<i64>()? {
         Some(second) => (first, second),
diff --git a/library/src/base/color.rs b/library/src/base/color.rs
index d54911ca..2db41ebf 100644
--- a/library/src/base/color.rs
+++ b/library/src/base/color.rs
@@ -3,13 +3,13 @@ use std::str::FromStr;
 use crate::prelude::*;
 
 /// Create a grayscale color.
-pub fn luma(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn luma(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Component(luma) = args.expect("gray component")?;
     Ok(Value::Color(LumaColor::new(luma).into()))
 }
 
 /// Create an RGB(A) color.
-pub fn rgb(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn rgb(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     Ok(Value::Color(if let Some(string) = args.find::<Spanned<EcoString>>()? {
         match RgbaColor::from_str(&string.v) {
             Ok(color) => color.into(),
@@ -25,7 +25,7 @@ pub fn rgb(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// Create a CMYK color.
-pub fn cmyk(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn cmyk(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let RatioComponent(c) = args.expect("cyan component")?;
     let RatioComponent(m) = args.expect("magenta component")?;
     let RatioComponent(y) = args.expect("yellow component")?;
diff --git a/library/src/base/data.rs b/library/src/base/data.rs
index 67ef2f2c..4f6e3b67 100644
--- a/library/src/base/data.rs
+++ b/library/src/base/data.rs
@@ -5,12 +5,12 @@ use typst::diag::{format_xml_like_error, FileError};
 use crate::prelude::*;
 
 /// Read structured data from a CSV file.
-pub fn csv(vm: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn csv(vm: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v: path, span } =
         args.expect::<Spanned<EcoString>>("path to csv file")?;
 
     let path = vm.locate(&path).at(span)?;
-    let data = vm.world.file(&path).at(span)?;
+    let data = vm.world().file(&path).at(span)?;
 
     let mut builder = csv::ReaderBuilder::new();
     builder.has_headers(false);
@@ -45,12 +45,12 @@ fn format_csv_error(error: csv::Error) -> String {
 }
 
 /// Read structured data from a JSON file.
-pub fn json(vm: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn json(vm: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v: path, span } =
         args.expect::<Spanned<EcoString>>("path to json file")?;
 
     let path = vm.locate(&path).at(span)?;
-    let data = vm.world.file(&path).at(span)?;
+    let data = vm.world().file(&path).at(span)?;
     let value: serde_json::Value =
         serde_json::from_slice(&data).map_err(format_json_error).at(span)?;
 
@@ -85,12 +85,12 @@ fn format_json_error(error: serde_json::Error) -> String {
 }
 
 /// Read structured data from an XML file.
-pub fn xml(vm: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn xml(vm: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v: path, span } =
         args.expect::<Spanned<EcoString>>("path to xml file")?;
 
     let path = vm.locate(&path).at(span)?;
-    let data = vm.world.file(&path).at(span)?;
+    let data = vm.world().file(&path).at(span)?;
     let text = std::str::from_utf8(&data).map_err(FileError::from).at(span)?;
 
     let document = roxmltree::Document::parse(text).map_err(format_xml_error).at(span)?;
diff --git a/library/src/base/mod.rs b/library/src/base/mod.rs
index 837a2f0e..86ebd666 100644
--- a/library/src/base/mod.rs
+++ b/library/src/base/mod.rs
@@ -17,12 +17,12 @@ use typst::syntax::Source;
 use crate::prelude::*;
 
 /// The name of a value's type.
-pub fn type_(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn type_(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     Ok(args.expect::<Value>("value")?.type_name().into())
 }
 
 /// Ensure that a condition is fulfilled.
-pub fn assert(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn assert(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect::<Spanned<bool>>("condition")?;
     if !v {
         bail!(span, "assertion failed");
@@ -31,10 +31,10 @@ pub fn assert(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// Evaluate a string as Typst markup.
-pub fn eval(vm: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn eval(vm: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v: text, span } = args.expect::<Spanned<String>>("source")?;
     let source = Source::synthesized(text, span);
     let route = Route::default();
-    let module = model::eval(vm.world, route.track(), &source)?;
+    let module = model::eval(vm.world(), route.track(), &source)?;
     Ok(Value::Content(module.content))
 }
diff --git a/library/src/base/string.rs b/library/src/base/string.rs
index ed444d35..058ee248 100644
--- a/library/src/base/string.rs
+++ b/library/src/base/string.rs
@@ -3,12 +3,12 @@ use typst::model::Regex;
 use crate::prelude::*;
 
 /// The string representation of a value.
-pub fn repr(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn repr(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     Ok(args.expect::<Value>("value")?.repr().into())
 }
 
 /// Convert a value to a string.
-pub fn str(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn str(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect("value")?;
     Ok(Value::Str(match v {
         Value::Int(v) => format_str!("{}", v),
@@ -19,29 +19,29 @@ pub fn str(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
 }
 
 /// Create blind text.
-pub fn lorem(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn lorem(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let words: usize = args.expect("number of words")?;
     Ok(Value::Str(lipsum::lipsum(words).into()))
 }
 
 /// Create a regular expression.
-pub fn regex(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn regex(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let Spanned { v, span } = args.expect::<Spanned<EcoString>>("regular expression")?;
     Ok(Regex::new(&v).at(span)?.into())
 }
 
 /// Converts an integer into one or multiple letters.
-pub fn letter(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn letter(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     numbered(Numbering::Letter, args)
 }
 
 /// Converts an integer into a roman numeral.
-pub fn roman(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn roman(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     numbered(Numbering::Roman, args)
 }
 
 /// Convert a number into a symbol.
-pub fn symbol(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn symbol(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     numbered(Numbering::Symbol, args)
 }
 
diff --git a/library/src/graphics/hide.rs b/library/src/graphics/hide.rs
index 0fdb8638..f79b31ae 100644
--- a/library/src/graphics/hide.rs
+++ b/library/src/graphics/hide.rs
@@ -6,7 +6,7 @@ pub struct HideNode(pub Content);
 
 #[node(LayoutInline)]
 impl HideNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 }
diff --git a/library/src/graphics/image.rs b/library/src/graphics/image.rs
index 12121257..202abebe 100644
--- a/library/src/graphics/image.rs
+++ b/library/src/graphics/image.rs
@@ -14,12 +14,12 @@ impl ImageNode {
     /// How the image should adjust itself to a given area.
     pub const FIT: ImageFit = ImageFit::Cover;
 
-    fn construct(vm: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(vm: &Vm, args: &mut Args) -> SourceResult<Content> {
         let Spanned { v: path, span } =
             args.expect::<Spanned<EcoString>>("path to image file")?;
 
         let full = vm.locate(&path).at(span)?;
-        let buffer = vm.world.file(&full).at(span)?;
+        let buffer = vm.world().file(&full).at(span)?;
         let ext = full.extension().and_then(OsStr::to_str).unwrap_or_default();
         let format = match ext.to_lowercase().as_str() {
             "png" => ImageFormat::Raster(RasterFormat::Png),
diff --git a/library/src/graphics/line.rs b/library/src/graphics/line.rs
index 112274d2..e7c347b2 100644
--- a/library/src/graphics/line.rs
+++ b/library/src/graphics/line.rs
@@ -15,7 +15,7 @@ impl LineNode {
     #[property(resolve, fold)]
     pub const STROKE: PartialStroke = PartialStroke::default();
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let origin = args.named("origin")?.unwrap_or_default();
 
         let delta = match args.named::<Axes<Rel<Length>>>("to")? {
diff --git a/library/src/graphics/shape.rs b/library/src/graphics/shape.rs
index d484b993..ebdc1717 100644
--- a/library/src/graphics/shape.rs
+++ b/library/src/graphics/shape.rs
@@ -38,7 +38,7 @@ impl<const S: ShapeKind> ShapeNode<S> {
     #[property(skip, resolve, fold)]
     pub const RADIUS: Corners<Option<Rel<Length>>> = Corners::splat(Rel::zero());
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let size = match S {
             SQUARE => args.named::<Length>("size")?.map(Rel::from),
             CIRCLE => args.named::<Length>("radius")?.map(|r| 2.0 * Rel::from(r)),
diff --git a/library/src/layout/align.rs b/library/src/layout/align.rs
index 5e1b3555..6337c941 100644
--- a/library/src/layout/align.rs
+++ b/library/src/layout/align.rs
@@ -12,7 +12,7 @@ pub struct AlignNode {
 
 #[node(LayoutBlock)]
 impl AlignNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let aligns: Axes<Option<GenAlign>> = args.find()?.unwrap_or_default();
         let body: Content = args.expect("body")?;
 
diff --git a/library/src/layout/columns.rs b/library/src/layout/columns.rs
index c5a340ee..6e1aaeae 100644
--- a/library/src/layout/columns.rs
+++ b/library/src/layout/columns.rs
@@ -17,7 +17,7 @@ impl ColumnsNode {
     #[property(resolve)]
     pub const GUTTER: Rel<Length> = Ratio::new(0.04).into();
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self {
             columns: args.expect("column count")?,
             child: args.expect("body")?,
@@ -106,7 +106,7 @@ pub struct ColbreakNode {
 
 #[node(Behave)]
 impl ColbreakNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let weak = args.named("weak")?.unwrap_or(false);
         Ok(Self { weak }.pack())
     }
diff --git a/library/src/layout/container.rs b/library/src/layout/container.rs
index 408f6720..9a6ccb9f 100644
--- a/library/src/layout/container.rs
+++ b/library/src/layout/container.rs
@@ -12,7 +12,7 @@ pub struct BoxNode {
 
 #[node(LayoutInline)]
 impl BoxNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let width = args.named("width")?;
         let height = args.named("height")?;
         let body = args.eat::<Content>()?.unwrap_or_default();
@@ -70,7 +70,7 @@ impl BlockNode {
     #[property(skip)]
     pub const BELOW: VNode = VNode::block_spacing(Em::new(1.2).into());
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.eat()?.unwrap_or_default()).pack())
     }
 
diff --git a/library/src/layout/grid.rs b/library/src/layout/grid.rs
index 7f58090b..3b5afcc5 100644
--- a/library/src/layout/grid.rs
+++ b/library/src/layout/grid.rs
@@ -15,7 +15,7 @@ pub struct GridNode {
 
 #[node(LayoutBlock)]
 impl GridNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let TrackSizings(columns) = args.named("columns")?.unwrap_or_default();
         let TrackSizings(rows) = args.named("rows")?.unwrap_or_default();
         let TrackSizings(base_gutter) = args.named("gutter")?.unwrap_or_default();
diff --git a/library/src/layout/pad.rs b/library/src/layout/pad.rs
index 318d9f27..d860e54d 100644
--- a/library/src/layout/pad.rs
+++ b/library/src/layout/pad.rs
@@ -11,7 +11,7 @@ pub struct PadNode {
 
 #[node(LayoutBlock)]
 impl PadNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let all = args.named("rest")?.or(args.find()?);
         let x = args.named("x")?;
         let y = args.named("y")?;
diff --git a/library/src/layout/page.rs b/library/src/layout/page.rs
index 3901740c..f3249347 100644
--- a/library/src/layout/page.rs
+++ b/library/src/layout/page.rs
@@ -41,7 +41,7 @@ impl PageNode {
     #[property(referenced)]
     pub const FOREGROUND: Marginal = Marginal::None;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 
@@ -150,7 +150,7 @@ pub struct PagebreakNode {
 
 #[node]
 impl PagebreakNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let weak = args.named("weak")?.unwrap_or(false);
         Ok(Self { weak }.pack())
     }
diff --git a/library/src/layout/place.rs b/library/src/layout/place.rs
index a4f05a6c..221e9008 100644
--- a/library/src/layout/place.rs
+++ b/library/src/layout/place.rs
@@ -7,7 +7,7 @@ pub struct PlaceNode(pub Content);
 
 #[node(LayoutBlock, Behave)]
 impl PlaceNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let aligns = args.find()?.unwrap_or(Axes::with_x(Some(GenAlign::Start)));
         let dx = args.named("dx")?.unwrap_or_default();
         let dy = args.named("dy")?.unwrap_or_default();
diff --git a/library/src/layout/spacing.rs b/library/src/layout/spacing.rs
index b42f90ef..f5c39af4 100644
--- a/library/src/layout/spacing.rs
+++ b/library/src/layout/spacing.rs
@@ -13,7 +13,7 @@ pub struct HNode {
 
 #[node(Behave)]
 impl HNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let amount = args.expect("spacing")?;
         let weak = args.named("weak")?.unwrap_or(false);
         Ok(Self { amount, weak }.pack())
@@ -60,7 +60,7 @@ pub struct VNode {
 
 #[node(Behave)]
 impl VNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let amount = args.expect("spacing")?;
         let node = if args.named("weak")?.unwrap_or(false) {
             Self::weak(amount)
diff --git a/library/src/layout/stack.rs b/library/src/layout/stack.rs
index 12a1c384..52de2c48 100644
--- a/library/src/layout/stack.rs
+++ b/library/src/layout/stack.rs
@@ -17,7 +17,7 @@ pub struct StackNode {
 
 #[node(LayoutBlock)]
 impl StackNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self {
             dir: args.named("dir")?.unwrap_or(Dir::TTB),
             spacing: args.named("spacing")?,
diff --git a/library/src/layout/transform.rs b/library/src/layout/transform.rs
index c45aa165..bee38cb4 100644
--- a/library/src/layout/transform.rs
+++ b/library/src/layout/transform.rs
@@ -13,7 +13,7 @@ pub struct MoveNode {
 
 #[node(LayoutInline)]
 impl MoveNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let dx = args.named("dx")?.unwrap_or_default();
         let dy = args.named("dy")?.unwrap_or_default();
         Ok(Self {
@@ -60,7 +60,7 @@ impl<const T: TransformKind> TransformNode<T> {
     #[property(resolve)]
     pub const ORIGIN: Axes<Option<GenAlign>> = Axes::default();
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let transform = match T {
             ROTATE => {
                 let angle = args.named_or_find("angle")?.unwrap_or_default();
diff --git a/library/src/structure/heading.rs b/library/src/structure/heading.rs
index d99e2db8..cf732a4e 100644
--- a/library/src/structure/heading.rs
+++ b/library/src/structure/heading.rs
@@ -16,7 +16,7 @@ pub struct HeadingNode {
 
 #[node(Show, Finalize)]
 impl HeadingNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self {
             body: args.expect("body")?,
             level: args.named("level")?.unwrap_or(NonZeroUsize::new(1).unwrap()),
diff --git a/library/src/structure/list.rs b/library/src/structure/list.rs
index 2a3f3035..222dcbcf 100644
--- a/library/src/structure/list.rs
+++ b/library/src/structure/list.rs
@@ -38,7 +38,7 @@ impl<const L: ListKind> ListNode<L> {
     /// The spacing between the items of a wide (non-tight) list.
     pub const SPACING: Smart<Spacing> = Smart::Auto;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let items = match L {
             LIST => args
                 .all()?
diff --git a/library/src/structure/reference.rs b/library/src/structure/reference.rs
index 4f672707..361f8c25 100644
--- a/library/src/structure/reference.rs
+++ b/library/src/structure/reference.rs
@@ -7,7 +7,7 @@ pub struct RefNode(pub EcoString);
 
 #[node(Show)]
 impl RefNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("target")?).pack())
     }
 
diff --git a/library/src/structure/table.rs b/library/src/structure/table.rs
index eaadc3a1..54413b63 100644
--- a/library/src/structure/table.rs
+++ b/library/src/structure/table.rs
@@ -23,7 +23,7 @@ impl TableNode {
     /// How much to pad the cells's content.
     pub const PADDING: Rel<Length> = Abs::pt(5.0).into();
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let TrackSizings(columns) = args.named("columns")?.unwrap_or_default();
         let TrackSizings(rows) = args.named("rows")?.unwrap_or_default();
         let TrackSizings(base_gutter) = args.named("gutter")?.unwrap_or_default();
diff --git a/library/src/text/deco.rs b/library/src/text/deco.rs
index 7db7fa1b..3357f76c 100644
--- a/library/src/text/deco.rs
+++ b/library/src/text/deco.rs
@@ -34,7 +34,7 @@ impl<const L: DecoLine> DecoNode<L> {
     /// with the glyphs. Does not apply to strikethrough.
     pub const EVADE: bool = true;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 
diff --git a/library/src/text/link.rs b/library/src/text/link.rs
index fd7aec8a..f682eea9 100644
--- a/library/src/text/link.rs
+++ b/library/src/text/link.rs
@@ -29,7 +29,7 @@ impl LinkNode {
     #[property(skip, referenced)]
     pub(crate) const DEST: Option<Destination> = None;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let dest = args.expect::<Destination>("destination")?;
         Ok(match dest {
             Destination::Url(url) => match args.eat()? {
diff --git a/library/src/text/mod.rs b/library/src/text/mod.rs
index 45808310..81343210 100644
--- a/library/src/text/mod.rs
+++ b/library/src/text/mod.rs
@@ -128,7 +128,7 @@ impl TextNode {
     #[property(skip, fold)]
     const DECO: Decoration = vec![];
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         // The text constructor is special: It doesn't create a text node.
         // Instead, it leaves the passed argument structurally unchanged, but
         // styles all text in it.
@@ -416,7 +416,7 @@ pub struct SpaceNode;
 
 #[node(Unlabellable, Behave)]
 impl SpaceNode {
-    fn construct(_: &mut Vm, _: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, _: &mut Args) -> SourceResult<Content> {
         Ok(Self.pack())
     }
 }
@@ -437,7 +437,7 @@ pub struct LinebreakNode {
 
 #[node(Behave)]
 impl LinebreakNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let justify = args.named("justify")?.unwrap_or(false);
         Ok(Self { justify }.pack())
     }
@@ -457,19 +457,19 @@ pub struct SmartQuoteNode {
 
 #[node]
 impl SmartQuoteNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         let double = args.named("double")?.unwrap_or(true);
         Ok(Self { double }.pack())
     }
 }
 
 /// Convert a string or content to lowercase.
-pub fn lower(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn lower(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     case(Case::Lower, args)
 }
 
 /// Convert a string or content to uppercase.
-pub fn upper(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn upper(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     case(Case::Upper, args)
 }
 
@@ -503,7 +503,7 @@ impl Case {
 }
 
 /// Display text in small capitals.
-pub fn smallcaps(_: &mut Vm, args: &mut Args) -> SourceResult<Value> {
+pub fn smallcaps(_: &Vm, args: &mut Args) -> SourceResult<Value> {
     let body: Content = args.expect("content")?;
     Ok(Value::Content(body.styled(TextNode::SMALLCAPS, true)))
 }
@@ -514,7 +514,7 @@ pub struct StrongNode(pub Content);
 
 #[node(Show)]
 impl StrongNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 
@@ -538,7 +538,7 @@ pub struct EmphNode(pub Content);
 
 #[node(Show)]
 impl EmphNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 
diff --git a/library/src/text/par.rs b/library/src/text/par.rs
index 196878f8..1dd6a42c 100644
--- a/library/src/text/par.rs
+++ b/library/src/text/par.rs
@@ -31,7 +31,7 @@ impl ParNode {
     /// How to determine line breaks.
     pub const LINEBREAKS: Smart<Linebreaks> = Smart::Auto;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         // The paragraph constructor is special: It doesn't create a paragraph
         // node. Instead, it just ensures that the passed content lives is in a
         // separate paragraph and styles it.
@@ -119,7 +119,7 @@ pub struct ParbreakNode;
 
 #[node(Unlabellable)]
 impl ParbreakNode {
-    fn construct(_: &mut Vm, _: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, _: &mut Args) -> SourceResult<Content> {
         Ok(Self.pack())
     }
 }
@@ -132,7 +132,7 @@ pub struct RepeatNode(pub Content);
 
 #[node(LayoutInline)]
 impl RepeatNode {
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }
 }
diff --git a/library/src/text/raw.rs b/library/src/text/raw.rs
index 101f527c..e47875dc 100644
--- a/library/src/text/raw.rs
+++ b/library/src/text/raw.rs
@@ -25,7 +25,7 @@ impl RawNode {
     #[property(referenced)]
     pub const LANG: Option<EcoString> = None;
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self {
             text: args.expect("text")?,
             block: args.named("block")?.unwrap_or(false),
diff --git a/library/src/text/shift.rs b/library/src/text/shift.rs
index e63211c6..b05f68b7 100644
--- a/library/src/text/shift.rs
+++ b/library/src/text/shift.rs
@@ -30,7 +30,7 @@ impl<const S: ShiftKind> ShiftNode<S> {
     /// The font size for synthetic sub- and superscripts.
     pub const SIZE: TextSize = TextSize(Em::new(0.6).into());
 
-    fn construct(_: &mut Vm, args: &mut Args) -> SourceResult<Content> {
+    fn construct(_: &Vm, args: &mut Args) -> SourceResult<Content> {
         Ok(Self(args.expect("body")?).pack())
     }