typst 0.15.1.5 → 0.15.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a463fc66211965514d27ea8a2867902818e7f4398779b79a4c304a993e4d5e63
-  data.tar.gz: 484a1cdbecc7ae9381d7de90313a82b0288f053dd7a105974dc80f82d0baa4e3
+  metadata.gz: 97e4afa751e5a0bded609e423ea893b263ac5676afe79fe4bcde12761bd242dd
+  data.tar.gz: 112c45f8dbebcdcbcec318948b879dc47f44dc5c2bd5a143e4c035928dec6473
 SHA512:
-  metadata.gz: 930e9e74d5cd98a50c7f06c181f4104b5ef9325a43008e9b114ae7006b4d13b2445ea57c27c28c3d60f2df5ee07c0734ea2047f52e494c4303df917058a0feed
-  data.tar.gz: 0e806b7acb6b404e92ae170ce0f78f86743ca56dd99d99f5e365bd62a0f154bb7aebf8efadf4977260a85872325d4055aadde543df199dfa582b8aa07635caf8
+  metadata.gz: d825ef788371496a9b354cf1b22d3ea06c9f7fe2e3d1cc56b18310a9af1fede42fe449b23964c20f2b34df98a31155846d21750da0eaed97d146abbd4a7ad425
+  data.tar.gz: 0c561636ed80e29170ba849853ecd0c8342cb3abc609fb1d7ffeadc466eda702d537a454e1becd36e61f7339adc320ab6177adaf84d3bd8ef048ba6e7ddab222

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,8 @@ 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)
 
 ## 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,8 @@ 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]
 
 == License
 

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(

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

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.6
 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.19
 specification_version: 4
 summary: Ruby binding to typst, a new markup-based typesetting system that is powerful
   and easy to learn.