page_print 0.1.9 → 0.1.11

data/docs/production.md

@@ -0,0 +1,148 @@
+# Production guide
+
+PagePrint is pre-1.0 software. Treat adoption as an application-specific engineering decision: validate the native package, representative documents, throughput, memory use, fonts, and failure behavior on the same platform used in production.
+
+## Production readiness checklist
+
+Before deploying PagePrint:
+
+- [ ] Confirm the deployment platform has a native gem or can build PlutoBook from source.
+- [ ] Render representative short, long, image-heavy, and multilingual documents in CI.
+- [ ] Visually compare pagination, fonts, images, headers, and footers against approved fixtures.
+- [ ] Verify every stylesheet, image, and font is available through the Rails integration or an allowlisted resource fetcher.
+- [ ] Confirm templates do not depend on JavaScript, CSS Grid, or other unsupported browser features.
+- [ ] Load-test with production-sized documents and the same worker/thread configuration used in deployment.
+- [ ] Set application-level job timeouts and monitor render latency, failures, and output size.
+- [ ] Prefer `render_to_file` for large PDFs, and clean up temporary output in both success and failure paths.
+- [ ] Pin the gem version and test upgrades before rollout; renderer upgrades can alter layout and pagination.
+
+## Platform support
+
+PagePrint requires Ruby 3.2 or newer.
+
+| Platform | Installation |
+| --- | --- |
+| `x86_64-linux` | Native gem with vendored PlutoBook libraries; the Ruby extension is compiled against the local Ruby |
+| `arm64-darwin` | Native gem with vendored PlutoBook libraries; the Ruby extension is compiled against the local Ruby |
+| Other platforms | Source build using an installed PlutoBook |
+
+The published native gems disable PlutoBook's optional curl, TurboJPEG, and WebP features to keep the bundled dependency set smaller. PagePrint uses its own Ruby resource fetcher boundary and does not expose PlutoBook's optional network fetcher.
+
+Your production image still needs a compiler and Ruby development headers because the small PagePrint extension is compiled during installation.
+
+### Installing on other platforms
+
+Install PlutoBook development headers and libraries before installing the gem. On macOS with Homebrew:
+
+```sh
+brew install plutobook pkg-config
+bundle install
+```
+
+If `pkg-config` cannot find PlutoBook, provide explicit paths:
+
+```sh
+gem install page_print -- \
+  --with-plutobook-include=/path/to/include \
+  --with-plutobook-lib=/path/to/lib
+```
+
+Use equivalent Bundler build configuration in repeatable deployments:
+
+```sh
+bundle config set --local build.page_print \
+  "--with-plutobook-include=/path/to/include --with-plutobook-lib=/path/to/lib"
+bundle install
+```
+
+Run a render smoke test while building the deployment artifact, rather than only checking that the gem can be required:
+
+```sh
+bundle exec ruby -e '
+  require "page_print"
+  pdf = PagePrint.render("<h1>Deployment check</h1>")
+  abort "invalid PDF" unless pdf.start_with?("%PDF")
+'
+```
+
+## Security
+
+PagePrint's resource policy is deny-by-default: an unresolved URL is not fetched over the network. Preserve that property in custom fetchers.
+
+- Do not build a fetcher that blindly downloads arbitrary URLs. Doing so can introduce server-side request forgery (SSRF), access to cloud metadata endpoints, and unbounded downloads.
+- Prefer a fixed asset map, an application-owned URI scheme, or strict allowlists for scheme, host, path, content type, and size.
+- Do not treat PagePrint as a sandbox for hostile HTML. It parses complex input in native code and should run with the minimum filesystem and process permissions needed by the application.
+- Never place secrets in HTML, asset URLs, metadata, or error logs.
+- Validate and limit user-controlled content before inserting it into a trusted template.
+
+PagePrint's disabled network fallback improves predictability and reduces accidental outbound access, but it is not a complete security boundary.
+
+## Template compatibility
+
+PagePrint is intended for static, server-rendered documents. It does not execute JavaScript. PlutoBook supports much of CSS 3 and selected CSS 4 functionality, but important gaps include CSS Grid and some advanced visual features.
+
+Before migrating from PDFKit, `wkhtmltopdf`, or a browser renderer:
+
+1. Inventory JavaScript, layout modules, fonts, SVG, and remote assets used by the templates.
+2. Check the [PlutoBook feature matrix](https://github.com/plutoprint/plutobook/blob/main/FEATURES.md).
+3. Render a fixture set with both engines.
+4. Compare page breaks and visual output, not only whether a PDF was produced.
+
+Use explicit `@page`, print styles, and embedded or controlled fonts. Font substitution is a common cause of different line wrapping and pagination across development and production.
+
+## Assets and networking
+
+For deterministic output, package document assets with the application and return them from a resource fetcher. Avoid making rendering depend on the availability or latency of another service.
+
+Rails applications using Propshaft get a default fetcher for `/assets/...`. Outside Rails, configure a fetcher once at process startup:
+
+```ruby
+PagePrint.configure do |config|
+  config.resource_fetcher = ProductionPdfAssets.new
+end
+```
+
+See the [resource fetcher reference](configuration.md#resource-fetchers) for the callable contract.
+
+## Capacity and concurrency
+
+HTML parsing, layout, and PDF writing are native CPU- and memory-intensive work. The extension releases Ruby's Global VM Lock during PlutoBook loading and writing, but Ruby callbacks such as a custom resource fetcher run with the lock.
+
+Do not size workers from the repository benchmark alone. Measure:
+
+- latency percentiles, not only averages;
+- peak resident memory with concurrent renders;
+- the largest realistic HTML, image, and PDF sizes;
+- application behavior when a render raises or a job times out;
+- both `render` and `render_to_file` if you expect large outputs.
+
+Use bounded job concurrency. For background processing, let the job system retry only failures known to be transient; invalid templates and unsupported resources will fail repeatedly.
+
+## Failure handling
+
+PagePrint validates option types and raises Ruby exceptions for invalid input, resource fetcher failures, HTML loading failures, and PDF write failures. Treat a successful method return—and, where appropriate, a `%PDF` signature and non-zero output size—as the completion signal.
+
+When writing temporary files:
+
+```ruby
+require "tempfile"
+
+Tempfile.create(["invoice", ".pdf"]) do |file|
+  PagePrint.render_to_file(html, file.path)
+  deliver(file.path)
+end
+```
+
+Do not expose native error text directly to end users. Record enough context to identify the template and render options, without logging document contents that may contain personal or confidential data.
+
+## Upgrade strategy
+
+Pin PagePrint in the application lockfile. Before upgrading PagePrint or PlutoBook:
+
+1. Build on every production platform.
+2. Run the complete PDF fixture suite.
+3. Compare visual output and page count.
+4. Repeat a focused load test.
+5. Roll out gradually while watching latency and render failures.
+
+[Back to the README](../README.md)

data/ext/page_print/page_print.c

@@ -2,7 +2,9 @@
 #include "ruby/encoding.h"
 #include "ruby/thread.h"
 #include <limits.h>
+#include <math.h>
 #include <stdint.h>
+#include <string.h>
 #include <plutobook/plutobook.h>
 
 #if defined(__GNUC__) || defined(__clang__)
@@ -55,6 +57,7 @@ typedef struct {
 
 typedef struct {
     VALUE object;
+    VALUE error;
     int state;
 } pageprint_resource_fetcher_t;
 
@@ -66,10 +69,12 @@ typedef struct {
 
 typedef struct {
     VALUE output;
+    VALUE error;
     int state;
 } pageprint_pdf_string_output_t;
 
 typedef struct {
+    pageprint_pdf_string_output_t *owner;
     VALUE output;
     const char *data;
     unsigned int length;
@@ -102,10 +107,49 @@ typedef struct {
     VALUE metadata;
 } pageprint_apply_metadata_args_t;
 
+typedef struct {
+    plutobook_t *book;
+    VALUE html;
+    VALUE base_url;
+    VALUE resource_fetcher;
+    VALUE metadata;
+    pageprint_resource_fetcher_t resource_fetcher_state;
+} pageprint_book_context_t;
+
+typedef struct {
+    pageprint_book_context_t book_context;
+    VALUE html;
+    VALUE path;
+    VALUE options;
+} pageprint_render_to_file_context_t;
+
+typedef struct {
+    pageprint_book_context_t book_context;
+    VALUE html;
+    VALUE options;
+    pageprint_pdf_string_output_t output;
+} pageprint_render_context_t;
+
 static VALUE pageprint_append_pdf_string(VALUE value);
 static plutobook_stream_status_t pageprint_write_pdf_string(void *closure, const char *data, unsigned int length);
 static plutobook_resource_data_t *pageprint_fetch_resource(void *closure, const char *url);
 
+static void pageprint_reject_embedded_nul(VALUE value, const char *name)
+{
+    if (memchr(RSTRING_PTR(value), '\0', (size_t)RSTRING_LEN(value))) {
+        rb_raise(rb_eArgError, "%s must not contain NUL bytes", name);
+    }
+}
+
+static VALUE pageprint_frozen_string_copy(VALUE value)
+{
+    VALUE copy = rb_str_dup(value);
+
+    rb_obj_freeze(copy);
+
+    return copy;
+}
+
 static void PAGEPRINT_NORETURN pageprint_raise_plutobook_error(VALUE error_class, const char *message)
 {
     const char *error_message = plutobook_get_error_message();
@@ -128,6 +172,12 @@ static void PAGEPRINT_NORETURN pageprint_raise_plutobook_error_with_path(VALUE e
     rb_raise(error_class, "%s %s", message, path);
 }
 
+static void PAGEPRINT_NORETURN pageprint_jump_callback_error(int state, VALUE error)
+{
+    rb_set_errinfo(error);
+    rb_jump_tag(state);
+}
+
 static double pageprint_unit_factor_from_value(VALUE value, const char *name)
 {
     ID value_id;
@@ -175,6 +225,14 @@ static plutobook_page_size_t pageprint_page_size_from_value(VALUE value)
         width_number = NUM2DBL(width);
         height_number = NUM2DBL(height);
 
+        if (!isfinite(width_number)) {
+            rb_raise(rb_eArgError, "page_size width must be finite");
+        }
+
+        if (!isfinite(height_number)) {
+            rb_raise(rb_eArgError, "page_size height must be finite");
+        }
+
         if (width_number <= 0) {
             rb_raise(rb_eArgError, "page_size width must be greater than 0");
         }
@@ -247,6 +305,10 @@ static plutobook_page_margins_t pageprint_margins_from_value(VALUE value)
         bottom_number = NUM2DBL(bottom);
         left_number = NUM2DBL(left);
 
+        if (!isfinite(top_number) || !isfinite(right_number) || !isfinite(bottom_number) || !isfinite(left_number)) {
+            rb_raise(rb_eArgError, "margins values must be finite");
+        }
+
         if (top_number < 0 || right_number < 0 || bottom_number < 0 || left_number < 0) {
             rb_raise(rb_eArgError, "margins values must be greater than or equal to 0");
         }
@@ -410,11 +472,17 @@ static void *pageprint_write_pdf_without_gvl(void *ptr)
 static void *pageprint_append_pdf_string_with_gvl(void *ptr)
 {
     pageprint_pdf_string_append_t *append = ptr;
+    pageprint_pdf_string_output_t *output = append->owner;
     int state = 0;
 
     rb_protect(pageprint_append_pdf_string, (VALUE)append, &state);
 
-    return (void *)(intptr_t)state;
+    if (state && !output->state) {
+        output->state = state;
+        output->error = rb_errinfo();
+    }
+
+    return NULL;
 }
 
 static void *pageprint_write_pdf_stream_without_gvl(void *ptr)
@@ -492,24 +560,31 @@ static void *pageprint_call_resource_fetcher_with_gvl(void *ptr)
 
     rb_protect(pageprint_call_resource_fetcher, (VALUE)args, &state);
 
-    return (void *)(intptr_t)state;
+    if (state && !args->fetcher->state) {
+        args->fetcher->state = state;
+        args->fetcher->error = rb_errinfo();
+    }
+
+    return NULL;
 }
 
 static plutobook_resource_data_t *pageprint_fetch_resource(void *closure, const char *url)
 {
     pageprint_resource_fetcher_t *fetcher = closure;
     pageprint_resource_fetch_args_t args;
-    int state;
+
+    if (fetcher->state) {
+        return NULL;
+    }
 
     if (!NIL_P(fetcher->object)) {
         args.fetcher = fetcher;
         args.url = url;
         args.resource = NULL;
 
-        state = (int)(intptr_t)rb_thread_call_with_gvl(pageprint_call_resource_fetcher_with_gvl, &args);
+        rb_thread_call_with_gvl(pageprint_call_resource_fetcher_with_gvl, &args);
 
-        if (state) {
-            fetcher->state = state;
+        if (fetcher->state) {
             plutobook_set_error_message("failed to fetch URL '%s'", url);
             return NULL;
         }
@@ -608,15 +683,11 @@ static pageprint_options_t pageprint_options_from_value(VALUE options)
     return result;
 }
 
-static plutobook_t *pageprint_create_book_from_html(VALUE html, VALUE options, pageprint_resource_fetcher_t *resource_fetcher)
+static void pageprint_create_book_from_html(VALUE html, VALUE options, pageprint_book_context_t *context)
 {
     pageprint_options_t pageprint_options;
-
-    const char *html_str;
     const char *base_url_str;
     long html_len;
-
-    plutobook_t *book;
     pageprint_load_html_args_t load_args;
 
     if (!RB_TYPE_P(html, T_STRING)) {
@@ -631,45 +702,49 @@ static plutobook_t *pageprint_create_book_from_html(VALUE html, VALUE options, p
         rb_raise(rb_eArgError, "html is too large");
     }
 
+    pageprint_reject_embedded_nul(html, "html");
     pageprint_options = pageprint_options_from_value(options);
+    context->html = pageprint_frozen_string_copy(html);
+    context->base_url = Qnil;
+    context->resource_fetcher = pageprint_options.resource_fetcher;
+    context->metadata = pageprint_options.metadata;
+
+    if (!NIL_P(pageprint_options.base_url)) {
+        pageprint_reject_embedded_nul(pageprint_options.base_url, "base_url");
+        context->base_url = pageprint_frozen_string_copy(pageprint_options.base_url);
+    }
 
-    html_str = RSTRING_PTR(html);
-    html_len = RSTRING_LEN(html);
+    html_len = RSTRING_LEN(context->html);
 
     /* 1. Create */
-    book = plutobook_create(pageprint_options.page_size, pageprint_options.margins, pageprint_options.media);
+    context->book = plutobook_create(pageprint_options.page_size, pageprint_options.margins, pageprint_options.media);
 
-    if (!book) {
+    if (!context->book) {
         rb_raise(rb_eRuntimeError, "failed to create plutobook");
     }
 
-    resource_fetcher->object = pageprint_options.resource_fetcher;
-    resource_fetcher->state = 0;
+    context->resource_fetcher_state.object = context->resource_fetcher;
+    context->resource_fetcher_state.error = Qnil;
+    context->resource_fetcher_state.state = 0;
 
-    plutobook_set_custom_resource_fetcher(book, pageprint_fetch_resource, resource_fetcher);
+    plutobook_set_custom_resource_fetcher(context->book, pageprint_fetch_resource, &context->resource_fetcher_state);
 
     /* 2. Load HTML */
     plutobook_clear_error_message();
 
     base_url_str = "";
-    if (!NIL_P(pageprint_options.base_url)) {
-        base_url_str = StringValueCStr(pageprint_options.base_url);
+    if (!NIL_P(context->base_url)) {
+        base_url_str = RSTRING_PTR(context->base_url);
     }
 
-    load_args.book = book;
-    load_args.html = html_str;
+    load_args.book = context->book;
+    load_args.html = RSTRING_PTR(context->html);
     load_args.length = (int)html_len;
     load_args.user_style = "";
     load_args.user_script = "";
     load_args.base_url = base_url_str;
     load_args.ok = 0;
 
-    RB_GC_GUARD(html);
-    RB_GC_GUARD(options);
-    RB_GC_GUARD(pageprint_options.base_url);
-    RB_GC_GUARD(pageprint_options.resource_fetcher);
-    RB_GC_GUARD(pageprint_options.metadata);
-
     rb_thread_call_without_gvl(
         pageprint_load_html_without_gvl,
         &load_args,
@@ -677,37 +752,41 @@ static plutobook_t *pageprint_create_book_from_html(VALUE html, VALUE options, p
         NULL
     );
 
-    if (!load_args.ok) {
-        plutobook_destroy(book);
+    RB_GC_GUARD(context->html);
+    RB_GC_GUARD(context->base_url);
 
-        if (resource_fetcher->state) {
-            rb_jump_tag(resource_fetcher->state);
+    if (!load_args.ok) {
+        if (context->resource_fetcher_state.state) {
+            pageprint_jump_callback_error(
+                context->resource_fetcher_state.state,
+                context->resource_fetcher_state.error
+            );
         }
 
         pageprint_raise_plutobook_error(rb_eRuntimeError, "failed to load HTML into plutobook");
     }
 
-    if (resource_fetcher->state) {
-        plutobook_destroy(book);
-        rb_jump_tag(resource_fetcher->state);
+    if (context->resource_fetcher_state.state) {
+        pageprint_jump_callback_error(
+            context->resource_fetcher_state.state,
+            context->resource_fetcher_state.error
+        );
     }
 
     {
         pageprint_apply_metadata_args_t metadata_args;
         int metadata_state = 0;
 
-        metadata_args.book = book;
-        metadata_args.metadata = pageprint_options.metadata;
+        metadata_args.book = context->book;
+        metadata_args.metadata = context->metadata;
 
         rb_protect(pageprint_apply_metadata_with_gvl, (VALUE)&metadata_args, &metadata_state);
+        RB_GC_GUARD(context->metadata);
 
         if (metadata_state) {
-            plutobook_destroy(book);
             rb_jump_tag(metadata_state);
         }
     }
-
-    return book;
 }
 
 static VALUE pageprint_append_pdf_string(VALUE value)
@@ -723,62 +802,54 @@ static plutobook_stream_status_t pageprint_write_pdf_string(void *closure, const
 {
     pageprint_pdf_string_output_t *output = closure;
     pageprint_pdf_string_append_t append;
-    int state;
 
+    if (output->state) {
+        return PLUTOBOOK_STREAM_STATUS_WRITE_ERROR;
+    }
+
+    append.owner = output;
     append.output = output->output;
     append.data = data;
     append.length = length;
 
-    state = (int)(intptr_t)rb_thread_call_with_gvl(pageprint_append_pdf_string_with_gvl, &append);
+    rb_thread_call_with_gvl(pageprint_append_pdf_string_with_gvl, &append);
 
-    if (state) {
-        output->state = state;
+    if (output->state) {
         return PLUTOBOOK_STREAM_STATUS_WRITE_ERROR;
     }
 
     return PLUTOBOOK_STREAM_STATUS_SUCCESS;
 }
 
-static VALUE pageprint_render_to_file(int argc, VALUE *argv, VALUE self) {
-    VALUE html;
-    VALUE path;
-    VALUE options;
-
-    const char *path_str;
-
-    plutobook_t *book;
-    pageprint_resource_fetcher_t resource_fetcher;
-    pageprint_write_pdf_args_t write_args;
-
-    rb_check_arity(argc, 2, 3);
+static VALUE pageprint_destroy_book(VALUE value)
+{
+    pageprint_book_context_t *context = (pageprint_book_context_t *)value;
+    plutobook_t *book = context->book;
 
-    html = argv[0];
-    path = argv[1];
-    options = argc == 3 ? argv[2] : Qnil;
+    context->book = NULL;
 
-    if (!RB_TYPE_P(path, T_STRING)) {
-        rb_raise(rb_eTypeError, "path must be a String");
+    if (book) {
+        plutobook_destroy(book);
     }
 
-    if (RSTRING_LEN(path) == 0) {
-        rb_raise(rb_eArgError, "path must not be empty");
-    }
+    return Qnil;
+}
 
-    path_str = StringValueCStr(path);
+static VALUE pageprint_render_to_file_body(VALUE value)
+{
+    pageprint_render_to_file_context_t *context = (pageprint_render_to_file_context_t *)value;
+    const char *path_str;
+    pageprint_write_pdf_args_t write_args;
 
-    book = pageprint_create_book_from_html(html, options, &resource_fetcher);
+    pageprint_create_book_from_html(context->html, context->options, &context->book_context);
+    path_str = RSTRING_PTR(context->path);
 
     plutobook_clear_error_message();
 
-    write_args.book = book;
+    write_args.book = context->book_context.book;
     write_args.path = path_str;
     write_args.ok = 0;
 
-    RB_GC_GUARD(html);
-    RB_GC_GUARD(options);
-    RB_GC_GUARD(resource_fetcher.object);
-    RB_GC_GUARD(path);
-
     rb_thread_call_without_gvl(
         pageprint_write_pdf_without_gvl,
         &write_args,
@@ -786,10 +857,17 @@ static VALUE pageprint_render_to_file(int argc, VALUE *argv, VALUE self) {
         NULL
     );
 
-    plutobook_destroy(book);
+    RB_GC_GUARD(context->path);
+    RB_GC_GUARD(context->book_context.resource_fetcher);
+    RB_GC_GUARD(context->book_context.resource_fetcher_state.error);
+    RB_GC_GUARD(context->html);
+    RB_GC_GUARD(context->options);
 
-    if (resource_fetcher.state) {
-        rb_jump_tag(resource_fetcher.state);
+    if (context->book_context.resource_fetcher_state.state) {
+        pageprint_jump_callback_error(
+            context->book_context.resource_fetcher_state.state,
+            context->book_context.resource_fetcher_state.error
+        );
     }
 
     if (!write_args.ok) {
@@ -799,36 +877,42 @@ static VALUE pageprint_render_to_file(int argc, VALUE *argv, VALUE self) {
     return Qtrue;
 }
 
-static VALUE pageprint_render(int argc, VALUE *argv, VALUE self) {
-    VALUE html;
-    VALUE options;
-    pageprint_pdf_string_output_t output;
+static VALUE pageprint_render_to_file(int argc, VALUE *argv, VALUE self)
+{
+    pageprint_render_to_file_context_t context = { 0 };
 
-    plutobook_t *book;
-    pageprint_resource_fetcher_t resource_fetcher;
-    pageprint_write_pdf_stream_args_t write_args;
+    rb_check_arity(argc, 2, 3);
 
-    rb_check_arity(argc, 1, 2);
+    context.html = argv[0];
+    context.options = argc == 3 ? argv[2] : Qnil;
+
+    if (!RB_TYPE_P(argv[1], T_STRING)) {
+        rb_raise(rb_eTypeError, "path must be a String");
+    }
+
+    if (RSTRING_LEN(argv[1]) == 0) {
+        rb_raise(rb_eArgError, "path must not be empty");
+    }
+
+    pageprint_reject_embedded_nul(argv[1], "path");
+    context.path = pageprint_frozen_string_copy(argv[1]);
 
-    html = argv[0];
-    options = argc == 2 ? argv[1] : Qnil;
-    output.output = rb_str_new(NULL, 0);
-    output.state = 0;
-    rb_enc_associate_index(output.output, rb_ascii8bit_encindex());
+    return rb_ensure(pageprint_render_to_file_body, (VALUE)&context, pageprint_destroy_book, (VALUE)&context.book_context);
+}
+
+static VALUE pageprint_render_body(VALUE value)
+{
+    pageprint_render_context_t *context = (pageprint_render_context_t *)value;
+    pageprint_write_pdf_stream_args_t write_args;
 
-    book = pageprint_create_book_from_html(html, options, &resource_fetcher);
+    pageprint_create_book_from_html(context->html, context->options, &context->book_context);
 
     plutobook_clear_error_message();
 
-    write_args.book = book;
-    write_args.output = &output;
+    write_args.book = context->book_context.book;
+    write_args.output = &context->output;
     write_args.ok = 0;
 
-    RB_GC_GUARD(html);
-    RB_GC_GUARD(options);
-    RB_GC_GUARD(resource_fetcher.object);
-    RB_GC_GUARD(output.output);
-
     rb_thread_call_without_gvl(
         pageprint_write_pdf_stream_without_gvl,
         &write_args,
@@ -836,21 +920,45 @@ static VALUE pageprint_render(int argc, VALUE *argv, VALUE self) {
         NULL
     );
 
-    plutobook_destroy(book);
-
-    if (resource_fetcher.state) {
-        rb_jump_tag(resource_fetcher.state);
+    RB_GC_GUARD(context->book_context.resource_fetcher);
+    RB_GC_GUARD(context->book_context.resource_fetcher_state.error);
+    RB_GC_GUARD(context->output.output);
+    RB_GC_GUARD(context->output.error);
+    RB_GC_GUARD(context->html);
+    RB_GC_GUARD(context->options);
+
+    if (context->book_context.resource_fetcher_state.state) {
+        pageprint_jump_callback_error(
+            context->book_context.resource_fetcher_state.state,
+            context->book_context.resource_fetcher_state.error
+        );
     }
 
-    if (output.state) {
-        rb_jump_tag(output.state);
+    if (context->output.state) {
+        pageprint_jump_callback_error(context->output.state, context->output.error);
     }
 
     if (!write_args.ok) {
         pageprint_raise_plutobook_error(rb_eRuntimeError, "failed to write PDF to string");
     }
 
-    return output.output;
+    return context->output.output;
+}
+
+static VALUE pageprint_render(int argc, VALUE *argv, VALUE self)
+{
+    pageprint_render_context_t context = { 0 };
+
+    rb_check_arity(argc, 1, 2);
+
+    context.html = argv[0];
+    context.options = argc == 2 ? argv[1] : Qnil;
+    context.output.output = rb_str_new(NULL, 0);
+    context.output.error = Qnil;
+    context.output.state = 0;
+    rb_enc_associate_index(context.output.output, rb_ascii8bit_encindex());
+
+    return rb_ensure(pageprint_render_body, (VALUE)&context, pageprint_destroy_book, (VALUE)&context.book_context);
 }
 
 void Init_page_print(void) {
@@ -888,6 +996,6 @@ void Init_page_print(void) {
     id_mm = rb_intern_const("mm");
     id_px = rb_intern_const("px");
 
-    rb_define_singleton_method(mPagePrint, "render_to_file", RUBY_METHOD_FUNC(pageprint_render_to_file), -1);
-    rb_define_singleton_method(mPagePrint, "render", RUBY_METHOD_FUNC(pageprint_render), -1);
+    rb_define_singleton_method(mPagePrint, "render_to_file", pageprint_render_to_file, -1);
+    rb_define_singleton_method(mPagePrint, "render", pageprint_render, -1);
 }