imprimatur 0.1.0 → 0.3.0

data/ext/imprimatur_native/core/src/xlsx/autofit.rs

@@ -0,0 +1,60 @@
+//! Column widths from the cells. There is no font to measure text with, so
+//! a column is as wide as its widest cell's character count says, scaled by
+//! that cell's font.
+
+#[cfg(test)]
+mod tests;
+
+use std::collections::BTreeMap;
+
+use super::cell::Cell;
+use super::format::Font;
+use super::worksheet::Worksheet;
+
+/// Excel's widest column, in characters.
+const MAX_WIDTH: f64 = 255.0;
+
+/// The width each column without one of its own needs for its widest cell:
+/// `(characters + 3) × points / 10`, a bold cell counting one and a half
+/// times, at most 255. Formulas are left out: their results are unknown.
+pub fn widths(sheet: &Worksheet, base: &Font) -> BTreeMap<u16, f64> {
+    let mut widths = BTreeMap::new();
+    for (_, cells) in sheet.rows() {
+        for (&column, entry) in cells {
+            if sheet.column_widths().contains_key(&column) {
+                continue;
+            }
+            let Some(characters) = characters(&entry.cell) else {
+                continue;
+            };
+            let font = usize::try_from(entry.style)
+                .ok()
+                .and_then(|style| style.checked_sub(1))
+                .and_then(|index| sheet.formats().get(index))
+                .map_or(base, |format| &format.font);
+            let bold = if font.bold { 1.5 } else { 1.0 };
+            #[expect(
+                clippy::cast_precision_loss,
+                reason = "a cell holds at most 32 767 characters"
+            )]
+            let width = (characters as f64 + 3.0) * f64::from(font.half_points(base)) / 20.0 * bold;
+            let width = (width.min(MAX_WIDTH) * 100.0).round() / 100.0;
+            let widest = widths.entry(column).or_insert(0.0_f64);
+            *widest = widest.max(width);
+        }
+    }
+    widths
+}
+
+/// How many characters a cell shows unformatted: a text's longest line,
+/// a number's digits, `TRUE`, a date as `yyyy-mm-dd` and a time
+/// `yyyy-mm-dd hh:mm:ss`.
+fn characters(cell: &Cell) -> Option<usize> {
+    match cell {
+        Cell::Text(text) => text.split('\n').map(|line| line.chars().count()).max(),
+        Cell::Number(number) => Some(number.to_string().len()),
+        Cell::Bool(value) => Some(if *value { 4 } else { 5 }),
+        Cell::DateTime(date) => Some(if date.has_time() { 19 } else { 10 }),
+        Cell::Formula(_) => None,
+    }
+}

data/ext/imprimatur_native/core/src/xlsx/date.rs

@@ -90,6 +90,12 @@ impl DateTime {
         Self { hour: 0, minute: 0, second: 0, nanosecond: 0, ..self }
     }
 
