imprimatur 0.5.0-aarch64-linux-gnu → 0.6.1-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6d6451a7a370921f43b37e27a8edb7d886a4923981afd28a256b424b85234e
-  data.tar.gz: e74c978a45ce43cc0856b186b71f38d3204aea8cb71c4f0ed5d961bd4f0dc874
+  metadata.gz: 0c846ab26c3cce1cfd29ad57abec947eac5c8df63a8632edc28449b7130aa6ff
+  data.tar.gz: 9df791e2413c83d76620a696fb8f0a8b24c13504637ae08663f027fb695c90da
 SHA512:
-  metadata.gz: bf5c3cc806be6379e109c335d65e4b1f84662cbdcb569db4ae0e9fd0e028d4185cf0f9f0b4cd7cc37ac00cc8a313878aaddaee276898b5835e4365f25fe0dfb4
-  data.tar.gz: 0ac1716d1208f48001683efafd3bba638ddc134ff1d67c545a7ad123f99213ee9ff83a96eb7603ca3f3f64ba1cdb8a14507128f530adf21c3e6a5ab989ebca95
+  metadata.gz: d889377347b347029cef45c2bdeb0d721b10bd9f7a67320a3358e7a49a83a92f3280b7dd43700f70cc33e9a773cf742cb61b88cfb4bc032821386720c8dbbd0b
+  data.tar.gz: 82311d23c3f95907dd1c3bf97e7da8c2e15c5faf466006d1250b950c2c5a33c5018e157f5479b50979426eea7b8766c74e1c78ca17cda66440163b9b63101fca

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## Unreleased
+
+- Isolate PDF metadata and text reads in the bundled resource-limited Rust
+  worker, as rendering already is; all three accept `memory_bytes:`.
+- On Linux/FreeBSD, re-exec the worker under its address-space limit before
+  reading the PDF, including tiny metadata-only reads.
+- Preserve completed pages on worker termination and recover healthy neighbors
+  after page-local stream limits without renewing the overall deadline.
+- Allow a bounded exit grace when macOS cannot inspect an exiting worker;
+  persistent monitor failures still terminate and reap a live worker.
+
+## [0.6.1](https://github.com/seuros/imprimatur/compare/v0.6.0...v0.6.1) (2026-10-25)
+
+
+### Bug Fixes
+
+* **pdf:** isolate bounded reads and preserve page recovery ([fbfbbc5](https://github.com/seuros/imprimatur/commit/fbfbbc5e7e44768efae293b37be255b8b797f831))
+
+## [0.6.0](https://github.com/seuros/imprimatur/compare/v0.5.0...v0.6.0) (2026-10-25)
+
+
+### Features
+
+* bound PDF reads and rendering; deduplicate Rust ([420e096](https://github.com/seuros/imprimatur/commit/420e096591ef08190427c7b090840dcd761010b4))
+* **doc:** set the body font size ([44f7617](https://github.com/seuros/imprimatur/commit/44f76170fd1ad29f143c1ef22c355fd1c1cbf8e1))
+
+
+### Bug Fixes
+
+* enforce render limits across Unix platforms ([5c7f0ba](https://github.com/seuros/imprimatur/commit/5c7f0bab2076681782c6bfa2de6062ad53c0e7f9))
+
 ## [0.5.0](https://github.com/seuros/imprimatur/compare/v0.4.0...v0.5.0) (2026-10-18)
 
 

data/README.md

@@ -7,10 +7,9 @@ a 40,000-character cell is refused at the door, not discovered by Excel's
 
 - **A Ruby DSL over a native core.** The core is also published on its own,
   as `imprimatur` on crates.io; the gem wraps it.
-- **No third-party format stack.** The XML writer and the zip container are
-  written here, from ECMA-376 and the zip specification; only deflate
-  (`miniz_oxide`) and CRC-32 (`crc32fast`) come from crates, and QR Code and
-  Data Matrix encoding (`qrcode`, `datamatrix`) for barcodes.
+- **Own readers and writers.** XML, zip and PDF reading/writing live here.
+  Optional full-page PDF rendering uses Hayro, a pure-Rust CPU renderer;
+  no Poppler, PDFium, GPU or system fonts are required.
 - **Deterministic.** The same document always gives the same bytes.
 - **Native only.** CRuby 4.0+. No pure Ruby fallback, no JRuby, no TruffleRuby.
 
@@ -178,7 +177,7 @@ Not yet: merged cells, frozen panes, streaming for very large sheets.
 One document, two formats:
 
 ```ruby
-doc = Imprimatur::Document.new(page_size: :a4, page_numbers: true)
+doc = Imprimatur::Document.new(page_size: :a4, font_size: 10, page_numbers: true)
 doc.heading "Quarterly report"
 doc.heading "Sales", level: 2
 doc.paragraph do |p|
@@ -195,12 +194,14 @@ doc.paragraph "Appendix."
 doc.save_pdf("report.pdf")
 doc.save_docx("report.docx")
 
-Imprimatur.pdf("memo.pdf") { it.paragraph "Or in one go." }    # Imprimatur.docx alike
+Imprimatur.pdf("memo.pdf", font_size: 10) { it.paragraph "Or in one go." } # Imprimatur.docx alike
 Imprimatur.pdf(page_size: [200, 200], margin: 10) { it.image qr_png, width: 180 }
 ```
 
 - Headings 1 to 3 (real Word heading styles in DOCX), paragraphs of runs
   (bold, italic, underline, color), alignment, `\n` line breaks and tabs.
+- Body text at `font_size:` points (1 to 1638, in steps of 0.5; 11 unless
+  set), in both formats; headings keep their own sizes.
 - Tables: equal columns, borders, a shaded header row that repeats on every
   page; cells are converted with `to_s`.
 - Pictures: PNG or JPEG (a path, the bytes or an IO), at `width:` or
@@ -333,6 +334,61 @@ pages of headings and paragraphs with their position, a workbook's typed
 cells and comments, a Word document's blocks with their bold, italic and
 linked stretches.
 
+For a PDF without text, `content` still returns every page, its empty
+`blocks` and its `images` count. `markdown` and the text-oriented CLI commands
+still report `NoTextLayer`;
+OCR callers need the structure of scanned and blank pages too.
+
+### Bounded PDF pages and OCR rendering
+
+```ruby
+Imprimatur.pdf_info(upload.download) # => {page_count: 20, encrypted: false}
+result = Imprimatur.pdf_pages(upload.download, first_page: 2, last_page: 10, max_pages: 5)
+result[:pages].each { |page| puts [page[:page], page[:status], page[:text]] }
+png = Imprimatur.render_pdf_page(upload.download, page: 2, max_side: 1568)
+```
+
+`pdf_info` counts actual pages without interpreting their content. `pdf_pages`
+only interprets the selected streams, at most 500 pages by default. Each page
+has `status` (`text`, `empty`, `failed`, `skipped`), `text`, `images` (nil if
+unknown), `truncated` and `reason`. It keeps healthy pages when another is
+damaged. Unlike the tolerant Markdown reader, corrupt Flate streams fail
+explicitly. Limits are 256 KiB of text per page and 8 MiB total
+(`max_page_bytes:`, `max_output_bytes:`); truncation respects UTF-8.
+
+`render_pdf_page` returns an opaque grayscale PNG of the **whole page**, not
+just its scan image; `grayscale: false` keeps color. It bounds the output surface
+before allocation (`max_pixels:`, 4 million) and encoded output
+(`max_output_bytes:`, 8 MiB). Preflight rejects pages drawing more than 40 million
+source-image pixels. Renderer warnings fail instead of silently dropping content.
+The crate exposes `read::pdf::{info, pages, render_page}` (`render` feature) and
+`read::pdf::isolation::{info_isolated, pages_isolated, render_page_isolated}`
+(`isolation` feature). These take an absolute path to the trusted
+`imprimatur-render-worker` executable. The gem bundles that worker and always
+isolates all three PDF operations; it never falls back to in-process parsing
+or searches PATH.
+
+All three accept the normal read limits and `memory_bytes:`
+(1 GiB by default): Linux/FreeBSD enforce an address-space cap; macOS uses a
+sampled RSS watchdog, which can briefly overshoot. A worker is killed and reaped
+on timeout, cancellation or supervisor failure. Each operation has a mandatory
+60-second process ceiling even with `timeout: nil`; a shorter `timeout:` still
+applies. CPU time, output files and core dumps are also limited.
+
+The page worker flushes completed records as it goes. An exhausted stream
+budget triggers individual-page recovery inside that worker: each attempt has
+its own `max_inflated` allowance, while the original overall deadline, process
+memory limit and aggregate text cap remain in force. An oversized page is
+`failed`, not blank, without discarding healthy neighbors. A worker terminated
+after metadata was read preserves completed pages and explicitly marks the
+unreached pages; an expired overall deadline marks them `skipped`. Cancellation
+still raises rather than returning a partial successful call.
+
+This is resource containment, **not a filesystem/network security sandbox**.
+The raw crate `info`, `pages` and `render_page` APIs remain in-process;
+`render_page` cannot interrupt Hayro.
+`max_inflated` bounds our preflight, not Hayro's internal decoders.
+
 ```ruby
 sheet = Imprimatur.content("sales.xlsx")[:sheets].first
 sheet[:rows][1][:cells]
@@ -441,7 +497,7 @@ The core works without Ruby too; see
 
 ```sh
 bundle install
-rake test:all        # cargo test, then the Ruby suite on the compiled extension
+rake test:all        # core, CLI and Ruby suites on the compiled extension
 rake lint            # dictator, cargo fmt --check, clippy
 rake gems:native     # the precompiled gem for this machine, in pkg/
 ```

data/lib/imprimatur/document.rb

@@ -21,10 +21,11 @@ module Imprimatur
     # @param page_size [:a4, :letter, Array(Numeric, Numeric)] or its width
     #   and height in points, 36 to 1584 a side
     # @param margin [Numeric, nil] points on every side, one inch (72) unless set
+    # @param font_size [Numeric, nil] body text in points, 1 to 1638 in steps of 0.5; 11 unless set
     # @param page_numbers [Boolean] number pages "1 / N" in the footer
     # @raise [ArgumentError] an unknown page size
-    # @raise [Imprimatur::Error] a page size or margin out of range
-    def initialize(page_size: :a4, margin: nil, page_numbers: false)
+    # @raise [Imprimatur::Error] a page size, margin or font size out of range
+    def initialize(page_size: :a4, margin: nil, font_size: nil, page_numbers: false)
       @native = Native::Document.new
       numbers = page_numbers ? true : false
       if page_size.is_a?(Array)
@@ -34,6 +35,7 @@ module Imprimatur
         @native.set_page(page_size.to_s, numbers)
       end
       @native.set_margin(Float(margin)) if margin
+      @native.set_font_size(Float(font_size)) if font_size
     end
 
     # A PNG or JPEG in the flow, at +width+ or +height+ points (the other

data/lib/imprimatur/native.rb

@@ -15,3 +15,10 @@ rescue LoadError => e
   raise LoadError, "imprimatur: the native extension did not load (#{e.message}). " \
                    'Install a platform gem, or build it with `rake compile` (toolchain: https://rustup.rs).'
 end
+
+module Imprimatur
+  # Always use the companion of the loaded extension, never PATH.
+  RENDER_WORKER = File.join(File.dirname($LOADED_FEATURES.find do |path|
+    path.end_with?("/imprimatur_native.#{RbConfig::CONFIG['DLEXT']}")
+  end), 'imprimatur-render-worker').freeze
+end

data/lib/imprimatur/pdf_reader.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Imprimatur
+  # Keyword handling only; parsing, limits and rendering live in the native core.
+  module PdfReader
+    def self.info(document, memory_bytes: 1024 * 1024 * 1024, max_bytes: nil, **limits)
+      JSON.parse(Native.pdf_info(Reader.read(document, max_bytes), Reader.limits(max_bytes:, **limits),
+                                 RENDER_WORKER, memory_bytes),
+                 symbolize_names: true)
+    end
+
+    def self.pages(document, first_page: 1, last_page: 0xFFFFFFFF, max_pages: 500,
+                   max_page_bytes: 256 * 1024, max_output_bytes: 8 * 1024 * 1024,
+                   memory_bytes: 1024 * 1024 * 1024, max_bytes: nil, **limits)
+      options = [first_page, last_page, max_pages, max_page_bytes, max_output_bytes]
+      JSON.parse(Native.pdf_pages(Reader.read(document, max_bytes), Reader.limits(max_bytes:, **limits),
+                                  options, RENDER_WORKER, memory_bytes),
+                 symbolize_names: true)
+    end
+
+    def self.render(document, page:, max_side: 1568, max_pixels: 4_000_000,
+                    max_output_bytes: 8 * 1024 * 1024, grayscale: true,
+                    memory_bytes: 1024 * 1024 * 1024, max_bytes: nil, **limits)
+      Native.render_pdf_page(Reader.read(document, max_bytes), Reader.limits(max_bytes:, **limits),
+                            [page, max_side, max_pixels, max_output_bytes, grayscale],
+                            RENDER_WORKER, memory_bytes)
+    end
+  end
+end

data/lib/imprimatur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imprimatur
-  VERSION = '0.5.0'
+  VERSION = '0.6.1'
 end

data/lib/imprimatur.rb

@@ -10,6 +10,7 @@ require_relative 'imprimatur/barcode'
 require_relative 'imprimatur/xlsx'
 require_relative 'imprimatur/document'
 require_relative 'imprimatur/reader'
+require_relative 'imprimatur/pdf_reader'
 require_relative 'imprimatur/spreadsheet'
 require_relative 'imprimatur/zip'
 
@@ -45,7 +46,7 @@ module Imprimatur
     # Builds a {Document} and renders it as PDF. With a path, saves it there
     # and returns the path; without, returns the bytes.
     #
-    # @param options [Hash] +page_size:+ and +page_numbers:+, see {Document#initialize}
+    # @param options [Hash] +page_size:+, +margin:+, +font_size:+ and +page_numbers:+, see {Document#initialize}
     # @yieldparam document [Document]
     def pdf(path = nil, **options, &) = Document.build(:pdf, path, **options, &)
 
@@ -92,7 +93,11 @@ module Imprimatur
     #   sheet = Imprimatur.content('sales.xlsx')[:sheets].first
     #   sheet[:rows][1][:cells]  # => [{cell: "A2", type: "text", value: "North"}, ...]
     #
-    # Takes the arguments of {.markdown}, and raises as it does. With
+    # Unlike {.markdown}, a PDF without text still returns every page, with
+    # empty +:blocks+ and its image count, rather than raising {NoTextLayer}.
+    # This keeps scanned and blank pages visible to OCR callers.
+    #
+    # Takes the arguments of {.markdown}, and raises as it does otherwise. With
     # +styles: true+ each sheet also lists its formatted cells' +:styles+:
     # font, size, bold, italic, underline, ARGB color and fill, alignment,
     # wrap, border and number format.
@@ -100,6 +105,25 @@ module Imprimatur
     # @return [Hash] with symbol keys; +:format+ is +"pdf"+, +"xlsx"+ or +"docx"+
     def content(document, ...) = Reader.content(document, ...)
 
+    # PDF metadata without reading page content.
+    # @return [Hash] +page_count:+ and +encrypted:+
+    def pdf_info(document, ...) = PdfReader.info(document, ...)
+
+    # A bounded, one-based page selection. Each page has its status, text,
+    # image count (nil when unknown), truncation flag and failure reason.
+    # Takes +first_page:+, +last_page:+, +max_pages:+ (500),
+    # +max_page_bytes:+ (256 KiB), +max_output_bytes:+ (8 MiB), and read limits.
+    # @return [Hash] +page_count:+, +encrypted:+ and +pages:+
+    def pdf_pages(document, ...) = PdfReader.pages(document, ...)
+
+    # A full page as an opaque PNG, not just its embedded images.
+    # Takes +page:+ (one-based), +max_side:+ (1568), +max_pixels:+ (4 million),
+    # +max_output_bytes:+ (8 MiB), +grayscale:+ (true), and read limits.
+    # Rendering checks time/cancellation before and after Hayro, not during it.
+    # Untrusted documents still need an externally limited worker process.
+    # @return [String] PNG bytes
+    def render_pdf_page(document, ...) = PdfReader.render(document, ...)
+
     # A workbook's sheets and their values, read from the same documents
     # {.markdown} takes (+.xlsx+, +.xls+, +.ods+); see {Spreadsheet}.
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imprimatur
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: aarch64-linux-gnu
 authors:
 - Abdelkader Boudih
@@ -10,9 +10,10 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: 'A Ruby DSL over a native core that writes Excel workbooks, and PDF and
-  Word documents from one model, with its own XML, zip and PDF writers: no third-party
-  format stack. It reads PDF, XLSX, XLS, ODS and DOCX back: as Markdown, as typed
-  structure, and their images. Precompiled for Linux, macOS and FreeBSD; CRuby only.'
+  Word documents from one model, with its own XML, zip and PDF readers and writers.
+  It reads PDF, XLSX, XLS, ODS and DOCX back: as Markdown, as typed structure, and
+  their images. Full-page PDF rendering uses the pure-Rust Hayro renderer. Precompiled
+  for Linux, macOS and FreeBSD; CRuby only.'
 email:
 - terminale@gmail.com
 executables: []
@@ -23,12 +24,14 @@ files:
 - LICENSE.txt
 - README.md
 - lib/imprimatur.rb
+- lib/imprimatur/4.0/imprimatur-render-worker
 - lib/imprimatur/4.0/imprimatur_native.so
 - lib/imprimatur/barcode.rb
 - lib/imprimatur/document.rb
 - lib/imprimatur/error.rb
 - lib/imprimatur/formula.rb
 - lib/imprimatur/native.rb
+- lib/imprimatur/pdf_reader.rb
 - lib/imprimatur/reader.rb
 - lib/imprimatur/spreadsheet.rb
 - lib/imprimatur/style.rb