typst 0.15.1.5 → 0.15.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a463fc66211965514d27ea8a2867902818e7f4398779b79a4c304a993e4d5e63
-  data.tar.gz: 484a1cdbecc7ae9381d7de90313a82b0288f053dd7a105974dc80f82d0baa4e3
+  metadata.gz: e504e7d6117a089aea226128ffb96a606d0569184d274a31b786b40323ea2459
+  data.tar.gz: c54e606e7ec710230a13fd418b8faeb1f427342f6533ebe0cfa1402fbb0ee327
 SHA512:
-  metadata.gz: 930e9e74d5cd98a50c7f06c181f4104b5ef9325a43008e9b114ae7006b4d13b2445ea57c27c28c3d60f2df5ee07c0734ea2047f52e494c4303df917058a0feed
-  data.tar.gz: 0e806b7acb6b404e92ae170ce0f78f86743ca56dd99d99f5e365bd62a0f154bb7aebf8efadf4977260a85872325d4055aadde543df199dfa582b8aa07635caf8
+  metadata.gz: db255e768cc4b75a8f233494478140672721c19de71b5c7a8e9f3dc48cbe89fb4a8a372f004fd5136388ba0a6c673a9e133a003ea73dfc285bab6f371108cd50
+  data.tar.gz: ae2a297b332214c1b83ed24a0862b5288aae8ded7a7d921b198f7777ce5ef091492ff85d4484729f171416a2ab8cd9765b4234f338e2bbd7ca3bf9c6434c315d

data/Cargo.toml

@@ -1,3 +1,6 @@
 [workspace]
 members = ["ext/typst"]
-resolver = "2"
+resolver = "2"
+
+[profile.release]
+strip = true

data/README.md

@@ -1,10 +1,19 @@
 # typst-rb
 
