page_print 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4756973315a1710c09f8fb293da5057e5a16690d128a55e63b1e36dbec037ea6
-  data.tar.gz: e267eadccf8a7dcc8efb43f90d968fc016dafb43e9ff2610cbd0258c3340199b
+  metadata.gz: ca32ba67da6a5c3cfe5c66b3eac1242ffc1068ccce7838820d4550fffbe9d73d
+  data.tar.gz: 90ad2b4d3612d123f562ebd43098ed110c2ccb608d058409c496ce76e455e25d
 SHA512:
-  metadata.gz: 486e05765bcc2f15584c1c694468c7c1cd4fe000bb5c20e71b1ece8006068f154b287969a8b902232d2e1414b0d0807edaf0ecbb8f143195e220e9a84da770d4
-  data.tar.gz: d58d39763a9ba7f6da46e0d0449e4be802de2f067773345a51003960775d2a0f785e98ffe145c8d8df96356421b9ed64707b018ce28ce36f2dc31e8bbf36bd60
+  metadata.gz: 68dc83310a8f0d25281d22f1d66c771c2d87a855c4802690df8ecf2e3bc74127602d405ccc4746ddf4d1495f94aa079aa3cc4668f023ca68bccec3360096b46a
+  data.tar.gz: 3fa636884d4c816a4aea7c3b34262a3f21c1d09e59c44cc8b0fde3c2bb145cdfbc26a5a9468c636d92057cfa8736906c671933e0b97f1b2ba1bafd183f21d3d5

data/README.md

@@ -1,284 +1,205 @@
 # PagePrint
 
