typst 0.14.2.3 → 0.15.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdc56381647f2be411648ebbf5525576c5c6a259257cafd29de225dbd50da25c
-  data.tar.gz: 414023a808e3081a46e5e3ca64aa44920aedc41bbeca7c7004557e2a76b682f9
+  metadata.gz: 0a438a6f795f22c5957eeaefbde3b825e7bf8e8634d75bc402de95321bc0e28d
+  data.tar.gz: 192a0dafec2d0b226674eabda64cc71926cc491444f2c2f391a868936c68f044
 SHA512:
-  metadata.gz: bf751aa8cfe5c0cb9f7433728f61ef1882af9fdea3b0aa031fa87e906a6be1880b1832a74597871911751fc912fb93f2f8946d4b8fd022c175828865d428938c
-  data.tar.gz: 62d507c32cdd32be9cf125350953a57971968e5aff1b43604d506e640901a327b940ab51c5becb6e4890ce1c8f656c4adb0a8bae19e1b3b217a6d82c8cddfb80
+  metadata.gz: 2df9d3457d9e2293132e1b528c646c74f00974cc27cb1d3d35801fc8989ee9d9c5fe1b83a615cc245a8ca3f04349f356d385d1dd653b6dba8d4d5ac77ab285ee
+  data.tar.gz: 447e18da8b0678394bcde2f5ef6fe25235e8d4d3c9e484375944a0f1054786739dec77bcce2291a252360dc284d40062dcac4dcd2de94e73fa4f190741887401

data/ext/typst/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "typst"
-version = "0.14.2"
+version = "0.15.0"
 edition = "2021"
 
 [lib]
@@ -12,7 +12,7 @@ chrono = { version = "0.4.42", default-features = false, features = [
     "std",
 ] }
 codespan-reporting = "0.13"
-comemo = "0.5.0"
+comemo = "0.5.1"
 dirs = "5" #
 ecow = "0.2"
 env_logger = "0.10.1" #