-Ruby binding to [typst](https://github.com/typst/typst),
+Ruby language binding to [typst](https://github.com/typst/typst),
 a new markup-based typesetting system that is powerful and easy to learn.
 
+## Rubygems
+
+ Source and native gems are provided for the following platforms: `aarch64-linux` `aarch64-linux-musl` `arm64-darwin` `x64-mingw-ucrt` `x86_64-darwin` `x86_64-linux` `x86_64-linux-musl`. The gems are built from CI [gem-push](https://github.com/actsasflinn/typst-rb/actions/workflows/gem-push.yml) action and can be verified against SHA256SUMS published with the [release](https://github.com/actsasflinn/typst-rb/releases).
+
 ## Installation
 
+Add the following to your gemfile and `bundle install`
+```ruby
+gem 'typst', '>= 0.15.1.5'
+```
+or install from the command line:
 ```bash
 gem install typst
 ```
@@ -13,69 +22,111 @@ gem install typst
 
 ```ruby
 require "typst"
+```
+
+### Hello World
+This example compiles a typst string to PDF and writes to a file.
+```ruby
+Typst(body: "= Hello World\nThis is your first typst PDF").compile(:pdf).write("hello_world.pdf")
+```
 
-# Compile a typst file and write the output to a PDF file
-Typst("readme.typ").compile(:pdf).write("readme.pdf")
+### The basics
+This example initializes a `Typst::Base` object `t` using a string. The `t` object is basically an environment for your typst input and can take a variety of options suitable for your task which you can see in subsequent examples.
+```ruby
+t = Typst(body: "= Hello World\nThis is your first typst PDF")
+```
+This step compiles the typst input held in the `t` object and returns a `Typst::Document` object `doc`. In this case we're compiling to PDF so `doc` is a `Typst::PdfDocument` object which holds the PDF bytes and is ready to write to a file, output to a buffer, etc.
+```ruby
+doc = t.compile(:pdf)
 ```
+This step writes the output to a local file in your current working directory.
+```ruby
+doc.write("hello_world.pdf")
+```
+### Different ways to setup the typst input
 
-### Use a typst file `readme.typ`
+#### Use a local typst file named `example.typ`
 ```ruby
-t = Typst("readme.typ")
+t = Typst("example.typ")
 ```
 
-### Use a typst string
+#### Use a typst string
 ```ruby
 t = Typst(body: %{hello world})
 ```
 
-### Use a typst file in a zip file
+#### Use a zipped typst file
 ```ruby
 t = Typst(zip: "test/main.typ.zip")
 ```
 
-### Compile to PDF
+#### Use a remote typst file
+```ruby
+require "open-uri"
+URI.open("https://github.com/actsasflinn/typst-rb/raw/refs/heads/main/README.typ") do |u|
+  Typst(body: u.read).compile(:pdf).write("remote_readme.pdf")
+end
+```
+
+#### Use a remote zipped typst file
+```ruby
+require "open-uri"
+URI.open("https://github.com/actsasflinn/typst-rb/raw/refs/heads/main/test/hello.typ.zip") do |u|
+  Tempfile.create do |f|
+    f.write(u.read)
+    f.rewind
+    Typst(zip: f).compile(:pdf).write("remote_zipped.pdf")
+  end
+end
+```
+
+### Compiling
+
+#### Compile to PDF
 ```ruby
 doc = t.compile(:pdf)
 ```
 
-### Compile to PDF selecting the typst supported PdfStandard
+#### Compile to PDF selecting the typst supported PdfStandard
 ```ruby
 doc = t.compile(:pdf, pdf_standards: ["2.0"])
 ```
 
-### Compile to SVG
+#### Compile to SVG
 ```ruby
 doc = t.compile(:svg)
 ```
 
-### Compile to PNG
+#### Compile to PNG
 ```ruby
 doc = t.compile(:png)
 ```
 
-### Compile to PNG and set PPI
+#### Compile to PNG and set PPI
 ```ruby
 doc = t.compile(:png, ppi: 72)
 ```
 
-### Compile to HTML (using Typst expirmental HTML)
+#### Compile to HTML (using Typst expirmental HTML)
 ```ruby
 doc = t.compile(:html_experimental)
 ```
 
-### Or return content as an array of bytes
+### Output
+
+#### Return compiled content as an array of bytes
 ```ruby
 pdf_bytes = Typst("readme.typ").compile(:pdf).bytes
 # => [37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]
 ```
 
-### Write the output to a file
-Note: for multi-page documents using formats other than PDF and HTML, pages write to multiple files, e.g. `readme_0.png`, `readme_1.png`
+#### Write compiled output to a file
+Note: for multi-page documents using formats other than PDF and HTML, pages write to multiple files, e.g. `filename_0.png`, `filename_1.png`
 ```ruby
 doc.write("filename.pdf")
 ```
 
-### Return PDF, SVG, PNG or HTML content as an array of pages
+#### Return PDF, SVG, PNG or HTML content as an array of pages
 ```ruby
 Typst("readme.typ").compile(:pdf).pages
 # => ["%PDF-1.7\n%\x80\x80\x80\x80\n\n1 0 obj\n<<\n  /Type /Pages\n  /Count 3\n  /Kids [160 0 R 162 ...
@@ -90,7 +141,9 @@ Typst("readme.typ").compile(:html_experimental).pages
 # => ["<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <meta name=\"viewport\" ...
 ```
 
-### Pass values into typst using sys_inputs
+### More advanced setups
+
+#### Pass values into typst using sys_inputs
 ```ruby
 sys_inputs_example = %{
 #let persons = json(bytes(sys.inputs.persons))
@@ -104,7 +157,7 @@ data = { "persons" => people.to_json }
 Typst(body: sys_inputs_example, sys_inputs: data).compile(:pdf).write("sys_inputs_example.pdf")
 ```
 
-### Apply inputs to typst to product multiple PDFs
+#### Apply inputs to typst to product multiple PDFs
 ```ruby
 t = Typst(body: sys_inputs_example)
 people.each do |person|
@@ -112,7 +165,7 @@ people.each do |person|
 end
 ```
 
-### A more complex example of compiling from string using other dependency typst template, svg and font resources all in memory
+#### A more complex example of compiling from string using other dependency typst template, svg and font resources all in memory
 ```ruby
 main = %{
 #import "template.typ": *
@@ -137,12 +190,12 @@ font_bytes = File.read("Example.ttf")
 Typst(body: main, dependencies: { "template.typ" => template, "icon.svg" => icon }, fonts: { "Example.ttf" => font_bytes }).compile(:pdf)
 ```
  
-### From a zip with a named main typst file
+#### Use a zip file with an alternatively named main typst file
 ```ruby
 Typst(zip: "test/main.typ.zip", main_file: "hello.typ").compile(:pdf)
 ```
 
-### Use a package from the [Typst Universe](https://typst.app/universe)
+#### Use a package from the [Typst Universe](https://typst.app/universe)
 Your package_example.typ file...
 ```typst
 #import "@preview/wordometer:0.1.5": word-count, total-words
@@ -160,6 +213,25 @@ In this document, there are #total-words words all up.
 Typst("package_example.typ").compile(:pdf).write("package_example.pdf")
 ```
 
+### Compiler warnings
+
+A compile can succeed *and* warn. The most common case is an unknown font
+family: typst substitutes a different face, the document is produced, and
+nothing tells you it is in the wrong typeface. Every compiled document carries
+the warnings that came with it.
+
+```ruby
+doc = Typst(body: %{#set text(font: "Not Installed")\n= Hello}).compile(:pdf)
+doc.warnings?
+# => true
+doc.warnings
+# => ["warning: unknown font family: \"Not Installed\"\n  ┌─ /tmp/.../main.typ:1:0\n ..."]
+```
+
+Each entry is one formatted diagnostic, so they can be counted, filtered or
+logged individually. A clean compile returns an empty array. Warnings that
+accompany a compile *error* are still included in the raised message, as before.
+
 ### Query a typst document
 ```ruby
 Typst("readme.typ").query("heading").result
@@ -196,7 +268,9 @@ typst-rb is based on [typst-py](https://github.com/messense/typst-py) by [messen
 clear_cache was contributed by [NRicciVestmark](https://github.com/NRicciVestmark)\
 CI improvements were contributed by [am1006](https://github.com/am1006)\
 Defect resolutions by [adam12](https://github.com/adam12) and [walterdavis](https://github.com/walterdavis)\
-Design suggestions by [alec-c4](https://github.com/alec-c4)
+Design suggestions by [alec-c4](https://github.com/alec-c4)\
+Compiler warnings were contributed by [TheSoloHacker47](https://github.com/TheSoloHacker47) \
+Font optimization patches were contributed by [dmke](https://github.com/dmke)
 
 ## License
 

data/README.typ

@@ -9,10 +9,19 @@
 
 = typst-rb
 
-Ruby binding to #link("https://github.com/typst/typst")[typst], a new markup-based typesetting system that is powerful and easy to learn.
+Ruby language binding to #link("https://github.com/typst/typst")[typst], a new markup-based typesetting system that is powerful and easy to learn.
+
+== Rubygems
+
+ Source and native gems are provided for the following platforms: `aarch64-linux` `aarch64-linux-musl` `arm64-darwin` `x64-mingw-ucrt` `x86_64-darwin` `x86_64-linux` `x86_64-linux-musl`. The gems are built from CI #link("https://github.com/actsasflinn/typst-rb/actions/workflows/gem-push.yml")[gem-push] action and can be verified against SHA256SUMS published with the #link("https://github.com/actsasflinn/typst-rb/releases")[release].
 
 == Installation
 
+Add the following to your gemfile and `bundle install`
+```ruby
+gem 'typst', '>= 0.15.1.5'
+```
+or install from the command line:
 ```bash
 gem install typst
 ```
@@ -21,69 +30,110 @@ gem install typst
 
 ```ruby
 require "typst"
+```
 
-# Compile a typst file and write the output to a PDF file
-Typst("readme.typ").compile(:pdf).write("readme.pdf")
+=== Hello World
+This example compiles a typst string to PDF and writes to a file.
+```ruby
+Typst(body: "= Hello World\nThis is your first typst PDF").compile(:pdf).write("hello_world.pdf")
+```
+=== The basics
+This example initializes a `Typst::Base` object `t` using a string. The `t` object is basically an environment for your typst input and can take a variety of options suitable for your task which you can see in subsequent examples.
+```ruby
+t = Typst(body: "= Hello World\nThis is your first typst PDF")
 ```
+This step compiles the typst input held in the `t` object and returns a `Typst::Document` object `doc`. In this case we're compiling to PDF so `doc` is a `Typst::PdfDocument` object which holds the PDF bytes and is ready to write to a file, output to a buffer, etc.
+```ruby
+doc = t.compile(:pdf)
+```
+This step writes the output to a local file in your current working directory.
+```ruby
+doc.write("hello_world.pdf")
+```
+=== Different ways to setup the typst input
 
-=== Use a typst file `readme.typ`
+==== Use a local typst file named `example.typ`
 ```ruby
-t = Typst("readme.typ")
+t = Typst("example.typ")
 ```
 
-=== Use a typst string
+==== Use a typst string
 ```ruby
 t = Typst(body: %{hello world})
 ```
 
-=== Use a typst file in a zip file
+==== Use a zipped typst file
 ```ruby
 t = Typst(zip: "test/main.typ.zip")
 ```
 
-=== Compile to PDF
+==== Use a remote typst file
+```ruby
+require "open-uri"
+URI.open("https://github.com/actsasflinn/typst-rb/raw/refs/heads/main/README.typ") do |u|
+  Typst(body: u.read).compile(:pdf).write("remote_readme.pdf")
+end
+```
+
+==== Use a remote zipped typst file
+```ruby
+require "open-uri"
+URI.open("https://github.com/actsasflinn/typst-rb/raw/refs/heads/main/test/hello.typ.zip") do |u|
+  Tempfile.create do |f|
+    f.write(u.read)
+    f.rewind
+    Typst(zip: f).compile(:pdf).write("remote_zipped.pdf")
+  end
+end
+```
+
+=== Compiling
+
+==== Compile to PDF
 ```ruby
 doc = t.compile(:pdf)
 ```
 
-=== Compile to PDF selecting the typst supported PdfStandard
+==== Compile to PDF selecting the typst supported PdfStandard
 ```ruby
 doc = t.compile(:pdf, pdf_standards: ["2.0"])
 ```
 
-=== Compile to SVG
+==== Compile to SVG
 ```ruby
 doc = t.compile(:svg)
 ```
 
-=== Compile to PNG
+==== Compile to PNG
 ```ruby
 doc = t.compile(:png)
 ```
 
-=== Compile to PNG and set PPI
+==== Compile to PNG and set PPI
 ```ruby
 doc = t.compile(:png, ppi: 72)
 ```
 
-=== Compile to HTML (using Typst expirmental HTML)
+==== Compile to HTML (using Typst expirmental HTML)
 ```ruby
 doc = t.compile(:html_experimental)
 ```
 
-=== Or return content as an array of bytes
+=== Output
+
+==== Return compiled content as an array of bytes
 ```ruby
 pdf_bytes = Typst("readme.typ").compile(:pdf).bytes
 # => [37, 80, 68, 70, 45, 49, 46, 55, 10, 37, 128 ...]
 ```
 
-=== Write the output to a file
-Note: for multi-page documents using formats other than PDF and HTML, pages write to multiple files, e.g. `readme_0.png`, `readme_1.png`
+==== Write compiled output to a file
+Note: for multi-page documents using formats other than PDF and HTML, pages write to multiple files, e.g. `filename_0.png`, `filename_1.png`
 ```ruby
 doc.write("filename.pdf")
 ```
 
-=== Return PDF, SVG, PNG or HTML content as an array of pages
+==== Return PDF, SVG, PNG or HTML content as an array of pages
 ```ruby
 Typst("readme.typ").compile(:pdf).pages
 # => ["%PDF-1.7\n%\x80\x80\x80\x80\n\n1 0 obj\n<<\n  /Type /Pages\n  /Count 3\n  /Kids [160 0 R 162 ...
@@ -98,7 +148,9 @@ Typst("readme.typ").compile(:html_experimental).pages
 # => ["<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\">\n    <meta name=\"viewport\" ...
 ```
 
-=== Pass values into typst using sys_inputs
+=== More advanced setups
+
+==== Pass values into typst using sys_inputs
 ```ruby
 sys_inputs_example = %{
 #let persons = json(bytes(sys.inputs.persons))
@@ -112,7 +164,7 @@ data = { "persons" => people.to_json }
 Typst(body: sys_inputs_example, sys_inputs: data).compile(:pdf).write("sys_inputs_example.pdf")
 ```
 
-=== Apply inputs to typst to product multiple PDFs
+==== Apply inputs to typst to product multiple PDFs
 ```ruby
 t = Typst(body: sys_inputs_example)
 people.each do |person|
@@ -120,7 +172,7 @@ people.each do |person|
 end
 ```
 
-=== A more complex example of compiling from string using other dependency typst template, svg and font resources all in memory
+==== A more complex example of compiling from string using other dependency typst template, svg and font resources all in memory
 ```ruby
 main = %{
 #import "template.typ": *
@@ -145,12 +197,12 @@ font_bytes = File.read("Example.ttf")
 Typst(body: main, dependencies: { "template.typ" => template, "icon.svg" => icon }, fonts: { "Example.ttf" => font_bytes }).compile(:pdf)
 ```
  
-=== From a zip with a named main typst file
+==== Use a zip file with an alternatively named main typst file
 ```ruby
 Typst(zip: "test/main.typ.zip", main_file: "hello.typ").compile(:pdf)
 ```
 
-=== Use a package from the #link("https://typst.app/universe")[Typst Universe]
+==== Use a package from the #link("https://typst.app/universe")[Typst Universe]
 Your package_example.typ file...
 ```typst
 #import "@preview/wordometer:0.1.5": word-count, total-words
@@ -168,6 +220,25 @@ In this document, there are #total-words words all up.
 Typst("package_example.typ").compile(:pdf).write("package_example.pdf")
 ```
 
+=== Compiler warnings
+
+A compile can succeed *and* warn. The most common case is an unknown font
+family: typst substitutes a different face, the document is produced, and
+nothing tells you it is in the wrong typeface. Every compiled document carries
+the warnings that came with it.
+
+```ruby
+doc = Typst(body: %{#set text(font: "Not Installed")\n= Hello}).compile(:pdf)
+doc.warnings?
+# => true
+doc.warnings
+# => ["warning: unknown font family: \"Not Installed\"\n  ┌─ /tmp/.../main.typ:1:0\n ..."]
+```
+
+Each entry is one formatted diagnostic, so they can be counted, filtered or
+logged individually. A clean compile returns an empty array. Warnings that
+accompany a compile *error* are still included in the raised message, as before.
+
 === Query a typst document
 ```ruby
 Typst("readme.typ").query("heading").result
@@ -204,7 +275,9 @@ typst-rb is based on #link("https://github.com/messense/typst-py")[typst-py] by
 clear_cache was contributed by #link("https://github.com/NRicciVestmark")[NRicciVestmark]\
 CI improvements were contributed by #link("https://github.com/am1006")[am1006]\
 Defect resolutions by #link("https://github.com/adam12")[adam12] and #link("https://github.com/walterdavis")[walterdavis]\
-Design suggestions by #link("https://github.com/alec-c4")[alec-c4]
+Design suggestions by #link("https://github.com/alec-c4")[alec-c4]\
+Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47] \
+Font optimization patches were contributed by #link("https://github.com/dmke")[dmke]
 
 == License
 

data/Rakefile

@@ -34,6 +34,10 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
+task 'benchmark' do |t|
+  sh "bundle exec ruby benchmarks/compile_pdf.rb"
+end
+
 task 'gem:native' do |t|
   CROSS_PLATFORMS.each do |platform|
     sh "bundle exec rb-sys-dock --platform #{platform} --build"

data/ext/typst/src/compiler.rs

@@ -22,7 +22,7 @@ impl SystemWorld {
         pdf_standards: &[typst_pdf::PdfStandard],
         pretty: bool,
         render_bleed: bool,
-    ) -> StrResult<Vec<Vec<u8>>> {
+    ) -> StrResult<(Vec<Vec<u8>>, Vec<String>)> {
         // Reset everything and ensure that the main file is present.
         self.reset();
         self.source(self.main()).map_err(|err| err.to_string())?;
@@ -32,7 +32,7 @@ impl SystemWorld {
                 let Warned { output, warnings } = typst::compile::<HtmlDocument>(self);
                 match output {
                     Ok(document) => {
-                        Ok(vec![export_html(&document, self, pretty)?])
+                        Ok((vec![export_html(&document, self, pretty)?], self.format_warnings(&warnings)))
                     }
                     Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
                 }
@@ -43,25 +43,45 @@ impl SystemWorld {
                     // Export the PDF / PNG.
                     Ok(document) => {
                         // Assert format is "pdf" or "png" or "svg"
-                        match format.unwrap_or("pdf").to_ascii_lowercase().as_str() {
-                            "pdf" => Ok(vec![export_pdf(
+                        let buffers = match format.unwrap_or("pdf").to_ascii_lowercase().as_str() {
+                            "pdf" => vec![export_pdf(
                                 &document,
                                 self,
                                 typst_pdf::PdfStandards::new(pdf_standards)
                                     .map_err(|e| eco_format!("PDF standards error: {:?}", e))
                                     .at(Span::detached()).unwrap(),
                                 pretty,
-                            )?]),
-                            "png" => Ok(export_image(&document, ImageExportFormat::Png, ppi, pretty, render_bleed)?),
-                            "svg" => Ok(export_image(&document, ImageExportFormat::Svg, ppi, pretty, render_bleed)?),
-                            fmt => Err(eco_format!("unknown format: {fmt}")),
-                        }
+                            )?],
+                            "png" => export_image(&document, ImageExportFormat::Png, ppi, pretty, render_bleed)?,
+                            "svg" => export_image(&document, ImageExportFormat::Svg, ppi, pretty, render_bleed)?,
+                            fmt => return Err(eco_format!("unknown format: {fmt}")),
+                        };
+                        Ok((buffers, self.format_warnings(&warnings)))
                     }
                     Err(errors) => Err(format_diagnostics(self, &errors, &warnings).unwrap().into()),
                 }
             }
         }
     }
+
+    /// One formatted string per warning.
+    ///
+    /// A successful compile can still produce warnings — an unknown font
+    /// family being the one that bites people, because Typst substitutes a
+    /// different face and the document still generates. Previously those were
+    /// dropped on the floor: `format_diagnostics` only ever saw them on the
+    /// error path. Returning them one per entry (rather than as a single
+    /// blob) means a caller can count them, filter them, or attach them to a
+    /// log line without parsing.
+    fn format_warnings(&self, warnings: &[SourceDiagnostic]) -> Vec<String> {
+        warnings
+            .iter()
+            .map(|warning| {
+                format_diagnostics(self, &[], std::slice::from_ref(warning))
+                    .unwrap_or_else(|_| warning.message.to_string())
+            })
+            .collect()
+    }
 }
 
 /// Export to a PDF.

data/ext/typst/src/lib.rs

@@ -24,7 +24,7 @@ fn to_html(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<Vec<Vec<u8>>, Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
     let input = input.canonicalize()
         .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
 
@@ -62,11 +62,11 @@ fn to_html(
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    let bytes = world
+    let compiled = world
         .compile(Some("html"), None, &Vec::new(), pretty, render_bleed)
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    Ok(bytes)
+    Ok(compiled)
 }
 
 fn to_svg(
@@ -79,7 +79,7 @@ fn to_svg(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<Vec<Vec<u8>>, Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
     let input = input.canonicalize()
         .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
 
@@ -104,11 +104,11 @@ fn to_svg(
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    let svg_bytes = world
+    let compiled = world
         .compile(Some("svg"), None, &Vec::new(), pretty, render_bleed)
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    Ok(svg_bytes)
+    Ok(compiled)
 }
 
 fn to_png(
@@ -121,7 +121,7 @@ fn to_png(
     render_bleed: bool,
     sys_inputs: HashMap<String, String>,
     ppi: Option<f32>,
-) -> Result<Vec<Vec<u8>>, Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
     let input = input.canonicalize()
         .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
 
@@ -146,11 +146,11 @@ fn to_png(
         .build()
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    let bytes = world
+    let compiled = world
         .compile(Some("png"), ppi, &Vec::new(), false, render_bleed)
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    Ok(bytes)
+    Ok(compiled)
 }
 
 fn to_pdf(
@@ -163,7 +163,7 @@ fn to_pdf(
     pretty: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
-) -> Result<Vec<Vec<u8>>, Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
     let input = input.canonicalize()
         .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
 
@@ -217,11 +217,11 @@ fn to_pdf(
         }
     }
 
-    let pdf_bytes = world
+    let compiled = world
         .compile(Some("pdf"), None, &pdf_standards_vec, pretty, true)
         .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg.to_string()))?;
 
-    Ok(pdf_bytes)
+    Ok(compiled)
 }
 
 fn query(
@@ -287,6 +287,10 @@ fn clear_cache(_ruby: &Ruby, max_age: usize) {
     comemo::evict(max_age);
 }
 
+fn clear_font_cache(_ruby: &Ruby) {
+    world::clear_font_cache();
+}
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     env_logger::init();
@@ -298,5 +302,6 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("_to_html", function!(to_html, 8))?;
     module.define_singleton_method("_query", function!(query, 10))?;
     module.define_singleton_method("_clear_cache", function!(clear_cache, 1))?;
+    module.define_singleton_method("_clear_font_cache", function!(clear_font_cache, 0))?;
     Ok(())
 }

data/ext/typst/src/world.rs

@@ -7,10 +7,10 @@ use chrono::{DateTime, Datelike, FixedOffset, Local};
 use typst::diag::{FileError, FileResult, StrResult};
 use typst::foundations::{Bytes, Datetime, Dict, Duration};
 use typst::syntax::{FileId, Lines, Source, VirtualPath, VirtualRoot, RootedPath};
-use typst::text::{Font, FontBook};
+use typst::text::{Font, FontBook, FontInfo};
 use typst::utils::LazyHash;
 use typst::{Features, Library, LibraryExt, World};
-use typst_kit::fonts::{self, FontStore};
+use typst_kit::fonts::{self, FontPath, FontStore};
 use typst_kit::packages::{FsPackages, SystemPackages, UniversePackages};
 
 /// A world that provides access to the operating system.
@@ -195,7 +195,7 @@ impl SystemWorldBuilder {
     }
 
     pub fn build(self) -> StrResult<SystemWorld> {
-        let fonts = Arc::new(build_font_store(self.ignore_system_fonts, self.ignore_embedded_fonts, self.font_paths));
+        let fonts = 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);
 
@@ -217,13 +217,84 @@ impl SystemWorldBuilder {
     }
 }
 
+/// Font discovery, which is far too slow to repeat on every compile.
+///
+/// A full system font scan takes about 95 ms, which for a small document
+/// dwarfs the compilation itself. `FontStore` cannot be cloned, so the
+/// discovered fonts are kept alongside the assembled stores.
+struct FontCache {
+    /// The locations found by walking the system font directories.
+    system: Option<Arc<Vec<(PathBuf, u32, FontInfo)>>>,
+    /// The fonts shipped with typst, already parsed.
+    embedded: Option<Arc<Vec<(Font, FontInfo)>>>,
+    /// A store per combination of the two ignore flags, for compiles that
+    /// bring no font paths of their own. Sharing one keeps the fonts a
+    /// document uses loaded between compiles and hashes the book only once.
+    stores: [Option<Arc<FontStore>>; 4],
+}
+
+const EMPTY_FONT_CACHE: FontCache =
+    FontCache { system: None, embedded: None, stores: [const { None }; 4] };
+
+static FONT_CACHE: Mutex<FontCache> = Mutex::new(EMPTY_FONT_CACHE);
+
+/// Forgets everything discovered so far, so that the next compile picks up
+/// fonts installed or removed since.
+pub fn clear_font_cache() {
+    *FONT_CACHE.lock().unwrap() = EMPTY_FONT_CACHE;
+}
+
+/// Reads a cache field, filling it on a miss.
+///
+/// The lock is not held while building, so two threads missing at once both
+/// build and one result is dropped. That wastes a scan but keeps a 95 ms
+/// build off the lock.
+fn cached<T>(
+    select: impl Fn(&mut FontCache) -> &mut Option<Arc<T>>,
+    build: impl FnOnce() -> T,
+) -> Arc<T> {
+    let hit = select(&mut FONT_CACHE.lock().unwrap()).clone();
+    if let Some(value) = hit {
+        return value;
+    }
+
+    let value = Arc::new(build());
+    *select(&mut FONT_CACHE.lock().unwrap()) = Some(value.clone());
+    value
+}
+
+/// Obtains a font store for the given configuration.
+///
+/// Extra font paths are scanned on every compile. They are usually a
+/// temporary directory written by `Typst.build_world_from_s`, so their
+/// contents can change between compiles and caching on them would grow
+/// without bound.
+fn font_store(ignore_system_fonts: bool, ignore_embedded_fonts: bool, font_paths: Vec<PathBuf>) -> Arc<FontStore> {
+    if !font_paths.is_empty() {
+        return Arc::new(build_font_store(ignore_system_fonts, ignore_embedded_fonts, font_paths));
+    }
+
+    let index = usize::from(ignore_system_fonts) << 1 | usize::from(ignore_embedded_fonts);
+    cached(
+        move |cache| &mut cache.stores[index],
+        || build_font_store(ignore_system_fonts, ignore_embedded_fonts, Vec::new()),
+    )
+}
+
 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());
+        let system = cached(
+            |cache| &mut cache.system,
+            || fonts::system().map(|(path, info)| (path.path, path.index, info)).collect(),
+        );
+        fonts.extend(system.iter().map(|(path, index, info)| {
+            (FontPath { path: path.clone(), index: *index }, info.clone())
+        }));
     }
     if !ignore_embedded_fonts {
-        fonts.extend(fonts::embedded());
+        let embedded = cached(|cache| &mut cache.embedded, || fonts::embedded().collect());
+        fonts.extend(embedded.iter().cloned());
     }
     for path in font_paths {
         fonts.extend(fonts::scan(&path));

data/lib/document.rb

@@ -2,8 +2,18 @@ module Typst
   class Document
     attr_accessor :bytes
 
-    def initialize(bytes)
+    # Diagnostics the compiler emitted while *succeeding*. An unknown font
+    # family is the common one: Typst substitutes another face, the document
+    # generates, and nothing tells you unless you look here.
+    attr_accessor :warnings
+
+    def initialize(bytes, warnings = [])
       @bytes = bytes
+      @warnings = warnings
+    end
+
+    def warnings?
+      !warnings.empty?
     end
 
     def write_some(filename)

data/lib/formats/html_experimental.rb

@@ -2,7 +2,8 @@ module Typst
   class HtmlExperimental < Base
     def initialize(*options)
       super(*options)
-      @compiled = HtmlExperimentalDocument.new(Typst::_to_html(*self.typst_pretty_args))
+      bytes, warnings = Typst::_to_html(*self.typst_pretty_args)
+      @compiled = HtmlExperimentalDocument.new(bytes, warnings)
     end
   end
   class HtmlExperimentalDocument < Document

data/lib/formats/pdf.rb

@@ -2,7 +2,8 @@ module Typst
   class Pdf < Base
     def initialize(*options)
       super(*options)
-      @compiled = PdfDocument.new(Typst::_to_pdf(*self.typst_pdf_args))
+      bytes, warnings = Typst::_to_pdf(*self.typst_pdf_args)
+      @compiled = PdfDocument.new(bytes, warnings)
     end
   end
   class PdfDocument < Document

data/lib/formats/png.rb

@@ -2,7 +2,8 @@ module Typst
   class Png < Base
     def initialize(*options)
       super(*options)
-      @compiled = PngDocument.new(Typst::_to_png(*self.typst_png_args))
+      bytes, warnings = Typst::_to_png(*self.typst_png_args)
+      @compiled = PngDocument.new(bytes, warnings)
     end
   end
   class PngDocument < Document

data/lib/formats/svg.rb

@@ -2,7 +2,8 @@ module Typst
   class Svg < Base
     def initialize(*options)
       super(*options)
-      @compiled = SvgDocument.new(Typst::_to_svg(*self.typst_pretty_args))
+      bytes, warnings = Typst::_to_svg(*self.typst_pretty_args)
+      @compiled = SvgDocument.new(bytes, warnings)
     end
   end
   class SvgDocument < Document

data/lib/typst.rb

@@ -17,6 +17,12 @@ module Typst
     Typst::_clear_cache(max_age)
   end
 
+  # Discards the discovered system and embedded fonts, so that the next
+  # compile picks up fonts installed or removed since the first one.
+  def self.clear_font_cache
+    Typst::_clear_font_cache
+  end
+
   def self.build_world_from_s(main_source, **options, &blk)
     dependencies = options[:dependencies] ||= {}
     fonts = options[:fonts] ||= {}
@@ -30,16 +36,18 @@ module Typst
         File.binwrite(tmp_dep_file, dep_source)
       end
 
-      relative_font_path = Pathname.new(tmp_dir).join("fonts")
-      relative_font_path.mkpath
-      fonts.each do |font_name, font_bytes|
-        tmp_font_file = relative_font_path.join(font_name)
-        File.binwrite(tmp_font_file, font_bytes)
+      unless fonts.empty?
+        relative_font_path = Pathname.new(tmp_dir).join("fonts")
+        relative_font_path.mkpath
+        fonts.each do |font_name, font_bytes|
+          tmp_font_file = relative_font_path.join(font_name)
+          File.binwrite(tmp_font_file, font_bytes)
+        end
+        options[:font_paths] = (options[:font_paths] || []) + [relative_font_path]
       end
 
       options[:file] = tmp_main_file
       options[:root] = tmp_dir
-      options[:font_paths] = [relative_font_path]
 
       blk.call(options)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.15.1.5
+  version: 0.15.1.8
 platform: ruby
 authors:
 - Flinn
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.