+Fast, in-process HTML-to-PDF rendering for Ruby, powered by [PlutoBook](https://github.com/plutoprint/plutobook).
+
 > [!IMPORTANT]
-> PagePrint is not production-ready yet. The gem is still in active testing, especially around native packaging and platform compatibility.
+> PagePrint is still pre-1.0 and is not yet recommended as a drop-in production dependency without application-specific testing. Native packaging and platform compatibility are still being validated. See the [production guide](docs/production.md) before deploying it.
 
-`page_print` renders HTML strings to PDF files from Ruby using the `plutobook` library through a native C extension.
+PagePrint turns an HTML string into PDF bytes—or writes it directly to a file—through a small native C extension. It is designed for server-generated documents such as invoices, reports, labels, and statements where the HTML is known in advance and does not depend on JavaScript.
 
-It exists as a faster, simpler alternative to PDFKit and other `wkhtmltopdf`-based gems. There is no external renderer process to shell out to, and the public Ruby API is intentionally small.
 
-## Installation
+## Why PagePrint?
 
-Add PagePrint to your Gemfile:
+PDFKit and Wicked PDF render documents by launching the `wkhtmltopdf` executable. PagePrint instead embeds a purpose-built paged-media renderer in the Ruby process.
 
-```ruby
-gem "page_print"
-```
+That gives PagePrint a few useful properties:
 
-Or install from RubyGems directly:
+- **No renderer subprocess:** no executable discovery, shelling out, or process startup per render.
+- **A small Ruby API:** pass HTML in and receive PDF bytes, or write directly to a path.
+- **Print-oriented CSS:** PlutoBook supports paged-media features such as `@page`, page counters, and running headers and footers.
+- **Controlled resource loading:** PagePrint does not fetch unresolved HTTP URLs. Your application decides which stylesheets, images, and fonts may be loaded.
+- **Rails asset integration:** Propshaft and `public/assets` resources work without HTTP requests back into the application.
 
-```sh
-gem install page_print
-```
+### How does it compare with PDFKit and Wicked PDF?
 
-Native gems are published for `x86_64-linux` and `arm64-darwin`. Other platforms build from source and require PlutoBook development headers and library files.
+PDFKit and Wicked PDF are Ruby integrations for `wkhtmltopdf`; their rendering behavior and operational requirements come from that executable.
 
-## Rails Usage
+| | PagePrint / PlutoBook | PDFKit or Wicked PDF / `wkhtmltopdf` |
+| --- | --- | --- |
+| Runtime model | Native library in the Ruby process | External `wkhtmltopdf` executable |
+| Rendering engine | Purpose-built for static documents and CSS paged media | Legacy Qt WebKit browser engine |
+| JavaScript | Not supported | Supported by legacy Qt WebKit |
+| Network access | Denied unless your fetcher supplies the resource | Built in |
+| CSS compatibility | Print-focused and partial; no CSS Grid | Limited by the old WebKit engine |
+| Operational footprint | Native gem and bundled libraries on supported platforms | `wkhtmltopdf` binary plus Qt/WebKit dependencies |
+| Upstream status | PagePrint currently packages PlutoBook 0.19.0 | `wkhtmltopdf` was archived in 2023 |
 
-PagePrint is optimized for Rails applications using Propshaft. In Rails, PagePrint installs a default Propshaft-backed resource fetcher and uses the current request URL as the default `base_url`.
+PagePrint is a strong fit when you control the templates, value predictable print layout, and do not need JavaScript. Stay with a `wkhtmltopdf`-based gem if your existing templates depend on its JavaScript or WebKit-specific rendering behavior. When migrating, compare representative output carefully because changing engines can alter pagination, fonts, and layout.
 
-Render a PDF from a controller:
+The `wkhtmltopdf` project was [archived in 2023](https://github.com/wkhtmltopdf/wkhtmltopdf) and its own [status document](https://github.com/wkhtmltopdf/wkhtmltopdf/blob/master/docs/status.md) describes its Qt 4 / WebKit stack as unsupported and outdated. PlutoBook is purpose-built for static paged output, but has a narrower feature set; review its [feature matrix](https://github.com/plutoprint/plutobook/blob/main/FEATURES.md) before migrating a complex template.
+
+## Installation
+
+Add the gem to your `Gemfile`:
 
 ```ruby
-class PrintsController < ApplicationController
-  def pdf
-    html = render_to_string(template: "prints/pdf", formats: [:html], layout: "pdf")
-    pdf = PagePrint.html_to_pdf_string(
-      html,
-      page_size: :a4,
-      margins: :normal,
-      media: :print,
-      metadata: { title: "Print PDF", author: "PagePrint" }
-    )
-
-    send_data pdf, filename: "print.pdf", type: "application/pdf", disposition: "inline"
-  end
-end
+gem "page_print"
 ```
 
-Use normal Rails asset helpers in the PDF template or layout:
+Then run:
 
-```erb
-<%= stylesheet_link_tag "pdf" %>
-<%= image_tag "logo.png" %>
+```sh
+bundle install
 ```
 
-During controller actions, PagePrint defaults `base_url` to `request.base_url`. The default Rails resource fetcher resolves `/assets/...` through Propshaft or `public/assets`, avoiding HTTP requests back to the Rails app.
-
-You can still override `base_url` explicitly:
+PagePrint requires Ruby 3.2 or newer. Native gems with vendored PlutoBook libraries are published for:
 
-```ruby
-pdf = PagePrint.html_to_pdf_string(html, base_url: "https://example.com")
-```
+- `x86_64-linux`
+- `arm64-darwin` (Apple Silicon)
 
-Override the fetcher only when needed:
+Other platforms build from source and require PlutoBook development headers and libraries. See [Installing on other platforms](docs/production.md#installing-on-other-platforms).
 
-```ruby
-# config/initializers/page_print.rb
-PagePrint.configure do |config|
-  config.resource_fetcher = MyResourceFetcher.new
-end
-```
+## Quick start
 
-## Ruby Usage
+Require PagePrint and render an HTML string:
 
 ```ruby
 require "page_print"
-require "tmpdir"
 
 html = <<~HTML
+  <!doctype html>
   <html>
+    <head>
+      <meta charset="utf-8">
+      <style>
+        @page {
+          size: A4;
+
+          @bottom-center {
+            content: counter(page) " / " counter(pages);
+            color: #666;
+            font-size: 10pt;
+          }
+        }
+
+        body { font-family: sans-serif; }
+      </style>
+    </head>
     <body>
-      <h1>Hello</h1>
-      <p>This PDF was generated by PagePrint.</p>
+      <h1>Invoice #1042</h1>
+      <p>Thank you for your business.</p>
     </body>
   </html>
 HTML
 
-output_path = File.join(Dir.tmpdir, "page_print-output.pdf")
-
-PagePrint.html_to_pdf(html, output_path, base_url: "https://example.com")
+pdf = PagePrint.render(html, page_size: :a4, margins: :normal)
 ```
 
-To get the generated PDF as a binary string instead of writing directly to a file:
+For large documents, write directly to a file instead of retaining the PDF in a Ruby string:
 
 ```ruby
-pdf = PagePrint.html_to_pdf_string(html, base_url: "https://example.com")
+PagePrint.render_to_file(html, "invoice.pdf", page_size: :a4, margins: :normal)
 ```
 
-Use custom page dimensions and margins when a preset is not enough:
+`render_to_file` returns `true`; `render` returns an `ASCII-8BIT` Ruby string containing the PDF.
 
-```ruby
-pdf = PagePrint.html_to_pdf_string(
-  html,
-  page_size: { width: 100, height: 150, unit: :mm },
-  margins: { top: 5, right: 6, bottom: 7, left: 8, unit: :mm }
-)
-```
+## Rails
 
-You can configure default options once, for example to provide a resource fetcher used by all renders:
+PagePrint integrates automatically with Rails applications that use Propshaft. Render a template to HTML, pass it to PagePrint, then send the resulting bytes:
 
 ```ruby
-PagePrint.configure do |config|
-  config.resource_fetcher = lambda do |url|
-    next unless url == "asset:pdf.css"
+class InvoicesController < ApplicationController
+  def show
+    html = render_to_string(template: "invoices/show", formats: [:html], layout: "pdf")
+    pdf = PagePrint.render(html, page_size: :a4, margins: :normal, metadata: { title: "Invoice ##{params[:id]}", author: "Example Ltd" })
 
-    { content: "body { font-family: sans-serif; }", mime_type: "text/css" }
+    send_data pdf, filename: "invoice-#{params[:id]}.pdf", type: "application/pdf", disposition: "inline"
   end
 end
 ```
 
-## Options
-
-Supported keyword options:
-
-- `base_url:` string used to resolve relative URLs in the HTML
-- `page_size:` one of `:a3`, `:a4`, `:a5`, `:b4`, `:b5`, `:letter`, `:legal`, `:ledger`, or `{ width:, height:, unit: }`
-- `margins:` one of `:none`, `:normal`, `:narrow`, `:moderate`, `:wide`, or `{ top:, right:, bottom:, left:, unit: }`
-- `media:` one of `:print`, `:screen`
-- `resource_fetcher:` callable that receives a URL and returns `nil` or `{ content:, mime_type:, text_encoding: nil }`
-- `metadata:` hash with `:title`, `:author`, `:subject`, `:keywords`, `:creation_date`, or `:modification_date`
-
-Unresolved URLs are not fetched over the network. Provide assets through `resource_fetcher`, or return `nil` to skip a URL.
-
-`metadata[:creation_date]` and `metadata[:modification_date]` should be ISO-8601 strings, for example `2026-05-10T12:00:00Z`.
-
-Custom dimensions and margins require `unit:`. Supported units are `:pt`, `:pc`, `:in`, `:cm`, `:mm`, and `:px`.
-
-## Benchmarking
-
-```sh
-RUNS=30 WARMUPS=3 bundle exec ruby benchmark/pdf_renderers.rb
-```
-
-Measured on 2026-05-30 with Ruby 3.4.7 on Apple Silicon:
-
-| Renderer | Avg wall | P95 wall | Avg CPU | Avg peak RSS | Avg PDF |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| `page_print` | 78.2ms | 89.6ms | 93.4ms | 42.1MB | 33.0KB |
-| PDFKit | 782.2ms | 2127.1ms | 824.8ms | 59.4MB | 27.9KB |
-
-For options and CSV output, see `benchmark/README.md`.
-
-## Requirements
-
-- Ruby 3.2+
-- Native gems are published for `x86_64-linux` and `arm64-darwin`.
-- Native gems vendor PlutoBook but compile the small Ruby extension during install so it links against your local Ruby.
-- Source builds on unsupported platforms require PlutoBook development headers and library files.
-
-Supported platforms:
-
-| Platform | Install Type |
-| --- | --- |
-| `x86_64-linux` | Vendored PlutoBook, local Ruby extension build |
-| `arm64-darwin` | Vendored PlutoBook, local Ruby extension build |
-| Other platforms | Source build |
-
-Source build requirements on macOS with Homebrew:
-
-```sh
-brew install plutobook pkg-config
-```
-
-If `pkg-config` cannot find `plutobook`, install the gem with explicit include and library paths:
-
-```sh
-gem install page_print -- --with-plutobook-include=/path/to/include --with-plutobook-lib=/path/to/lib
-```
-
-Native gems bundle PlutoBook and required non-system shared libraries. Optional PlutoBook features for curl, TurboJPEG, and WebP are disabled in native gems to keep the bundled dependency set smaller.
-
-## Notes
-
-- The extension supports writing to a file path with `html_to_pdf` or returning PDF bytes with `html_to_pdf_string`.
-- JavaScript execution is intentionally unsupported.
-- Native gems disable PlutoBook's optional curl, TurboJPEG, and WebP features.
+Normal asset helpers can be used in the PDF template:
 
-## Development
-
-Install development dependencies:
-
-```sh
-bundle install
-```
-
-Compile the native extension into `lib/page_print`:
-
-```sh
-bundle exec rake compile
+```erb
+<%= stylesheet_link_tag "pdf" %>
+<%= image_tag "logo.png", alt: "Example Ltd" %>
 ```
 
-Open an interactive Ruby session against the local checkout:
+During a controller action, PagePrint uses `request.base_url` to resolve relative URLs. Its Rails resource fetcher reads `/assets/...` from Propshaft or `public/assets`; it does not make an HTTP request back to Rails.
 
-```sh
-bundle exec irb -Ilib
-```
+## Assets and network access
 
-Then load the gem from the repo and try it:
+PagePrint intentionally does not download unresolved resources. Supply a `resource_fetcher` when non-Rails HTML needs external styles, images, or fonts:
 
 ```ruby
-require "page_print"
-require "tmpdir"
-
-output_path = File.join(Dir.tmpdir, "page_print-output.pdf")
-
-PagePrint.html_to_pdf("<html><body><h1>Hello</h1></body></html>", output_path, page_size: :letter, margins: :narrow, media: :screen)
-```
-
-You can also do a quick one-shot smoke test from the shell:
-
-```sh
-bundle exec ruby -Ilib -e 'require "tmpdir"; require "page_print"; output_path = File.join(Dir.tmpdir, "page_print-output.pdf"); p PagePrint.html_to_pdf("<html><body><h1>Hello</h1></body></html>", output_path, page_size: :letter, margins: :narrow, media: :screen)'
-```
-
-Or use the development console, which compiles the native extension first and then starts IRB with `PagePrint` loaded:
-
-```sh
-bin/console
+assets = {
+  "asset:pdf.css" => {
+    content: File.binread("app/assets/stylesheets/pdf.css"),
+    mime_type: "text/css"
+  }
+}
+
+pdf = PagePrint.render(
+  "<link rel=\"stylesheet\" href=\"asset:pdf.css\"><h1>Report</h1>",
+  resource_fetcher: ->(url) { assets[url] }
+)
 ```
 
-## Running Tests
-
-Run the test suite only:
+The fetcher receives each resolved URL and returns `{ content:, mime_type: }` or `nil`. Returning `nil` skips the resource. This makes resource access explicit, but it does not make untrusted HTML safe; see [Security](docs/production.md#security).
 
-```sh
-bundle exec rake test
-```
+## Configuration
 
-Or run the default rake task, which compiles the extension and then runs tests:
+The common rendering options are:
 
-```sh
-bundle exec rake
+```ruby
+PagePrint.render(
+  html,
+  base_url: "https://example.test",
+  page_size: :letter,
+  margins: :narrow,
+  media: :print,
+  metadata: { title: "Quarterly report" },
+  resource_fetcher: fetcher
+)
 ```
 
-## Local Build
+Defaults are A4 paper, normal margins, and print media. See the [configuration reference](docs/configuration.md) for every preset, custom dimensions, metadata fields, global configuration, and resource fetcher behavior.
 
-Build and install locally:
+## Performance
 
-```sh
-gem build page_print.gemspec
-gem install ./page_print-*.gem
-```
+The repository includes a reproducible benchmark against PDFKit using the same static HTML input. On May 30, 2026, the recorded run used Ruby 3.4.7 on an Apple Silicon development machine:
 
-## Releasing
+| Renderer | Average wall time | P95 wall time | Average peak RSS |
+| --- | ---: | ---: | ---: |
+| PagePrint | 78.2 ms | 89.6 ms | 42.1 MB |
+| PDFKit | 782.2 ms | 2,127.1 ms | 59.4 MB |
 
-Publish a new version with:
+These numbers are illustrative, not a capacity guarantee. Rendering cost varies significantly with fonts, images, document length, and host configuration. Run the benchmark—or your own production templates—on the deployment target before sizing infrastructure.
 
 ```sh
-bin/bump 0.1.6
+RUNS=30 WARMUPS=3 bundle exec ruby benchmark/pdf_renderers.rb
 ```
 
-That updates `lib/page_print/version.rb` and `Gemfile.lock`, commits `Release 0.1.6`, creates annotated tag `v0.1.6`, and pushes `main` plus the tag. Requires a clean worktree on `main`.
+See [benchmark/README.md](benchmark/README.md) for methodology and CSV output.
 
-The Package workflow then builds the source and platform gems, pushes them to RubyGems (trusted publishing / OIDC, GitHub environment `release`), and creates a GitHub Release with the gem artifacts and commit notes since the previous `v*` tag.
+## Documentation
 
-## Building Native Gems
+- [Configuration and API reference](docs/configuration.md)
+- [Production guide](docs/production.md)
+- [Benchmark methodology](benchmark/README.md)
+- [PlutoBook feature matrix](https://github.com/plutoprint/plutobook/blob/main/FEATURES.md)
 
-Build an `x86_64-linux` platform gem with a vendored PlutoBook library:
-
-```sh
-bundle exec rake package:linux
-```
+## Development
 
-Build an Apple Silicon macOS platform gem with a vendored PlutoBook library:
+Install dependencies, compile the extension, and run the test suite:
 
 ```sh
-bundle exec rake package:darwin_arm64
+bundle install
+bundle exec rake
 ```
 
-These tasks check out PlutoBook `v0.18.0`, build it into `lib/page_print/vendor/<platform>`, and write a platform gem to `pkg/`. Platform gems compile the Ruby extension during gem install to avoid tying the gem to the build machine's Ruby version.
+Use `bin/console` for an IRB session with the extension compiled and PagePrint loaded.
 
-Native gems bundle PlutoBook and its non-system shared library dependencies. Optional PlutoBook features for curl, TurboJPEG, and WebP are disabled to keep the bundled dependency set smaller.
+## License
 
-The packaging tasks expect PlutoBook's build dependencies to be installed on the build machine, including Meson, Ninja, pkg-config, Cairo, FreeType, HarfBuzz, Fontconfig, Expat, and ICU.
+PagePrint is available under the [MIT License](LICENSE).

data/docs/configuration.md

@@ -0,0 +1,204 @@
+# Configuration and API reference
+
+PagePrint exposes two rendering methods and a small set of keyword options.
+
+## Rendering methods
+
+### `PagePrint.render(html, **options)`
+
+Renders a non-empty HTML string and returns the PDF as an `ASCII-8BIT` Ruby string.
+
+```ruby
+pdf = PagePrint.render("<h1>Report</h1>")
+```
+
+### `PagePrint.render_to_file(html, path, **options)`
+
+Renders a non-empty HTML string directly to `path` and returns `true`. The destination directory must already exist and be writable.
+
+```ruby
+PagePrint.render_to_file("<h1>Report</h1>", "/tmp/report.pdf")
+```
+
+Writing directly to a file avoids keeping the finished PDF in a Ruby string and is preferable for large documents or background jobs.
+
+## Options
+
+Both rendering methods accept the same options.
+
+| Option | Default | Accepted values |
+| --- | --- | --- |
+| `base_url:` | `nil` outside Rails | A string or `nil` |
+| `page_size:` | `:a4` | A page preset or custom dimensions |
+| `margins:` | `:normal` | A margin preset or custom dimensions |
+| `media:` | `:print` | `:print` or `:screen` |
+| `resource_fetcher:` | Configured global fetcher or `nil` | Any callable, `nil`, or `false` |
+| `metadata:` | `nil` | A metadata hash or `nil` |
+
+Unknown options raise `ArgumentError`; values of the wrong type raise `TypeError`.
+
+### Base URL
+
+`base_url` resolves relative URLs found in the HTML:
+
+```ruby
+html = '<link rel="stylesheet" href="/assets/report.css"><h1>Report</h1>'
+PagePrint.render(html, base_url: "https://example.test", resource_fetcher: fetcher)
+```
+
+The fetcher receives `https://example.test/assets/report.css`. A base URL resolves the URL; it does not enable network access.
+
+Set an application-wide default when rendering outside Rails:
+
+```ruby
+PagePrint.configure do |config|
+  config.base_url = "https://example.test"
+end
+```
+
+An explicit `base_url:` takes precedence over the configured value.
+
+### Page size
+
+Available presets:
+
+```text
+:a3  :a4  :a5  :b4  :b5  :letter  :legal  :ledger
+```
+
+Custom dimensions require a width, height, and unit:
+
+```ruby
+PagePrint.render(
+  html,
+  page_size: { width: 100, height: 150, unit: :mm }
+)
+```
+
+Width and height must be greater than zero.
+
+### Margins
+
+Available presets:
+
+```text
+:none  :normal  :narrow  :moderate  :wide
+```
+
+Custom margins require all four sides and a unit:
+
+```ruby
+PagePrint.render(
+  html,
+  margins: { top: 5, right: 6, bottom: 7, left: 8, unit: :mm }
+)
+```
+
+Margin values must be zero or greater.
+
+Page sizes and margins support these units:
+
+```text
+:pt  :pc  :in  :cm  :mm  :px
+```
+
+### Media type
+
+Use `:print` to apply print styles and `:screen` to apply screen styles:
+
+```ruby
+PagePrint.render(html, media: :screen)
+```
+
+### PDF metadata
+
+Metadata keys and values must be symbols and strings, respectively. A value may also be `nil`.
+
+```ruby
+PagePrint.render(
+  html,
+  metadata: {
+    title: "Quarterly report",
+    author: "Example Ltd",
+    subject: "Q2 results",
+    keywords: "finance,quarterly",
+    creation_date: "2026-05-10T12:00:00Z",
+    modification_date: nil
+  }
+)
+```
+
+Supported keys are:
+
+- `:title`
+- `:author`
+- `:subject`
+- `:keywords`
+- `:creation_date`
+- `:modification_date`
+
+Use ISO 8601 strings for creation and modification dates.
+
+## Resource fetchers
+
+A resource fetcher is a callable that receives a resolved URL. It must return either `nil` or a hash containing binary `content` and its `mime_type`. `text_encoding` is optional.
+
+```ruby
+fetcher = lambda do |url|
+  case url
+  when "asset:report.css"
+    {
+      content: File.binread("app/assets/stylesheets/report.css"),
+      mime_type: "text/css",
+      text_encoding: "utf-8"
+    }
+  when "asset:logo.png"
+    {
+      content: File.binread("app/assets/images/logo.png"),
+      mime_type: "image/png"
+    }
+  end
+end
+
+PagePrint.render(html, resource_fetcher: fetcher)
+```
+
+Returning `nil` skips the URL. PagePrint does not fall back to an HTTP request. Exceptions raised by the fetcher are propagated to the caller.
+
+Configure a default fetcher for every render:
+
+```ruby
+PagePrint.configure do |config|
+  config.resource_fetcher = MyResourceFetcher.new
+end
+```
+
+Pass `resource_fetcher: false` or `nil` to disable a configured fetcher for one render.
+
+Keep fetchers narrowly scoped. Prefer an allowlist or a fixed asset map over fetching arbitrary URLs supplied by HTML.
+
+## Rails behavior
+
+When Rails is loaded, PagePrint installs two defaults:
+
+1. During controller actions, the current `request.base_url` becomes the default base URL for that request.
+2. `PagePrint::RailsResourceFetcher` resolves URLs under `/assets/` from `public/assets` or Propshaft.
+
+An explicit `base_url:` or `resource_fetcher:` still takes precedence. To replace the Rails fetcher globally:
+
+```ruby
+# config/initializers/page_print.rb
+PagePrint.configure do |config|
+  config.resource_fetcher = MyResourceFetcher.new
+end
+```
+
+The built-in Rails fetcher only handles `/assets/...` URLs. Other paths are skipped.
+
+## CSS and rendering support
+
+PagePrint delegates HTML and CSS support to PlutoBook. It supports print-oriented features including `@page`, page counters, and running headers and footers, but it is not a full web browser. JavaScript and CSS Grid are not supported.
+
+Consult the upstream [PlutoBook feature matrix](https://github.com/plutoprint/plutobook/blob/main/FEATURES.md) when designing or migrating templates. Test representative documents after every renderer or font change because pagination can change even when the HTML does not.
+
+[Back to the README](../README.md)