@@ -29,18 +29,21 @@ tar = "0.4" #
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
-typst = "0.14.2"
-typst-library  = "0.14.2"
-typst-kit = { version = "0.14.2", features = [
-    "downloads",
-    "embed-fonts",
+typst = "0.15.0"
+typst-library  = "0.15.0"
+typst-kit = { version = "0.15.0", features = [
+    "embedded-fonts",
+    "scan-fonts",
+    "system-downloader",
+    "system-packages",
     "vendor-openssl",
 ] }
-typst-pdf = "0.14.2"
-typst-svg = "0.14.2"
-typst-html = "0.14.2"
-typst-render = "0.14.2"
-typst-eval = "0.14.2"
+typst-pdf = "0.15.0"
+typst-svg = "0.15.0"
+typst-html = "0.15.0"
+typst-render = "0.15.0"
+typst-eval = "0.15.0"
+typst-layout = "0.15.0"
 ureq = { version = "2", default-features = false, features = [
     "gzip",
     "socks-proxy",
@@ -49,4 +52,4 @@ walkdir = "2.4.0"
 
 # enable rb-sys feature to test against Ruby head. This is only needed if you
 # want to work with the unreleased, in-development, next version of Ruby
-rb-sys = { version = "0.9.124", default-features = false, features = ["stable-api-compiled-fallback"] }
+rb-sys = { version = "0.9.128", default-features = false, features = ["stable-api-compiled-fallback"] }

data/ext/typst/src/compiler.rs

@@ -2,11 +2,11 @@ use chrono::{Datelike, Timelike};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::term::{self, termcolor};
 use ecow::{eco_format, EcoString};
-use typst::diag::{Severity, SourceDiagnostic, StrResult, Warned};
+use typst::diag::{At, Severity, SourceDiagnostic, StrResult, Warned};
 use typst::foundations::Datetime;
 use typst_html::HtmlDocument;
-use typst::layout::PagedDocument;
-use typst::syntax::{FileId, Lines, Span};
+use typst_layout::PagedDocument;
+use typst::syntax::{DiagSpan, FileId, Lines, Span};
 use typst::{World, WorldExt};
 
 use crate::world::SystemWorld;
@@ -45,7 +45,9 @@ impl SystemWorld {
                             "pdf" => Ok(vec![export_pdf(
                                 &document,
                                 self,
-                                typst_pdf::PdfStandards::new(pdf_standards)?,
+                                typst_pdf::PdfStandards::new(pdf_standards)
+                                    .map_err(|e| eco_format!("PDF standards error: {:?}", e))
+                                    .at(Span::detached()).unwrap()
                             )?]),
                             "png" => Ok(export_image(&document, ImageExportFormat::Png, ppi)?),
                             "svg" => Ok(export_image(&document, ImageExportFormat::Svg, ppi)?),
@@ -65,7 +67,7 @@ fn export_html(
     document: &HtmlDocument,
     world: &SystemWorld,
 ) -> StrResult<Vec<u8>> {
-    let html = typst_html::html(document)
+    let html = typst_html::html(document, &typst_html::HtmlOptions::default())
     .map_err(|e| match format_diagnostics(world, &e, &[]) {
         Ok(e) => EcoString::from(e),
         Err(err) => eco_format!("failed to print diagnostics ({err})"),
@@ -81,11 +83,10 @@ fn export_pdf(
     world: &SystemWorld,
     standards: typst_pdf::PdfStandards,
 ) -> StrResult<Vec<u8>> {
-    let ident = world.input().to_string_lossy();
     let buffer = typst_pdf::pdf(
         document,
         &typst_pdf::PdfOptions {
-            ident: typst::foundations::Smart::Custom(&ident),
+            ident: typst::foundations::Smart::Auto,
             timestamp: now().map(typst_pdf::Timestamp::new_utc),
             standards,
             ..Default::default()
@@ -95,7 +96,7 @@ fn export_pdf(
         Ok(e) => EcoString::from(e),
         Err(err) => eco_format!("failed to print diagnostics ({err})"),
     })?;
-    Ok(buffer)
+    Ok(buffer.into())
 }
 
 /// Get the current date and time in UTC.
@@ -124,13 +125,19 @@ fn export_image(
     ppi: Option<f32>,
 ) -> StrResult<Vec<Vec<u8>>> {
     let mut buffers = Vec::new();
-    for page in &document.pages {
+    for page in document.pages() {
         let buffer = match fmt {
-            ImageExportFormat::Png => typst_render::render(page, ppi.unwrap_or(144.0) / 72.0)
-                .encode_png()
-                .map_err(|err| eco_format!("failed to write PNG file ({err})"))?,
+            ImageExportFormat::Png => typst_render::render(
+                page,
+                &typst_render::RenderOptions {
+                    pixel_per_pt: typst::utils::Scalar::new(f64::from(ppi.unwrap_or(144.0) / 72.0)),
+                    render_bleed: false,
+                },
+            )
+            .encode_png()
+            .map_err(|err| eco_format!("failed to write PNG file ({err})"))?,
             ImageExportFormat::Svg => {
-                let svg = typst_svg::svg(page);
+                let svg = typst_svg::svg(page, &typst_svg::SvgOptions::default());
                 svg.as_bytes().to_vec()
             }
         };
@@ -162,7 +169,7 @@ pub fn format_diagnostics(
             diagnostic
                 .hints
                 .iter()
-                .map(|e| (eco_format!("hint: {e}")).into())
+                .map(|e| (eco_format!("hint: {}", e.v)).into())
                 .collect(),
         )
         .with_labels(label(world, diagnostic.span).into_iter().collect());
@@ -185,7 +192,8 @@ pub fn format_diagnostics(
 }
 
 /// Create a label for a span.
-fn label(world: &SystemWorld, span: Span) -> Option<Label<FileId>> {
+fn label(world: &SystemWorld, span: impl Into<DiagSpan>) -> Option<Label<FileId>> {
+    let span = span.into();
     Some(Label::primary(span.id()?, world.range(span)?))
 }
 
@@ -196,15 +204,16 @@ impl<'a> codespan_reporting::files::Files<'a> for SystemWorld {
 
     fn name(&'a self, id: FileId) -> CodespanResult<Self::Name> {
         let vpath = id.vpath();
-        Ok(if let Some(package) = id.package() {
-            format!("{package}{}", vpath.as_rooted_path().display())
+        Ok(if let typst::syntax::VirtualRoot::Package(package) = id.root() {
+            format!("{package}{}", vpath.get_with_slash())
         } else {
             // Try to express the path relative to the working directory.
             vpath
-                .resolve(self.root())
+                .realize(self.root())
+                .ok()
                 .and_then(|abs| pathdiff::diff_paths(abs, self.workdir()))
                 .as_deref()
-                .unwrap_or_else(|| vpath.as_rootless_path())
+                .unwrap_or_else(|| std::path::Path::new(vpath.get_without_slash()))
                 .to_string_lossy()
                 .into()
         })

data/ext/typst/src/download.rs

@@ -1,19 +1,7 @@
-use std::fmt::Display;
-
-use typst_kit::download::{DownloadState, Downloader, Progress};
-
-pub struct SlientDownload<T>(pub T);
-
-impl<T: Display> Progress for SlientDownload<T> {
-    fn print_start(&mut self) {}
-
-    fn print_progress(&mut self, _state: &DownloadState) {}
-
-    fn print_finish(&mut self, _state: &DownloadState) {}
-}
+use typst_kit::downloader::{Downloader, SystemDownloader};
 
 /// Returns a new downloader.
-pub fn downloader() -> Downloader {
+pub fn downloader() -> impl Downloader {
     let user_agent = concat!("typst-rb/", env!("CARGO_PKG_VERSION"));
-    Downloader::new(user_agent)
+    SystemDownloader::new(user_agent)
 }

data/ext/typst/src/lib.rs

@@ -19,8 +19,8 @@ fn to_html(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
     let input = input.canonicalize()
@@ -35,22 +35,6 @@ fn to_html(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut features = Vec::new();
     features.push(Feature::Html);
 
@@ -72,6 +56,7 @@ fn to_html(
         .features(feat)
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -87,8 +72,8 @@ fn to_svg(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
     let input = input.canonicalize()
@@ -103,22 +88,6 @@ fn to_svg(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -127,6 +96,7 @@ fn to_svg(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -142,8 +112,8 @@ fn to_png(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
     ppi: Option<f32>,
 ) -> Result<Vec<Vec<u8>>, Error> {
@@ -159,22 +129,6 @@ fn to_png(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -183,6 +137,7 @@ fn to_png(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -198,8 +153,8 @@ fn to_pdf(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
 ) -> Result<Vec<Vec<u8>>, Error> {
@@ -215,22 +170,6 @@ fn to_pdf(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
         .inputs(Dict::from_iter(
             sys_inputs
@@ -239,6 +178,7 @@ fn to_pdf(
         ))
         .font_paths(font_paths)
         .ignore_system_fonts(ignore_system_fonts)
+        .ignore_embedded_fonts(ignore_embedded_fonts)
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
@@ -287,8 +227,8 @@ fn query(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
-    resource_path: PathBuf,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<String, Error> {
     let format = match format.unwrap().to_ascii_lowercase().as_str() {
@@ -309,22 +249,6 @@ fn query(
         PathBuf::new()
     };
 
-    let resource_path = resource_path.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
-
-    let mut default_fonts = Vec::new();
-    for entry in walkdir::WalkDir::new(resource_path.join("fonts")) {
-        let path = entry
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
-            .into_path();
-        let Some(extension) = path.extension() else {
-            continue;
-        };
-        if extension == "ttf" || extension == "otf" {
-            default_fonts.push(path);
-        }
-    }
-
     let mut world = SystemWorld::builder(root, input)
     .inputs(Dict::from_iter(
         sys_inputs
@@ -333,6 +257,7 @@ fn query(
     ))
     .font_paths(font_paths)
     .ignore_system_fonts(ignore_system_fonts)
+    .ignore_embedded_fonts(ignore_embedded_fonts)
     .build()
     .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 

data/ext/typst/src/query.rs

@@ -3,8 +3,10 @@ use ecow::{eco_format, EcoString};
 use serde::Serialize;
 use typst::diag::{bail, StrResult, Warned};
 use typst::engine::Sink;
-use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
-use typst::layout::PagedDocument;
+use typst::foundations::{Content, Context, IntoValue, LocatableSelector, Scope};
+use typst::introspection::{EmptyIntrospector, Introspector};
+use typst::routines::SpanMode;
+use typst_layout::PagedDocument;
 use typst::syntax::Span;
 use typst::syntax::SyntaxMode;
 use typst::World;
@@ -73,13 +75,15 @@ fn retrieve(
     document: &PagedDocument,
 ) -> StrResult<Vec<Content>> {
     let selector = eval_string(
-        &typst::ROUTINES,
         world.track(),
+        world.library(),
         Sink::new().track_mut(),
+        EmptyIntrospector.track(),
+        Context::none().track(),
         &command.selector,
-        Span::detached(),
+        SpanMode::Uniform(Span::detached()),
         SyntaxMode::Code,
-        Scope::default(),
+        Scope::default()
     )
     .map_err(|errors| {
         let mut message = EcoString::from("failed to evaluate selector");
@@ -93,7 +97,7 @@ fn retrieve(
     .map_err(|e| e.message().clone())?;
 
     Ok(document
-        .introspector
+        .introspector()
         .query(&selector.0)
         .into_iter()
         .collect::<Vec<_>>())

data/ext/typst/src/world.rs

@@ -1,44 +1,34 @@
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::sync::{Mutex, OnceLock};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::collections::HashMap;
 
-use chrono::{DateTime, Datelike, Local};
-use ecow::eco_format;
+use chrono::{DateTime, Datelike, FixedOffset, Local};
 use typst::diag::{FileError, FileResult, StrResult};
-use typst::foundations::{Bytes, Datetime, Dict};
-use typst::syntax::{FileId, Lines, Source, VirtualPath};
+use typst::foundations::{Bytes, Datetime, Dict, Duration};
+use typst::syntax::{FileId, Lines, Source, VirtualPath, VirtualRoot, RootedPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
 use typst::{Features, Library, LibraryExt, World};
-use typst_kit::{
-    fonts::{FontSearcher, FontSlot},
-    package::PackageStorage,
-};
-
-use std::collections::HashMap;
-
-use crate::download::SlientDownload;
+use typst_kit::fonts::{self, FontStore};
+use typst_kit::packages::{FsPackages, SystemPackages, UniversePackages};
 
 /// A world that provides access to the operating system.
 pub struct SystemWorld {
     /// The working directory.
     workdir: Option<PathBuf>,
-    /// The canonical path to the input file.
-    input: PathBuf,
     /// The root relative to which absolute paths are resolved.
     root: PathBuf,
     /// The input path.
     main: FileId,
     /// Typst's standard library.
     library: LazyHash<Library>,
-    /// Metadata about discovered fonts.
-    book: LazyHash<FontBook>,
     /// Locations of and storage for lazily loaded fonts.
-    fonts: Vec<FontSlot>,
+    fonts: Arc<FontStore>,
     /// Maps file ids to source files and buffers.
     slots: Mutex<HashMap<FileId, FileSlot>>,
     /// Holds information about where packages are stored.
-    package_storage: PackageStorage,
+    package_storage: SystemPackages,
     /// The current datetime if requested. This is stored here to ensure it is
     /// always the same within one compilation. Reset between compilations.
     now: OnceLock<DateTime<Local>>,
@@ -50,7 +40,7 @@ impl World for SystemWorld {
     }
 
     fn book(&self) -> &LazyHash<FontBook> {
-        &self.book
+        &self.fonts.book()
     }
 
     fn main(&self) -> FileId {
@@ -66,21 +56,30 @@ impl World for SystemWorld {
     }
 
     fn font(&self, index: usize) -> Option<Font> {
-        self.fonts[index].get()
+        self.fonts.font(index)
     }
 
-    fn today(&self, offset: Option<i64>) -> Option<Datetime> {
+    fn today(&self, offset: Option<Duration>) -> Option<Datetime> {
         let now = self.now.get_or_init(chrono::Local::now);
 
-        let naive = match offset {
-            None => now.naive_local(),
-            Some(o) => now.naive_utc() + chrono::Duration::hours(o),
+        let now = match offset {
+            None => now.fixed_offset(),
+            Some(offset) => {
+                let seconds = offset.seconds().trunc();
+                if !seconds.is_finite()
+                    || seconds < f64::from(i32::MIN)
+                    || seconds > f64::from(i32::MAX)
+                {
+                    return None;
+                }
+                now.with_timezone(&FixedOffset::east_opt(seconds as i32)?)
+            }
         };
 
         Datetime::from_ymd(
-            naive.year(),
-            naive.month().try_into().ok()?,
-            naive.day().try_into().ok()?,
+            now.year(),
+            now.month().try_into().ok()?,
+            now.day().try_into().ok()?,
         )
     }
 }
@@ -122,23 +121,20 @@ impl SystemWorld {
         self.now.take();
     }
 
-    /// Return the canonical path to the input file.
-    pub fn input(&self) -> &PathBuf {
-        &self.input
-    }
-
     /// Lookup a source file by id.
     #[track_caller]
     pub fn lookup(&self, id: FileId) -> Lines<String> {
-//        self.source(id)
-//            .expect("file id does not point to any source file")
         self.slot(id, |slot| {
             if let Some(source) = slot.source.get() {
                 let source = source.as_ref().expect("file is not valid");
                 source.lines().clone()
             } else if let Some(bytes) = slot.file.get() {
                 let bytes = bytes.as_ref().expect("file is not valid");
-                Lines::try_from(bytes).expect("file is not valid utf-8")
+                Lines::new(
+                    decode_utf8(bytes.as_slice())
+                        .expect("file is not valid utf-8")
+                        .to_string(),
+                )
             } else {
                 panic!("file id does not point to any source file");
             }
@@ -151,8 +147,11 @@ pub struct SystemWorldBuilder {
     main: PathBuf,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
     inputs: Dict,
     features: Features,
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
 }
 
 impl SystemWorldBuilder {
@@ -162,8 +161,11 @@ impl SystemWorldBuilder {
             main,
             font_paths: Vec::new(),
             ignore_system_fonts: false,
+            ignore_embedded_fonts: false,
             inputs: Dict::default(),
             features: Features::default(),
+            package_path: None,
+            package_cache_path: None,
         }
     }
 
@@ -177,6 +179,11 @@ impl SystemWorldBuilder {
         self
     }
 
+    pub fn ignore_embedded_fonts(mut self, ignore: bool) -> Self {
+        self.ignore_embedded_fonts = ignore;
+        self
+    }
+
     pub fn inputs(mut self, inputs: Dict) -> Self {
         self.inputs = inputs;
         self
@@ -188,33 +195,57 @@ impl SystemWorldBuilder {
     }
 
     pub fn build(self) -> StrResult<SystemWorld> {
-        let fonts = FontSearcher::new()
-            .include_system_fonts(!self.ignore_system_fonts)
-            .search_with(&self.font_paths);
+        let fonts = Arc::new(build_font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths));
+
+        let package_storage = system_packages(self.package_path, self.package_cache_path);
 
-        let input = self.main.canonicalize().map_err(|_| {
-            eco_format!("input file not found (searched at {})", self.main.display())
-        })?;
         // Resolve the virtual path of the main file within the project root.
-        let main_path = VirtualPath::within_root(&self.main, &self.root)
-            .ok_or("input file must be contained in project root")?;
+        let main_path = VirtualPath::virtualize(&self.root, &self.main)
+            .map_err(|_| "input file must be contained in project root")?;
 
         let world = SystemWorld {
             workdir: std::env::current_dir().ok(),
-            input,
             root: self.root,
-            main: FileId::new(None, main_path),
+            main: RootedPath::new(VirtualRoot::Project, main_path).intern(),
             library: LazyHash::new(Library::builder().with_inputs(self.inputs).with_features(self.features).build()),
-            book: LazyHash::new(fonts.book),
-            fonts: fonts.fonts,
+            fonts,
             slots: Mutex::default(),
-            package_storage: PackageStorage::new(None, None, crate::download::downloader()),
+            package_storage,
             now: OnceLock::new(),
         };
         Ok(world)
     }
 }
 
+fn build_font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> FontStore {
+    let mut fonts = FontStore::new();
+    if !ignore_system_fonts {
+        fonts.extend(fonts::system());
+    }
+    if !ignore_embedded_fonts {
+        fonts.extend(fonts::embedded());
+    }
+    for path in font_paths {
+        fonts.extend(fonts::scan(&path));
+    }
+    fonts
+}
+
+fn system_packages(
+    package_path: Option<PathBuf>,
+    package_cache_path: Option<PathBuf>,
+) -> SystemPackages {
+    SystemPackages::from_parts(
+        package_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_data),
+        package_cache_path
+            .map(FsPackages::new)
+            .or_else(FsPackages::system_cache),
+        UniversePackages::new(crate::download::downloader()),
+    )
+}
+
 /// Holds canonical data for all paths pointing to the same entity.
 ///
 /// Both fields can be populated if the file is both imported and read().
@@ -244,7 +275,7 @@ impl FileSlot {
         self.file.reset();
     }
 
-    fn source(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Source> {
+    fn source(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Source> {
         let id = self.id;
         self.source.get_or_init(
             || system_path(root, id, package_storage),
@@ -260,7 +291,7 @@ impl FileSlot {
         )
     }
 
-    fn file(&mut self, root: &Path, package_storage: &PackageStorage) -> FileResult<Bytes> {
+    fn file(&mut self, root: &Path, package_storage: &SystemPackages) -> FileResult<Bytes> {
         let id = self.id;
         self.file.get_or_init(
             || system_path(root, id, package_storage),
@@ -270,19 +301,21 @@ impl FileSlot {
 }
 
 /// The path of the slot on the system.
-fn system_path(root: &Path, id: FileId, package_storage: &PackageStorage) -> FileResult<PathBuf> {
+fn system_path(root: &Path, id: FileId, package_storage: &SystemPackages) -> FileResult<PathBuf> {
     // Determine the root path relative to which the file path
     // will be resolved.
-    let buf;
-    let mut root = root;
-    if let Some(spec) = id.package() {
-        buf = package_storage.prepare_package(spec, &mut SlientDownload(&spec))?;
-        root = &buf;
-    }
+    let package_root;
+    let root = match id.root() {
+        VirtualRoot::Project => root,
+        VirtualRoot::Package(spec) => {
+            package_root = package_storage.obtain(spec)?;
+            package_root.path()
+        }
+    };
 
     // Join the path to the root. If it tries to escape, deny
     // access. Note: It can still escape via symlinks.
-    id.vpath().resolve(root).ok_or(FileError::AccessDenied)
+    id.vpath().realize(root).map_err(Into::into)
 }
 
 /// Lazily processes data for a file.

data/lib/base.rb

@@ -34,14 +34,14 @@ module Typst
       options[:dependencies] ||= {}
       options[:fonts] ||= {}
       options[:sys_inputs] ||= {}
-      options[:resource_path] ||= File.dirname(__FILE__)
       options[:ignore_system_fonts] ||= false
+      options[:ignore_embedded_fonts] ||= false
     
       self.options = options
     end
 
     def typst_args
-      [options[:file], options[:root], options[:font_paths], options[:resource_path], options[:ignore_system_fonts], options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
+      [options[:file], options[:root], options[:font_paths], options[:ignore_system_fonts], options[:ignore_embedded_fonts], options[:sys_inputs].map{ |k,v| [k.to_s,v.to_s] }.to_h]
     end
 
     def typst_pdf_args
@@ -125,14 +125,14 @@ module Typst
       query_options = { field: field, one: one, format: format }
 
       if self.options.has_key?(:file)
-        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+        Typst::Query.new(selector, self.options[:file], **query_options.merge(self.options.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
       elsif self.options.has_key?(:body)
         Typst::build_world_from_s(self.options[:body], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       elsif self.options.has_key?(:zip)
         Typst::build_world_from_zip(self.options[:zip], **self.options) do |opts|
-          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :resource_path, :ignore_system_fonts, :sys_inputs)))
+          Typst::Query.new(selector, opts[:file], **query_options.merge(opts.slice(:root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :sys_inputs)))
         end
       else
         raise "No input given"

data/lib/query.rb

@@ -2,9 +2,9 @@ module Typst
   class Query < Base
     attr_accessor :format
 
-    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], resource_path: ".", ignore_system_fonts: false, sys_inputs: {})
+    def initialize(selector, input, field: nil, one: false, format: "json", root: ".", font_paths: [], ignore_system_fonts: false, ignore_embedded_fonts: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, resource_path, ignore_system_fonts, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
     end
 
     def result(raw: false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.14.2.3
+  version: 0.15.0.0
 platform: ruby
 authors:
 - Flinn
@@ -18,7 +18,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -28,7 +28,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.124
+        version: 0.9.128
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -113,27 +113,12 @@ files:
 - ext/typst/extconf.rb
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
-- ext/typst/src/fonts.rs
 - ext/typst/src/lib.rs
 - ext/typst/src/package.rs
 - ext/typst/src/query.rs
 - ext/typst/src/world.rs
 - lib/base.rb
 - lib/document.rb
-- lib/fonts/DejaVuSansMono-Bold.ttf
-- lib/fonts/DejaVuSansMono-BoldOblique.ttf
-- lib/fonts/DejaVuSansMono-Oblique.ttf
-- lib/fonts/DejaVuSansMono.ttf
-- lib/fonts/LinLibertine_R.ttf
-- lib/fonts/LinLibertine_RB.ttf
-- lib/fonts/LinLibertine_RBI.ttf
-- lib/fonts/LinLibertine_RI.ttf
-- lib/fonts/NewCM10-Bold.otf
-- lib/fonts/NewCM10-BoldItalic.otf
-- lib/fonts/NewCM10-Italic.otf
-- lib/fonts/NewCM10-Regular.otf
-- lib/fonts/NewCMMath-Book.otf
-- lib/fonts/NewCMMath-Regular.otf
 - lib/formats/html_experimental.rb
 - lib/formats/pdf.rb
 - lib/formats/png.rb
@@ -158,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.

data/ext/typst/src/fonts.rs

@@ -1,86 +0,0 @@
-use std::cell::OnceCell;
-use std::fs::{self};
-use std::path::PathBuf;
-
-use fontdb::{Database, Source};
-use typst::font::{Font, FontBook, FontInfo};
-
-/// Searches for fonts.
-pub struct FontSearcher {
-    // Metadata about all discovered fonts.
-    pub book: FontBook,
-    /// Slots that the fonts are loaded into.
-    pub fonts: Vec<FontSlot>,
-}
-
-/// Holds details about the location of a font and lazily the font itself.
-pub struct FontSlot {
-    /// The path at which the font can be found on the system.
-    path: PathBuf,
-    /// The index of the font in its collection. Zero if the path does not point
-    /// to a collection.
-    index: u32,
-    /// The lazily loaded font.
-    font: OnceCell<Option<Font>>,
-}
-
-impl FontSlot {
-    /// Get the font for this slot.
-    pub fn get(&self) -> Option<Font> {
-        self.font
-            .get_or_init(|| {
-                let data = fs::read(&self.path).ok()?.into();
-                Font::new(data, self.index)
-            })
-            .clone()
-    }
-}
-
-impl FontSearcher {
-    /// Create a new, empty system searcher.
-    pub fn new() -> Self {
-        Self {
-            book: FontBook::new(),
-            fonts: vec![],
-        }
-    }
-
-    /// Search everything that is available.
-    pub fn search(&mut self, font_dirs: &[PathBuf], font_files: &[PathBuf]) {
-        let mut db = Database::new();
-
-        // Font paths have highest priority.
-        for path in font_dirs {
-            db.load_fonts_dir(path);
-        }
-
-        // System fonts have second priority.
-        db.load_system_fonts();
-
-        for path in font_files {
-            let _ret = db.load_font_file(path).ok();
-        }
-
-        for face in db.faces() {
-            let path = match &face.source {
-                Source::File(path) | Source::SharedFile(path, _) => path,
-                // We never add binary sources to the database, so there
-                // shouln't be any.
-                Source::Binary(_) => continue,
-            };
-
-            let info = db
-                .with_face_data(face.id, FontInfo::new)
-                .expect("database must contain this font");
-
-            if let Some(info) = info {
-                self.book.push(info);
-                self.fonts.push(FontSlot {
-                    path: path.clone(),
-                    index: face.index,
-                    font: OnceCell::new(),
-                });
-            }
-        }
-    }
-}