+    /// Year, month and day.
+    #[must_use]
+    pub const fn year_month_day(&self) -> (u16, u8, u8) {
+        (self.year, self.month, self.day)
+    }
+
     /// Hours, minutes and seconds.
     #[must_use]
     pub const fn time_of_day(&self) -> (u8, u8, u8) {
@@ -147,7 +153,7 @@ const fn days_in_month(year: u16, month: u8) -> u8 {
 
 /// The calendar date `days` after 1970-01-01: the inverse of
 /// [`days_from_civil`] (Howard Hinnant's `civil_from_days`).
-const fn civil_from_days(days: i64) -> (i64, i64, i64) {
+pub const fn civil_from_days(days: i64) -> (i64, i64, i64) {
     let days = days + 719_468;
     let era = days.div_euclid(146_097);
     let day_of_era = days - era * 146_097;

data/ext/imprimatur_native/core/src/xlsx/format.rs

@@ -132,7 +132,7 @@ impl Format {
         if length == 0 || length > MAX_FONT_NAME || name.chars().any(char::is_control) {
             return Err(Error::InvalidFontName(name));
         }
-        self.font.name = (name != DEFAULT_FONT).then_some(name);
+        self.font.name = Some(name);
         Ok(self)
     }
 
@@ -147,7 +147,7 @@ impl Format {
         #[expect(clippy::cast_possible_truncation, reason = "a whole number from 2 to 818")]
         #[expect(clippy::cast_sign_loss, reason = "a whole number from 2 to 818")]
         let half_points = half_points as u16;
-        self.font.half_points = (half_points != DEFAULT_HALF_POINTS).then_some(half_points);
+        self.font.half_points = Some(half_points);
         Ok(self)
     }
 
@@ -213,13 +213,29 @@ pub struct Font {
 }
 
 impl Font {
-    pub(crate) fn name(&self) -> &str {
-        self.name.as_deref().unwrap_or(DEFAULT_FONT)
+    /// No name or size of its own: the workbook's, Calibri 11 by default.
+    pub(crate) const BASE: Self = Self {
+        bold: false,
+        italic: false,
+        underline: false,
+        color: None,
+        name: None,
+        half_points: None,
+    };
+
+    /// Its name, or else the workbook's `base` one.
+    pub(crate) fn name<'a>(&'a self, base: &'a Self) -> &'a str {
+        self.name.as_deref().or(base.name.as_deref()).unwrap_or(DEFAULT_FONT)
+    }
+
+    /// Its size in half points, or else the workbook's `base` one.
+    pub(crate) fn half_points(&self, base: &Self) -> u16 {
+        self.half_points.or(base.half_points).unwrap_or(DEFAULT_HALF_POINTS)
     }
 
     /// The size in points as `<sz>` writes it: `11`, `10.5`.
-    pub(crate) fn size(&self) -> String {
-        let half_points = self.half_points.unwrap_or(DEFAULT_HALF_POINTS);
+    pub(crate) fn size(&self, base: &Self) -> String {
+        let half_points = self.half_points(base);
         let whole = half_points / 2;
         if half_points.is_multiple_of(2) { whole.to_string() } else { format!("{whole}.5") }
     }

data/ext/imprimatur_native/core/src/xlsx/package.rs

@@ -1,10 +1,13 @@
 //! The parts of an `.xlsx` package and the relationships between them.
 
+use std::collections::BTreeMap;
 use std::fmt::Write as _;
 use std::io::Write;
 
+use super::autofit;
 use super::cell::{Cell, cell_reference, push_cell_reference};
 use super::comment;
+use super::format::Font;
 use super::styles::Stylesheet;
 use super::text::{SharedStrings, escape, needs_preserve};
 use super::validation;
@@ -28,7 +31,9 @@ const DRAWING_ID: &str = "rId2";
 /// compressed and dropped before the next is built, so only one sheet's XML
 /// is in memory at a time; the styles and the shared string table, complete
 /// only after every sheet, follow them.
-pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
+/// `font` is the workbook's: unformatted cells', and the formats' with no
+/// name or size.
+pub fn write<W: Write>(sheets: &[Worksheet], font: &Font, out: W) -> Result<W> {
     if sheets.is_empty() {
         return Err(Error::EmptyWorkbook);
     }
@@ -57,7 +62,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
     for (number, sheet) in (1..).zip(sheets) {
         let remap = styles.add_sheet(sheet)?;
         set(&mut name, format_args!("xl/worksheets/sheet{number}.xml"));
-        zip.add(&name, worksheet(sheet, &remap, &mut strings).as_bytes())?;
+        zip.add(&name, worksheet(sheet, &remap, &mut strings, font).as_bytes())?;
         let comments = sheet.comments();
         if comments.is_empty() {
             continue;
@@ -74,7 +79,7 @@ pub fn write<W: Write>(sheets: &[Worksheet], out: W) -> Result<W> {
         next_block += comment::blocks_for(comments.len());
     }
     debug_assert_eq!(has_strings, !strings.is_empty(), "the text scan matches the table");
-    zip.add("xl/styles.xml", styles.to_xml().as_bytes())?;
+    zip.add("xl/styles.xml", styles.to_xml(font).as_bytes())?;
     if has_strings {
         zip.add("xl/sharedStrings.xml", strings.to_xml().as_bytes())?;
     }
@@ -137,7 +142,12 @@ fn workbook(sheets: &[Worksheet]) -> String {
 
 /// `remap` turns the sheet's own style ids into the workbook's. The cell
 /// loop formats into three scratch buffers instead of allocating per cell.
-fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedStrings<'a>) -> String {
+fn worksheet<'a>(
+    sheet: &'a Worksheet,
+    remap: &[u32],
+    strings: &mut SharedStrings<'a>,
+    font: &Font,
+) -> String {
     let mut xml = XmlWriter::new();
     xml.open("worksheet", &[("xmlns", MAIN_NS), ("xmlns:r", opc::RELATIONSHIPS)]);
     xml.empty("dimension", &[("ref", &dimension(sheet))]);
@@ -146,7 +156,7 @@ fn worksheet<'a>(sheet: &'a Worksheet, remap: &[u32], strings: &mut SharedString
         xml.empty("sheetView", &[("rightToLeft", "1"), ("workbookViewId", "0")]);
         xml.close("sheetViews");
     }
-    write_columns(&mut xml, sheet);
+    write_columns(&mut xml, sheet, font);
     xml.open("sheetData", &[]);
     let (mut reference, mut style, mut value) = (String::new(), String::new(), String::new());
     for (row, cells) in sheet.rows() {
@@ -216,13 +226,17 @@ fn set(buffer: &mut String, value: impl std::fmt::Display) {
 }
 
 /// `<cols>`: one `<col>` per run of adjacent columns with the same width.
-fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet) {
-    let widths = sheet.column_widths();
+/// The columns' widths: those set, and for an autofit sheet those its cells
+/// need.
+fn write_columns(xml: &mut XmlWriter, sheet: &Worksheet, font: &Font) {
+    let mut widths =
+        if sheet.is_autofit() { autofit::widths(sheet, font) } else { BTreeMap::new() };
+    widths.extend(sheet.column_widths());
     if widths.is_empty() {
         return;
     }
     let mut runs: Vec<(u16, u16, f64)> = Vec::new();
-    for (&column, &width) in widths {
+    for (column, width) in widths {
         match runs.last_mut() {
             Some((_, last, run_width))
                 if *last + 1 == column && run_width.to_bits() == width.to_bits() =>

data/ext/imprimatur_native/core/src/xlsx/styles.rs

@@ -70,7 +70,8 @@ impl Stylesheet {
         Ok(remap)
     }
 
-    pub fn to_xml(&self) -> String {
+    /// The stylesheet, fonts without a name or size of their own in `base`.
+    pub fn to_xml(&self, base: &Font) -> String {
         let mut number_formats = Table::<&str>::new(FIRST_CUSTOM_NUMBER_FORMAT);
         let mut fonts = Table::<&Font>::new(1);
         let mut fills = Table::<Color>::new(2);
@@ -101,7 +102,7 @@ impl Stylesheet {
             }
             xml.close("numFmts");
         }
-        write_fonts(&mut xml, &fonts.order);
+        write_fonts(&mut xml, &fonts.order, base);
         write_fills(&mut xml, &fills.order);
         write_borders(&mut xml, &borders.order);
         xml.open("cellStyleXfs", &[("count", "1")]);
@@ -131,24 +132,24 @@ impl Stylesheet {
     }
 }
 
-fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font]) {
+/// Font 0, the one of unformatted cells, is `base`.
+fn write_fonts(xml: &mut XmlWriter, fonts: &[&Font], base: &Font) {
     let count = (fonts.len() + 1).to_string();
     xml.open("fonts", &[("count", &count)]);
-    let default = Font::default();
-    for font in std::iter::once(&default).chain(fonts.iter().copied()) {
+    for font in std::iter::once(base).chain(fonts.iter().copied()) {
         xml.open("font", &[]);
         for (on, tag) in [(font.bold, "b"), (font.italic, "i"), (font.underline, "u")] {
             if on {
                 xml.empty(tag, &[]);
             }
         }
-        xml.empty("sz", &[("val", &font.size())]);
+        xml.empty("sz", &[("val", &font.size(base))]);
         if let Some(color) = font.color {
             xml.empty("color", &[("rgb", &color.argb())]);
         }
-        xml.empty("name", &[("val", font.name())]);
+        xml.empty("name", &[("val", font.name(base))]);
         // The family is a fallback hint; only Calibri's is known (2, swiss).
-        if font.name() == DEFAULT_FONT {
+        if font.name(base) == DEFAULT_FONT {
             xml.empty("family", &[("val", "2")]);
         }
         xml.close("font");

data/ext/imprimatur_native/core/src/xlsx/worksheet.rs

@@ -6,6 +6,7 @@ use std::sync::Arc;
 
 use super::text::check_length;
 use super::{Cell, CellRange, Comment, Format, Validation};
+use crate::script::Counts;
 use crate::{Error, Result};
 
 /// Rows in a sheet (Excel 2007 and later).
@@ -40,7 +41,9 @@ pub struct Worksheet {
     /// The style of an unformatted date, then of an unformatted date and time.
     date_styles: [Option<u32>; 2],
     widths: BTreeMap<u16, f64>,
-    right_to_left: bool,
+    autofit: bool,
+    /// As set; `None` to follow the sheet's text.
+    right_to_left: Option<bool>,
     validations: Vec<(CellRange, Validation)>,
     comments: BTreeMap<(u32, u16), Comment>,
 }
@@ -55,7 +58,8 @@ impl Worksheet {
             format_ids: HashMap::new(),
             date_styles: [None; 2],
             widths: BTreeMap::new(),
-            right_to_left: false,
+            autofit: false,
+            right_to_left: None,
             validations: Vec::new(),
             comments: BTreeMap::new(),
         }
@@ -174,16 +178,40 @@ impl Worksheet {
         Ok(self)
     }
 
-    /// Lays the sheet out right to left: column `A` on the right, as Excel
-    /// shows sheets for Arabic and Hebrew.
+    /// Sizes the columns without a width of their own to their widest cell,
+    /// estimated from its characters and font as
+    /// `(characters + 3) × points / 10`, bold one and a half times wider.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
+    }
+
+    #[must_use]
+    pub const fn is_autofit(&self) -> bool {
+        self.autofit
+    }
+
+    /// Lays the sheet out right to left, column `A` on the right, as Excel
+    /// shows sheets for Arabic and Hebrew; or left to right. Without a
+    /// call, a sheet is right to left when most of the letters of its name
+    /// and text cells are.
     pub const fn set_right_to_left(&mut self, right_to_left: bool) -> &mut Self {
-        self.right_to_left = right_to_left;
+        self.right_to_left = Some(right_to_left);
         self
     }
 
     #[must_use]
-    pub const fn is_right_to_left(&self) -> bool {
-        self.right_to_left
+    pub fn is_right_to_left(&self) -> bool {
+        self.right_to_left.unwrap_or_else(|| {
+            let mut counts = Counts::default();
+            counts.add(&self.name);
+            for entry in self.rows.values().flat_map(BTreeMap::values) {
+                if let Cell::Text(text) = &entry.cell {
+                    counts.add(text);
+                }
+            }
+            counts.right_to_left()
+        })
     }
 
     /// Applies a rule to the cells of `range`, whether or not they hold values.

data/ext/imprimatur_native/core/src/xlsx.rs

@@ -1,5 +1,6 @@
 //! `SpreadsheetML` (`.xlsx`) workbooks, per ECMA-376 Part 1.
 
+mod autofit;
 mod cell;
 mod comment;
 mod date;
@@ -22,6 +23,9 @@ pub(crate) use cell::push_cell_reference;
 pub use cell::{Cell, cell_reference, column_name};
 pub use comment::Comment;
 pub use date::DateTime;
+#[cfg(feature = "archive")]
+pub(crate) use date::civil_from_days;
+use format::Font;
 pub use format::{Border, Format, VerticalAlign};
 pub use range::{CellRange, parse_cell_reference};
 pub use validation::{Alert, Validation};
@@ -36,12 +40,44 @@ const MAX_SHEET_NAME: usize = 31;
 #[derive(Debug, Default)]
 pub struct Workbook {
     sheets: Vec<Worksheet>,
+    /// The font of unformatted cells, and of formats with no name or size.
+    font: Font,
+    /// Whether new sheets size their columns to their cells.
+    autofit: bool,
 }
 
 impl Workbook {
     #[must_use]
     pub const fn new() -> Self {
-        Self { sheets: Vec::new() }
+        Self { sheets: Vec::new(), font: Font::BASE, autofit: false }
+    }
+
+    /// The font of cells without a format, and of formats that name no font:
+    /// Calibri unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontName`] for an empty name, one longer than 31
+    /// characters or with a control character.
+    pub fn set_font_name(&mut self, name: impl Into<String>) -> Result<&mut Self> {
+        self.font.name = Format::new().font_name(name)?.font.name;
+        Ok(self)
+    }
+
+    /// The size of cells without a format, and of formats that set none: 11
+    /// points unless set.
+    ///
+    /// # Errors
+    /// [`Error::InvalidFontSize`] outside 1 to 409 points in steps of 0.5.
+    pub fn set_font_size(&mut self, points: f64) -> Result<&mut Self> {
+        self.font.half_points = Format::new().font_size(points)?.font.half_points;
+        Ok(self)
+    }
+
+    /// Whether the sheets added from now on size their columns to their
+    /// cells, as [`Worksheet::set_autofit`] does.
+    pub const fn set_autofit(&mut self, autofit: bool) -> &mut Self {
+        self.autofit = autofit;
+        self
     }
 
     /// Adds a sheet after the existing ones and returns it for writing.
@@ -56,7 +92,8 @@ impl Workbook {
         if self.sheets.iter().any(|sheet| sheet.name().to_lowercase() == folded) {
             return Err(Error::DuplicateSheetName(name));
         }
-        Ok(self.sheets.push_mut(Worksheet::new(name)))
+        let autofit = self.autofit;
+        Ok(self.sheets.push_mut(Worksheet::new(name)).set_autofit(autofit))
     }
 
     #[must_use]
@@ -73,7 +110,7 @@ impl Workbook {
     /// # Errors
     /// [`Error::EmptyWorkbook`] without sheets, [`Error::Io`] when `out` fails.
     pub fn write_to<W: Write>(&self, out: W) -> Result<W> {
-        package::write(&self.sheets, out)
+        package::write(&self.sheets, &self.font, out)
     }
 
     /// The `.xlsx` package as bytes.

data/ext/imprimatur_native/core/src/xml/reader.rs

@@ -57,6 +57,16 @@ impl<'a> Tag<'a> {
         }
     }
 
+    /// The attribute parsed: `None` when it is missing or does not parse.
+    pub fn parse<T: std::str::FromStr>(&self, local: &str) -> Option<T> {
+        self.attr(local)?.parse().ok()
+    }
+
+    /// Whether the attribute is there and on: `1`, `true` or `on`.
+    pub fn on(&self, local: &str) -> bool {
+        self.attr(local).is_some() && self.flag(local)
+    }
+
     /// `w:val`-style booleans: present without a value, `1`, `true` or
     /// `on` are true; Word writes `w:val="0"` to switch a property off.
     pub fn flag(&self, local: &str) -> bool {

data/ext/imprimatur_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "imprimatur_native"
-version = "0.1.0"
+version = "0.3.0"
 description = "Ruby bindings for the imprimatur crate"
 publish = false
 edition.workspace = true
@@ -15,7 +15,8 @@ crate-type = ["cdylib"]
 workspace = true
 
 [dependencies]
-imprimatur = { workspace = true, features = ["json"] }
+# Gems ship precompiled, so they carry every feature of the crate.
+imprimatur = { workspace = true, features = ["archive", "fonts", "json"] }
 serde_json.workspace = true
 magnus.workspace = true
 rb-sys.workspace = true

data/ext/imprimatur_native/ffi/src/archive.rs

@@ -0,0 +1,119 @@
+//! `Imprimatur::Native::ZipWriter` and `ZipReader`: zip archives of any
+//! files, compressed and read without the GVL.
+
+use std::cell::RefCell;
+use std::fs::File;
+
+use imprimatur::archive::{Archive, Writer};
+use magnus::{Error, RString, Ruby};
+
+use crate::blocking::without_gvl;
+use crate::{OrRaise, borrow};
+
+#[magnus::wrap(class = "Imprimatur::Native::ZipWriter", free_immediately, size)]
+pub struct ZipWriter(RefCell<Option<Writer<File>>>);
+
+fn finished(ruby: &Ruby) -> Error {
+    Error::new(ruby.exception_runtime_error(), "the archive is finished")
+}
+
+#[expect(clippy::needless_pass_by_value, reason = "magnus passes Ruby arguments as owned values")]
+impl ZipWriter {
+    /// A new archive at `path`.
+    pub fn new(ruby: &Ruby, path: String) -> Result<Self, Error> {
+        Ok(Self(RefCell::new(Some(Writer::create(path).or_raise(ruby)?))))
+    }
+
+    /// Adds the file at `source` as `name`, streamed.
+    pub fn add_file(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        source: String,
+        comment: Option<String>,
+    ) -> Result<(), Error> {
+        let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
+        let writer = slot.as_mut().ok_or_else(|| finished(ruby))?;
+        without_gvl(ruby, || writer.add_file(&name, &source, comment.as_deref()))?.or_raise(ruby)
+    }
+
+    /// Adds `data` as `name`.
+    pub fn add(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        data: RString,
+        comment: Option<String>,
+    ) -> Result<(), Error> {
+        let data = crate::bytes(data);
+        let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
+        let writer = slot.as_mut().ok_or_else(|| finished(ruby))?;
+        without_gvl(ruby, || writer.add(&name, &data, comment.as_deref()))?.or_raise(ruby)
+    }
+
+    /// The archive's own comment.
+    pub fn set_comment(ruby: &Ruby, rb_self: &Self, comment: String) -> Result<(), Error> {
+        let mut slot = borrow(ruby, &rb_self.0, "zip writer")?;
+        slot.as_mut().ok_or_else(|| finished(ruby))?.set_comment(&comment).or_raise(ruby)
+    }
+
+    /// Writes the archive's directory; the writer takes no more entries.
+    pub fn finish(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        let writer =
+            borrow(ruby, &rb_self.0, "zip writer")?.take().ok_or_else(|| finished(ruby))?;
+        without_gvl(ruby, || writer.finish())?.or_raise(ruby).map(drop)
+    }
+}
+
+/// An entry for Ruby: name, size, compressed size, CRC-32, comment.
+type EntryRow = (String, u64, u64, u32, String);
+
+#[magnus::wrap(class = "Imprimatur::Native::ZipReader", free_immediately, size)]
+pub struct ZipReader(RefCell<Archive<File>>);
+
+#[expect(clippy::needless_pass_by_value, reason = "magnus passes Ruby arguments as owned values")]
+impl ZipReader {
+    /// The archive at `path`.
+    pub fn new(ruby: &Ruby, path: String) -> Result<Self, Error> {
+        Ok(Self(RefCell::new(Archive::open(path).or_raise(ruby)?)))
+    }
+
+    pub fn names(ruby: &Ruby, rb_self: &Self) -> Result<Vec<String>, Error> {
+        Ok(borrow(ruby, &rb_self.0, "zip archive")?.names())
+    }
+
+    /// Each entry's name, size, compressed size, CRC-32 and comment.
+    pub fn entries(ruby: &Ruby, rb_self: &Self) -> Result<Vec<EntryRow>, Error> {
+        let entries = borrow(ruby, &rb_self.0, "zip archive")?.entries().or_raise(ruby)?;
+        Ok(entries
+            .into_iter()
+            .map(|entry| {
+                (entry.name, entry.size, entry.compressed_size, entry.crc32, entry.comment)
+            })
+            .collect())
+    }
+
+    /// The entry's bytes, `nil` when there is none.
+    pub fn read(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        limit: u64,
+    ) -> Result<Option<RString>, Error> {
+        let mut archive = borrow(ruby, &rb_self.0, "zip archive")?;
+        let data = without_gvl(ruby, || archive.read(&name, limit))?.or_raise(ruby)?;
+        Ok(data.map(|data| ruby.str_from_slice(&data)))
+    }
+
+    /// Writes the entry to `path`; whether there was one.
+    pub fn extract(
+        ruby: &Ruby,
+        rb_self: &Self,
+        name: String,
+        path: String,
+        limit: u64,
+    ) -> Result<bool, Error> {
+        let mut archive = borrow(ruby, &rb_self.0, "zip archive")?;
+        without_gvl(ruby, || archive.extract(&name, &path, limit))?.or_raise(ruby)
+    }
+}

data/ext/imprimatur_native/ffi/src/blocking.rs

@@ -0,0 +1,63 @@
+//! Work run without the GVL that cannot stop midway (compressing a file):
+//! Ruby's other threads keep running, and an interrupt waits for the end.
+
+use std::ffi::c_void;
+use std::panic::{AssertUnwindSafe, catch_unwind};
+
+use magnus::{Error, Ruby};
+
+/// Runs interrupted before they start are retried this many times.
+pub const MAX_ATTEMPTS: usize = 64;
+
+/// The job, and what it returned (or that it panicked).
+struct Slot<F, T> {
+    job: Option<F>,
+    result: Option<std::thread::Result<T>>,
+}
+
+/// Runs `job` on this thread with the GVL released.
+pub fn without_gvl<F: FnOnce() -> T, T>(ruby: &Ruby, job: F) -> Result<T, Error> {
+    let mut slot = Slot { job: Some(job), result: None };
+    let pointer: *mut Slot<F, T> = &raw mut slot;
+    for _ in 0..MAX_ATTEMPTS {
+        // SAFETY: `slot` outlives the call, which returns once `run` has
+        // finished or never started; `run` touches no Ruby object. Without
+        // an unblocking function the job runs to its end; the `2` variant
+        // raises no pending interrupt across these Rust frames.
+        #[allow(unsafe_code)]
+        unsafe {
+            rb_sys::rb_thread_call_without_gvl2(
+                Some(run::<F, T>),
+                pointer.cast(),
+                None,
+                std::ptr::null_mut(),
+            );
+        }
+        match slot.result.take() {
+            Some(Ok(value)) => return Ok(value),
+            Some(Err(_)) => {
+                return Err(Error::new(
+                    ruby.exception_runtime_error(),
+                    "imprimatur failed on this archive",
+                ));
+            }
+            // An interrupt was pending, so the job never started: let Ruby
+            // handle it (it may raise), then start.
+            None => ruby.thread_check_ints()?,
+        }
+    }
+    Err(Error::new(ruby.exception_runtime_error(), "interrupted before it could start"))
+}
+
+/// The job itself, without the GVL; a panic becomes an error, not an
+/// abort at this C boundary.
+#[allow(unsafe_code)]
+unsafe extern "C" fn run<F: FnOnce() -> T, T>(data: *mut c_void) -> *mut c_void {
+    // SAFETY: `data` is the `Slot` without_gvl passed, alive and not
+    // otherwise borrowed until this returns.
+    let slot = unsafe { &mut *data.cast::<Slot<F, T>>() };
+    if let Some(job) = slot.job.take() {
+        slot.result = Some(catch_unwind(AssertUnwindSafe(job)));
+    }
+    std::ptr::null_mut()
+}