typst 0.15.1.8 → 0.15.1.9.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e504e7d6117a089aea226128ffb96a606d0569184d274a31b786b40323ea2459
-  data.tar.gz: c54e606e7ec710230a13fd418b8faeb1f427342f6533ebe0cfa1402fbb0ee327
+  metadata.gz: 3c7cc49e13eced386fc44cfb914ebf07dc5892490730f3fd4fbed7448e974f74
+  data.tar.gz: 1f7e43e5d752bf8817f22ad3a3da673f1370f697d93effe05d69fe15128960e9
 SHA512:
-  metadata.gz: db255e768cc4b75a8f233494478140672721c19de71b5c7a8e9f3dc48cbe89fb4a8a372f004fd5136388ba0a6c673a9e133a003ea73dfc285bab6f371108cd50
-  data.tar.gz: ae2a297b332214c1b83ed24a0862b5288aae8ded7a7d921b198f7777ce5ef091492ff85d4484729f171416a2ab8cd9765b4234f338e2bbd7ca3bf9c6434c315d
+  metadata.gz: c44932e11673f6881589eb84e1e7a736e1116adf8c4f9200d4e14da7624eeb24df01320dac16faea7f5ac3e0d8567ea44c400422c94c57e250e7c705d289643c
+  data.tar.gz: 8b5689a033596181456b73a321f7df85b3ecd66b67865a33b6030b9560d0474b596f330564b7c335bf0f15bb9e469129fea424d01f1ac97ef1f13f595a7511c8

data/Cargo.lock

@@ -2060,18 +2060,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
+checksum = "02faf625bb10ba893e3ae620f19c9fb1b5f8fcae0fe4eb86bb3f2230fad75edb"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.128"
+version = "0.9.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
+checksum = "05be6f9c86fe5482808162826f6c047d093b3670582296c770de1d94f8066694"
 dependencies = [
  "bindgen",
  "lazy_static",

data/README.md

@@ -263,6 +263,58 @@ max_age = 10
 Typst::clear_cache(max_age)
 ```
 
+### Experimental
+
+#### Threads and concurrency
+
+A new experimental `concurrent` flag is added to work around Ruby's global VM lock and speed things up for batch workloads.
+
+Set the option globally
+```ruby
+Typst.concurrent = true
+```
+
+Or set the option per call
+```ruby
+Typst(body: invoice, concurrent: true)
+```
+
+Compiling releases Ruby's global VM lock, so several threads can compile at the
+same time and genuinely use several cores.
+
+```ruby
+docs = invoices.map { |invoice| Thread.new { Typst(body: invoice, concurrent: true).compile(:pdf) } }.map(&:value)
+```
+
+Eight threads compiling the same document, measured on a 24-core machine:
+
+| threads | documents/second | cores busy |
+|--------:|-----------------:|-----------:|
+|       1 |              9.9 |       1.00 |
+|       8 |             36.0 |       7.65 |
+
+That is throughput across documents, not speed within one. typst parallelizes
+page runs, so a document with a single page layout is one run and stays on one
+core no matter how many threads it is given.
+
+Threads share the compilation cache and the font discovery. Compiling different
+sources, with different `sys_inputs`, font paths and roots, at the same time is
+safe.
+
+Three things to know:
+
+* A compile cannot be interrupted. `Thread#kill` and `Ctrl-C` take effect once
+  it returns.
+* Package storage is not safe to populate concurrently. Threads that need the
+  same not-yet-cached package each download their own copy and untar it
+  straight into the same directory, over each other; on Windows that fails
+  outright rather than clobbering. Compile once to warm the cache before
+  fanning out. Reading a package already on disk from many threads is safe.
+* `clear_cache` takes the cache's write lock, so calling it in a loop while other
+  threads compile will starve them. Measured with four threads compiling and one
+  evicting as fast as it could, the compiles took 400 times longer. Call it
+  between batches of documents, not between documents.
+
 ## Contributors & Acknowledgements
 typst-rb is based on [typst-py](https://github.com/messense/typst-py) by [messense](https://github.com/messense)\
 clear_cache was contributed by [NRicciVestmark](https://github.com/NRicciVestmark)\
@@ -270,7 +322,8 @@ 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)\
 Compiler warnings were contributed by [TheSoloHacker47](https://github.com/TheSoloHacker47) \
-Font optimization patches were contributed by [dmke](https://github.com/dmke)
+Font optimization patches were contributed by [dmke](https://github.com/dmke) \
+Concurrency patches were contributed by [dmke](https://github.com/dmke)
 
 ## License
 

data/README.typ

@@ -270,14 +270,69 @@ max_age = 10
 Typst::clear_cache(max_age)
 ```
 
+=== Experimental
+
+==== Threads and concurrency
+
+A new experimental `concurrent` flag is added to work around Ruby's global VM lock and speed things up for batch workloads.
+
+Set the option globally
+```ruby
+Typst.concurrent = true
+```
+
+Or set the option per call
+```ruby
+Typst(body: invoice, concurrent: true)
+```
+
+Compiling releases Ruby's global VM lock, so several threads can compile at the
+same time and genuinely use several cores.
+
+```ruby
+docs = invoices.map { |invoice| Thread.new { Typst(body: invoice, concurrent: true).compile(:pdf) } }.map(&:value)
+```
+
+Eight threads compiling the same document, measured on a 24-core machine:
+
+#table(
+  columns: 3,
+  align: (right, right, right),
+  table.header([threads], [documents/second], [cores busy]),
+  [1], [9.9], [1.00],
+  [8], [36.0], [7.65],
+)
+
+That is throughput across documents, not speed within one. typst parallelizes
+page runs, so a document with a single page layout is one run and stays on one
+core no matter how many threads it is given.
+
+Threads share the compilation cache and the font discovery. Compiling different
+sources, with different `sys_inputs`, font paths and roots, at the same time is
+safe.
+
+Three things to know:
+
+- A compile cannot be interrupted. `Thread#kill` and `Ctrl-C` take effect once
+  it returns.
+- Package storage is not safe to populate concurrently. Threads that need the
+  same not-yet-cached package each download their own copy and untar it
+  straight into the same directory, over each other; on Windows that fails
+  outright rather than clobbering. Compile once to warm the cache before
+  fanning out. Reading a package already on disk from many threads is safe.
+- `clear_cache` takes the cache's write lock, so calling it in a loop while other
+  threads compile will starve them. Measured with four threads compiling and one
+  evicting as fast as it could, the compiles took 400 times longer. Call it
+  between batches of documents, not between documents.
+
 == Contributors & Acknowledgements
 typst-rb is based on #link("https://github.com/messense/typst-py")[typst-py] by #link("https://github.com/messense")[messense]\
 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]\
-Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47] \
-Font optimization patches were contributed by #link("https://github.com/dmke")[dmke]
+Compiler warnings were contributed by #link("https://github.com/TheSoloHacker47")[TheSoloHacker47]
+Concurrency patches were contributed by #link("https://github.com/dmke")[dmke]
 
 == License
 

data/Rakefile

@@ -30,12 +30,16 @@ end
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/*_test.rb']
+  # Absolute, because test/typst_test.rb chdirs into its own directory as it
+  # loads and the loader resolves what follows it against the working directory.
+  t.test_files = FileList['test/*_test.rb'].map { |f| File.expand_path(f) }
   t.verbose = true
 end
 
 task 'benchmark' do |t|
-  sh "bundle exec ruby benchmarks/compile_pdf.rb"
+  Dir.glob("benchmarks/*.rb").each do |b|
+    sh "bundle exec ruby #{b}"
+  end
 end
 
 task 'gem:native' do |t|
@@ -49,4 +53,4 @@ task 'gem:native:push' do |t|
   CROSS_PLATFORMS.each do |platform|
     sh "gem push pkg/typst-#{spec.version}-#{platform}.gem"
   end
-end
+end

data/ext/typst/Cargo.toml

@@ -52,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.128", default-features = false, features = ["stable-api-compiled-fallback"] }
+rb-sys = { version = "0.9.130", default-features = false, features = ["stable-api-compiled-fallback"] }

data/ext/typst/extconf.rb

@@ -1,4 +1,15 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
+module RbSys
+    class CargoBuilder < Gem::Ext::Builder
+        alias_method :old_platform_specific_rustc_args, :platform_specific_rustc_args
+        def new_platform_specific_rustc_args(dest_dir, flags = [])
+            flags += ["-l", "kernel32"] if mingw_target? # add kernel32 before libruby to avoid the sleep bug
+            old_platform_specific_rustc_args(dest_dir, flags)
+        end
+        alias_method :platform_specific_rustc_args, :new_platform_specific_rustc_args
+    end
+end
+
 create_rust_makefile("typst/typst")

data/ext/typst/src/lib.rs

@@ -7,15 +7,16 @@ use query::{query as typst_query, QueryCommand, SerializationFormat};
 use typst::foundations::{Dict, Value};
 use typst_library::Feature;
 use typst_pdf::PdfStandard;
+use nogvl::without_gvl;
 use world::SystemWorld;
 
 mod compiler;
 mod download;
+mod nogvl;
 mod query;
 mod world;
 
 fn to_html(
-    ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
@@ -24,13 +25,13 @@ fn to_html(
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|err| err.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+        .map_err(|err| err.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -60,32 +61,53 @@ fn to_html(
         .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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_svg(
+fn route_to_html(
     ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
+    concurrent: bool,
     render_bleed: bool,
     pretty: bool,
     sys_inputs: HashMap<String, String>,
 ) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+        })
+    } else {
+        to_html(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_svg(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    render_bleed: bool,
+    pretty: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -102,32 +124,53 @@ fn to_svg(
         .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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_png(
+fn route_to_svg(
     ruby: &Ruby,
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
+    concurrent: bool,
     render_bleed: bool,
+    pretty: bool,
     sys_inputs: HashMap<String, String>,
-    ppi: Option<f32>,
 ) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+        })
+    } else {
+        to_svg(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, pretty, sys_inputs)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_png(
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    render_bleed: bool,
+    sys_inputs: HashMap<String, String>,
+    ppi: Option<f32>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -144,17 +187,38 @@ fn to_png(
         .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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn to_pdf(
+fn route_to_png(
     ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    render_bleed: bool,
+    sys_inputs: HashMap<String, String>,
+    ppi: Option<f32>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
+        })
+    } else {
+        to_png(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, render_bleed, sys_inputs, ppi)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn to_pdf(
     input: PathBuf,
     root: Option<PathBuf>,
     font_paths: Vec<PathBuf>,
@@ -163,13 +227,13 @@ fn to_pdf(
     pretty: bool,
     sys_inputs: HashMap<String, String>,
     pdf_standards: Vec<String>,
-) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+) -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -186,7 +250,7 @@ fn to_pdf(
         .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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let pdf_standards_lookup: HashMap::<&str, PdfStandard> = HashMap::from([
         ("1.4", PdfStandard::V_1_4),
@@ -213,19 +277,40 @@ fn to_pdf(
         let result = pdf_standards_lookup.get(pdf_standard.as_str());
         match result {
             Some(value) => pdf_standards_vec.push(*value),
-            _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "Unknown PdfStandard")),
+            _ => return Err("Unknown PdfStandard".to_string()),
         }
     }
 
     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()))?;
+        .map_err(|msg| msg.to_string())?;
 
     Ok(compiled)
 }
 
-fn query(
+fn route_to_pdf(
     ruby: &Ruby,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    pretty: bool,
+    sys_inputs: HashMap<String, String>,
+    pdf_standards: Vec<String>,
+) -> Result<(Vec<Vec<u8>>, Vec<String>), Error> {
+    if concurrent {
+        without_gvl(move || -> Result<(Vec<Vec<u8>>, Vec<String>), String> {
+            to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+        })
+    } else {
+        to_pdf(input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, pretty, sys_inputs, pdf_standards)
+    }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
+}
+
+fn query(
     selector: String,
     field: Option<String>,
     one: bool,
@@ -236,19 +321,19 @@ fn query(
     ignore_system_fonts: bool,
     ignore_embedded_fonts: bool,
     sys_inputs: HashMap<String, String>,
-) -> Result<String, Error> {
+) -> Result<String, String> {
     let format = match format.unwrap().to_ascii_lowercase().as_str() {
         "json" => SerializationFormat::Json,
         "yaml" => SerializationFormat::Yaml,
-        _ => return Err(magnus::Error::new(ruby.exception_arg_error(), "unsupported serialization format"))?,
+        _ => return Err("unsupported serialization format".to_string()),
     };
 
     let input = input.canonicalize()
-        .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?;
+        .map_err(|msg| msg.to_string())?;
 
     let root = if let Some(root) = root {
         root.canonicalize()
-            .map_err(|err| magnus::Error::new(ruby.exception_arg_error(), err.to_string()))?
+            .map_err(|msg| msg.to_string())?
     } else if let Some(dir) = input.parent() {
         dir.into()
     } else {
@@ -265,7 +350,7 @@ fn query(
     .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()))?;
+    .map_err(|msg| msg.to_string())?;
 
     let result = typst_query(
         &mut world,
@@ -279,8 +364,32 @@ fn query(
 
     match result {
         Ok(data) => Ok(data),
-        Err(msg) => Err(magnus::Error::new(ruby.exception_arg_error(), msg.to_string())),
+        Err(msg) => return Err(msg.to_string()),
+    }
+}
+
+fn route_query(
+    ruby: &Ruby,
+    selector: String,
+    field: Option<String>,
+    one: bool,
+    format: Option<String>,
+    input: PathBuf,
+    root: Option<PathBuf>,
+    font_paths: Vec<PathBuf>,
+    ignore_system_fonts: bool,
+    ignore_embedded_fonts: bool,
+    concurrent: bool,
+    sys_inputs: HashMap<String, String>,
+) -> Result<String, Error> {
+    if concurrent {
+        without_gvl(move || -> Result<String, String> {
+            query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
+        })
+    } else {
+        query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
     }
+    .map_err(|msg| magnus::Error::new(ruby.exception_arg_error(), msg))
 }
 
 fn clear_cache(_ruby: &Ruby, max_age: usize) {
@@ -296,11 +405,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     env_logger::init();
 
     let module = ruby.define_module("Typst")?;
-    module.define_singleton_method("_to_pdf", function!(to_pdf, 8))?;
-    module.define_singleton_method("_to_svg", function!(to_svg, 8))?;
-    module.define_singleton_method("_to_png", function!(to_png, 8))?;
-    module.define_singleton_method("_to_html", function!(to_html, 8))?;
-    module.define_singleton_method("_query", function!(query, 10))?;
+    module.define_singleton_method("_to_pdf", function!(route_to_pdf, 9))?;
+    module.define_singleton_method("_to_svg", function!(route_to_svg, 9))?;
+    module.define_singleton_method("_to_png", function!(route_to_png, 9))?;
+    module.define_singleton_method("_to_html", function!(route_to_html, 9))?;
+    module.define_singleton_method("_query", function!(route_query, 11))?;
     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/nogvl.rs

@@ -0,0 +1,49 @@
+use std::ffi::c_void;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+/// Runs `f` with the GVL released, so other Ruby threads keep running while
+/// Typst compiles.
+///
+/// `f` runs on the calling OS thread and must not touch the Ruby API — no
+/// `Ruby` handle, no `Value`, no allocation of Ruby objects. Convert to and
+/// from Ruby types outside of this call.
+///
+/// No unblocking function is registered, so the call cannot be interrupted;
+/// a compile always runs to completion. That matches the previous behaviour,
+/// where holding the GVL made the compile uninterruptible anyway.
+pub fn without_gvl<F, T>(f: F) -> T
+where
+    F: FnOnce() -> T,
+{
+    struct Payload<F, T> {
+        f: Option<F>,
+        result: Option<std::thread::Result<T>>,
+    }
+
+    // A Rust panic must not unwind across the C frame that Ruby pushes here,
+    // so it is caught and resumed once we hold the GVL again.
+    unsafe extern "C" fn trampoline<F, T>(data: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce() -> T,
+    {
+        let payload = &mut *data.cast::<Payload<F, T>>();
+        let f = payload.f.take().expect("closure called twice");
+        payload.result = Some(catch_unwind(AssertUnwindSafe(f)));
+        std::ptr::null_mut()
+    }
+
+    let mut payload = Payload { f: Some(f), result: None };
+    unsafe {
+        rb_sys::rb_thread_call_without_gvl(
+            Some(trampoline::<F, T>),
+            (&raw mut payload).cast::<c_void>(),
+            None,
+            std::ptr::null_mut(),
+        );
+    }
+
+    match payload.result.take().expect("closure was not called") {
+        Ok(value) => value,
+        Err(panic) => std::panic::resume_unwind(panic),
+    }
+}

data/lib/base.rb

@@ -38,12 +38,13 @@ module Typst
       options[:ignore_embedded_fonts] ||= false
       options[:pretty] ||= false
       options[:render_bleed] ||= false
+      options[:concurrent] ||= Typst.concurrent
     
       self.options = options
     end
 
     def typst_options
-      [:file, :root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :render_bleed]
+      [:file, :root, :font_paths, :ignore_system_fonts, :ignore_embedded_fonts, :concurrent, :render_bleed]
     end
 
     def typst_args(opts)

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: [], ignore_system_fonts: false, ignore_embedded_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, concurrent: false, sys_inputs: {})
       self.format = format
-      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, sys_inputs)
+      @result = Typst::_query(selector, field, one, format, input, root, font_paths, ignore_system_fonts, ignore_embedded_fonts, concurrent, sys_inputs)
     end
 
     def result(raw: false)

data/lib/typst.rb

@@ -4,6 +4,7 @@ end
 
 module Typst
   @@formats = {}
+  @@concurrent = false
 
   def self.register_format(**format)
     @@formats.merge!(format)
@@ -13,6 +14,14 @@ module Typst
     @@formats
   end
 
+  def self.concurrent
+    @@concurrent
+  end
+
+  def self.concurrent=(value)
+    @@concurrent = value
+  end
+
   def self.clear_cache(max_age = 0)
     Typst::_clear_cache(max_age)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typst
 version: !ruby/object:Gem::Version
-  version: 0.15.1.8
+  version: 0.15.1.9.pre
 platform: ruby
 authors:
 - Flinn
@@ -18,7 +18,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.128
+        version: 0.9.130
   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.128
+        version: 0.9.130
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +88,7 @@ files:
 - ext/typst/src/compiler.rs
 - ext/typst/src/download.rs
 - ext/typst/src/lib.rs
+- ext/typst/src/nogvl.rs
 - ext/typst/src/package.rs
 - ext/typst/src/query.rs
 - ext/typst/src/world.rs