carve-hexapdf 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52d77d202d7f1390346e49475aa665563e045e3bcf0c411bfb10a0d99c800070
-  data.tar.gz: 74687ef32c19f1969dff555ace0311b406c65aecb2b7ea0fa6c5eeced9977b3c
+  metadata.gz: 998af42c6a5a9753c0874cbdd003da94d3433303de6051f1a784a7beb3f3d2a1
+  data.tar.gz: dfe6a046b7e1026ebe8c9ce6c1364872d58f9e407441049cba2a7dd9c63fce66
 SHA512:
-  metadata.gz: 718e37565452624372860471353c73c80b26566e603d62b60912d2dba8ec5b99555c2671c7663ddc42dac18b88c620b091490908eb756f2c1277bf1a7f0ea731
-  data.tar.gz: 11b5129dd95d3f1ffd4260a136f6c842a381d4286fcaedac400ff53ca25b49b084e3d6f58c725b8a56d74dc29343149307c42ae586308b91701b546250302ef0
+  metadata.gz: c9a88ff35c2faaa48db5a26344b49837d53b00212db3bd9f3ba44a743d32a212c16cbabe1b8fe7c2a0469882a93c7bd3684faaeddf91c3329af371440783c7de
+  data.tar.gz: 203abfd74c94db24dc267e14c8ab93dce5acc49e6ff98312fa17fb0c211b40f4c87dea3eafd62f9e9c8b78e06cf2025ae8f38a9a01ad849a072eac5aa3deef32

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-11-12
+
+The default fonts no longer crash the render: `x <= 10` and CJK text now produce a PDF.
+
+### Fixes
+
+- Text the font cannot draw no longer aborts the render. With the default Type1 fonts, `<=`, `>=` and `!=` print as written instead of `≤ ≥ ≠`, and other characters without a glyph print as `?` with a warning; a TrueType `base_font:` draws them (#70, #71).
+
+**Full Changelog**: https://github.com/markup-carve/carve-hexapdf/compare/v0.1.6...v0.1.7
+
+## [0.1.6] - 2026-11-12
+
+Definition lists and table cell alignment now reach the PDF, the gem loads on Ruby 3.4, and the engine moves to carve-lang 0.1.14.
+
+### Fixes
+
+- Definition list terms and descriptions are drawn; they were dropped from the page on every engine (#66).
+- `require "carve/hexapdf"` works on Ruby 3.4, where `base64` is no longer a default gem (#64).
+
+### Improvements
+
+- Table cells keep their horizontal alignment, from the cell or its column's header (#67).
+- Developed and tested against carve-lang 0.1.14. Its braced alignment spelling (`|={>}`) right-aligns the column; a first-line `---` now opens frontmatter that runs to the end of an unclosed document, so nothing below it is drawn (#68).
+
+**Full Changelog**: https://github.com/markup-carve/carve-hexapdf/compare/v0.1.5...v0.1.6
+
 ## [0.1.5] - 2026-10-24
 
 Ruby interchange text now appears in rendered PDFs, and tables with span markers render without a PDF layout error.

data/README.md

@@ -1,277 +1,27 @@
 # carve-hexapdf
 
-Render the [Carve](https://github.com/markup-carve/carve) markup language to
-**PDF** from Ruby, using the pure-Ruby [HexaPDF](https://hexapdf.gettalong.org)
-document composition engine.
-
-Carve source is parsed with [`Carve.parse`](https://github.com/markup-carve/carve-rb)
-(from the `carve-lang` gem) and the resulting AST is walked onto a
-`HexaPDF::Composer`:
-
-- **Inline** nodes become HexaPDF styled text runs: `*strong*` and `/emphasis/`
-  map to bold / italic font variants, `` `code` `` to a monospace font, links to
-  a colored run with a clickable URI overlay.
-- **Block** nodes map to HexaPDF boxes: headings and paragraphs to text boxes,
-  lists to list boxes (ordered / unordered / task), tables to table boxes,
-  block quotes / divs / admonitions to styled containers, and images to image
-  boxes.
+Ruby PDF renderer for Carve documents. It supports `carve-lang` 0.1.1 or later and uses the HexaPDF composition engine. See the [Carve documentation](https://markup-carve.github.io/carve/).
 
 ## Install
 
-```ruby
-# Gemfile
-gem "carve-hexapdf"
-```
-
 ```sh
-bundle install
+gem install carve-hexapdf
 ```
 
-`carve-hexapdf` depends on `carve-lang` (a native gem that builds the Carve
-engine via Rust) and on `hexapdf`.
-
 ## Usage
 
 ```ruby
 require "carve/hexapdf"
-
-# Carve syntax note: *...* is STRONG (bold), /.../ is EMPHASIS (italic).
-pdf_bytes = Carve::Hexapdf.render(<<~CRV)
-  # Report
-
-  A paragraph with *bold*, /italic/, `code`, and a [link](https://example.com).
-
-  |= Name |= Score |
-  | Ann   | 42     |
-  | Bob   | 7      |
-CRV
-
-# Write straight to a file:
 Carve::Hexapdf.render_file("# Hello", "hello.pdf")
-
-# Render an already-parsed / transformed AST:
-ast = Carve.parse("# From AST")
-pdf_bytes = Carve::Hexapdf.render_ast(ast)
-```
-
-For interchange `ruby` nodes, PDF text shows each pair as
-`base(annotation)`, including `()` when the annotation is empty.
-
-### Includes
-
-A Carve document can pull another file in with `{{ path }}`. A String has no
-identity of its own, so a directive in one stays literal; name the file instead
-and it expands:
-
-```ruby
-pdf_bytes = Carve::Hexapdf.render_from_file("report/index.crv")
-```
-
-`render_from_file` READS Carve from a path and hands back PDF bytes.
-`render_file` is its opposite pair: it takes Carve source and WRITES the PDF out,
-and a directive in that source stays literal.
-
-Containment defaults to the input file's own directory, so a sibling or a file
-below it resolves and nothing above it does. `include_root:` moves that root:
-
-```ruby
-Carve::Hexapdf.render_from_file("report/index.crv", include_root: "/srv/docs")
-```
-
-The root must be **absolute**. A relative one is refused rather than resolved,
-because resolving it lands on whatever directory the process happens to run in,
-which is not a root anyone chose. The named document has to sit inside the root.
-
-A target that cannot be read leaves the directive drawn as written, and the
-reason goes to stderr. The message does not say whether the file was missing or
-refused by containment: both report `include-unresolved`, so a document cannot
-be used to probe the filesystem. Pass `on_includes:` to take reporting over and
-get the dependency identities with it:
-
-```ruby
-Carve::Hexapdf.render_from_file(
-  "report/index.crv",
-  on_includes: lambda { |warnings:, dependencies:, suppressed_warnings:|
-    dependencies.each { |d| puts "#{d[:path]} #{d[:resolved] ? 'read' : d[:denial]}" }
-  }
-)
-```
-
-`extensions:` and `profile:` reach the engine on the include path, and a child
-file is parsed with the same ones as its parent. Without a root they raise,
-rather than being dropped: `Carve.parse` accepts neither.
-
-### Options
-
-| Option | Default | Meaning |
-| ------ | ------- | ------- |
-| `page_size` | `:A4` | HexaPDF page size (e.g. `:A4`, `:Letter`) |
-| `margin` | `45` | Page margin in points |
-| `base_font` | `"Times"` | Proportional font family |
-| `code_font` | `"Courier"` | Monospace font family |
-| `link_color` | `"hp-blue"` | Fill color for links |
-| `highlight_color` | `"fff3a3"` | Background color for `=highlight=` |
-| `styles` | `nil` | Hierarchical style overrides (see below) |
-| `renderers` | `nil` | Callables that turn math / diagram source into image bytes (see below) |
-
-## Styling
-
-Pass `styles:` to restyle renderer output without patching the renderer. Keys are
-hierarchical dotted names; more specific entries win before parent entries, and
-user values win over defaults at the same key.
-
-```ruby
-Carve::Hexapdf.render(source, styles: {
-  "heading" => { fill_color: "333333" },
-  "code.block" => { box: { background_color: "fff8dd", padding: 8 } },
-  "admonition.warning" => { box: { background_color: "fff0f0" } },
-})
-```
-
-Resolution examples:
-
-- `heading.1` resolves through `heading` and then `base`.
-- `code.inline` resolves through `code` and then `base`.
-- `admonition.warning` resolves through `admonition` and then `base`.
-- `box:` hashes deep-merge; other values, including margin arrays, replace as a
-  whole.
-- `box:` only takes effect on keys that draw a surrounding box (`code.block`,
-  `quote`, `admonition`, `definition_list`, `math`); on text-only keys it is
-  ignored.
-- `list` accepts only its structural properties (`item_spacing`,
-  `content_indentation`); item text styling flows through `paragraph`.
-
-Specificity comes first: `"heading" => { font_size: 30 }` does not override the
-default `heading.1` size of `22`, but `"heading" => { fill_color: "333333" }`
-does apply to all heading levels. To change all heading sizes, set
-`heading.1` through `heading.6` individually.
-
-Existing keyword options are sugar under `styles:` and explicit style entries
-win: `base_font:` maps to `base.font`, `code_font:` to `code.font`,
-`link_color:` to `link.fill_color`, and `highlight_color:` to
-`highlight.background_color`.
-
-| Key | Defaults |
-| --- | -------- |
-| `base` | `{ font: "Times" }` |
-| `heading` | `{ margin: [10, 0, 6] }` |
-| `heading.1` ... `heading.6` | `{ font_size: 22 }`, `{ font_size: 18 }`, `{ font_size: 15 }`, `{ font_size: 13 }`, `{ font_size: 12 }`, `{ font_size: 11 }` |
-| `paragraph` | `{ margin: [0, 0, 8] }` |
-| `code` | `{ font: "Courier" }` |
-| `code.block` | `{ font_size: 9, margin: [2, 0, 8], box: { background_color: "f2f2f2", padding: 6 } }` |
-| `code.inline` | `{}` |
-| `quote` | `{ box: { margin: [2, 0, 8], padding: [4, 10], background_color: "f7f7f7" } }` |
-| `admonition` | `{ box: { margin: [2, 0, 8], padding: [6, 10], background_color: "eef3fb" }, title_margin: [0, 0, 4] }` |
-| `admonition.<kind>` | No defaults; any kind the parser accepts works (including hyphenated ones) |
-| `list` | `{ item_spacing: 3, content_indentation: 18 }` |
-| `definition_list` | `{ box: { margin: [0, 0, 8] }, definition_indent: 16 }` |
-| `table` | `{ font_size: 10, cell_padding: 4, margin: [2, 0, 8] }` |
-| `table.header` | `{}` |
-| `table.caption` | `{ font_size: 9, margin: [0, 0, 8] }` |
-| `figure.caption` | `{ font_size: 9, margin: [2, 0, 8], text_align: :center }` (panel captions too) |
-| `figure.group` | `{ box: { margin: [2, 0, 8] }, column_gap: 18, min_column_width: 90 }` |
-| `figure.group.caption` | `{ font_size: 9, margin: [4, 0, 0], text_align: :center }` |
-| `footnote` | `{ font_size: 9, margin: [0, 0, 3] }` (endnote section entries) |
-| `link` | `{ fill_color: "hp-blue" }` |
-| `highlight` | `{ background_color: "fff3a3" }` |
-| `image` | `{ margin: [2, 0, 8] }` |
-| `math` | `{ font_size: 11, margin: [4, 0, 8], box: { padding: 4 } }` |
-| `thematic_break` | `{ height: 2, margin: [8, 0, 8], background_color: "cccccc" }` |
-
-## Supported constructs
-
-Headings, paragraphs, all inline emphasis (strong / emphasis / bold-italic /
-**underline** / **strikethrough** / **superscript** / **subscript** /
-**highlight**), code, links, autolinks, soft & hard breaks, ordered / unordered
-/ task lists (nested), **tables with header rows and full row / column spans**,
-block quotes (with attribution), fenced code blocks, divs, admonitions,
-definition lists, figures, thematic breaks, critic markup (insert → underline,
-delete → strikethrough), **footnotes** (superscript `[n]` markers with the
-bodies collected into a numbered endnote section - inline `^[..]` and
-referenced `[^id]` alike), and **images** - both block and inline, embedded
-from a local file path or a `data:` URI. Task-list checkboxes are drawn in the
-list marker column, so item text and nested lists align like any other list.
-
-### Composite figures
-
-A bare `::: figure` container is one figure of ordered panels (Carve PART 9
-section 4c):
-
-```
-{.columns-2}
-::: figure
-![one](a.png)
-^ (a) One
-
-![two](b.png)
-^ (b) Two
-:::
-^ Figure #: Both samples
 ```
 
-On a page that group is one float. Its panels, any content preserved between
-them and the group caption are laid out as a single box a page break may not
-enter, and each panel keeps its own caption the same way - so the caption that
-numbers the figure never lands on the page after the panels it numbers. A
-group too tall to fit a page splits instead of failing the render, with the
-panels still in source order.
-
-`.columns-N` on the attribute line is honored when the page is wide enough to
-give every column `figure.group.min_column_width` points, and is otherwise
-ignored in favor of a stack. Every panel is drawn either way: the hint decides
-arrangement, never content.
-
-An opener that carries a title or a label (`::: figure "T"`, `::: figure [g]`)
-is deliberately NOT this construct - it stays a generic container and renders
-as one.
-
-> [!NOTE]
-> The parser this gem consumes (`carve-lang`, over carve-rs) does not produce
-> `figure_group` nodes yet. The renderer accepts them today - through
-> `Carve.parse` once the engine ships the construct, and through
-> `Carve::Hexapdf.render_ast` with an AST from any engine that already does.
-
-### Math and diagrams (renderer callables)
-
-PDF has no client-side renderer, so math and diagram fences are turned into
-embedded raster images through callables you supply in `renderers:`. Each
-returns image bytes (PNG/JPG) as a String - or a Hash `{ bytes:, width:,
-height: }` (points) to control the drawn size, so high-DPI rasters embed
-crisply at their intended dimensions. A missing renderer, or one that returns
-anything else or raises, degrades that construct to its monospace source.
-
-```ruby
-Carve::Hexapdf.render(source, renderers: {
-  # inline `$`x`$` and display `$$`x`$$` math:
-  math: ->(tex, display) { my_tex_to_png(tex, display) },   # -> bytes | {bytes:, width:, height:} | nil
-  # fenced ```mermaid / ```dot|graphviz / ```chart|vega:
-  mermaid:  ->(src) { my_mermaid_to_png(src) },
-  graphviz: ->(src) { my_dot_to_png(src) },
-  chart:    ->(src) { my_chart_to_png(src) },
-})
-```
-
-### Graceful degradation
-
-The renderer never raises on an unsupported node - it degrades so a document
-always produces a PDF:
-
-- **Math / diagram** fences without a matching `renderers:` callable render
-  their source in a monospace run.
-- **Remote image URLs** (`http(s)://`) are shown as alt text - no network
-  fetching. Local files and `data:` URIs are embedded.
-- **Raw HTML** blocks/inlines and **comments** are dropped.
-
-## Development
+## Documentation
 
-Contributor setup, testing, and maintenance notes are in the [development guide](docs/development.md).
+- [Carve documentation](https://markup-carve.github.io/carve/)
+- [Guide](docs/guide.md)
+- [Documentation index](docs/README.md)
+- [Contributing and development](docs/development.md)
 
-## Licensing
+## License
 
-This gem is **MIT** licensed. However, **HexaPDF is dual-licensed AGPL-3.0 /
-commercial**. If you distribute software or offer it over a network while
-depending on HexaPDF, you must comply with the AGPL (open-source your
-application) or hold a
-[HexaPDF commercial license](https://hexapdf.gettalong.org/#pricing). This gem
-only bridges Carve to HexaPDF; your use of HexaPDF is governed by HexaPDF's own
-terms.
+[MIT](LICENSE). HexaPDF has separate licensing terms; see the [guide](docs/guide.md#licensing).

data/lib/carve/hexapdf/renderer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "stringio"
-require "base64"
 
 require_relative "style_map"
 
@@ -62,6 +61,8 @@ module Carve
                                            highlight_color: highlight_color,
                                            styles: styles))
         @renderers = renderers || {}
+        @drawable = {}
+        @warned = {}
       end
 
       def render_document(doc)
@@ -187,7 +188,7 @@ module Carve
         content = resolve_nbsp(node[:content]).chomp
         style = style_for("code.block", inherited_font: true, with_box: true)
         box = style.delete(:box)
-        target.text(content, **style, box_style: box)
+        target.text(drawable_text(content, style[:font] || code_font), **style, box_style: box)
       end
 
       def list(node, target)
@@ -258,13 +259,15 @@ module Carve
       def definition_list(node, target)
         style = style_for("definition_list", with_box: true)
         target.container(style: style[:box]) do |cont|
+          # `items` is a flat run of definition_term / definition_description
+          # nodes, not term/definition pairs.
           Array(node[:items]).each do |item|
-            Array(item[:terms]).each do |term|
-              cont.formatted_text(inline_runs(term, bold: true), margin: [2, 0, 1])
-            end
-            Array(item[:definitions]).each do |defn|
+            case item[:type]
+            when "definition_term"
+              cont.formatted_text(inline_runs(item[:children], bold: true), margin: [2, 0, 1])
+            when "definition_description"
               cont.container(style: { padding: [0, 0, 0, style[:definition_indent]] }) do |dcont|
-                Array(defn).each { |ch| block(ch, dcont) }
+                Array(item[:children]).each { |ch| block(ch, dcont) }
               end
             end
           end
@@ -385,7 +388,8 @@ module Carve
         else
           alt = resolve_nbsp(node[:alt])
           alt = "[image: #{node[:src]}]" if alt.empty?
-          target.formatted_text([{ text: alt, font: [base_font, { variant: :italic }] }],
+          font = [base_font, { variant: :italic }]
+          target.formatted_text([{ text: drawable_text(alt, font), font: font }],
                                 margin: [0, 0, BLOCK_GAP])
         end
       end
@@ -398,7 +402,8 @@ module Carve
         style = style_for("math", with_box: true)
         box = style.delete(:box)
         style[:font] ||= code_font
-        target.text(node[:content].to_s, **style, text_align: :center, box_style: box)
+        target.text(drawable_text(node[:content].to_s, style[:font]), **style,
+                    text_align: :center, box_style: box)
       end
 
       def thematic_break(target)
@@ -434,6 +439,7 @@ module Carve
                        resolved.first.none? { |o| o[:row_span] > 1 } ? 1 : 0
         table_style = style_for("table")
         header_style = style_for("table.header")
+        columns = column_alignments(node)
 
         cell_boxes = resolved.map do |row|
           row.map do |o|
@@ -444,6 +450,9 @@ module Carve
             # :margin belongs to the table box, :cell_padding is our pseudo-prop.
             box_opts = cell_style.except(:margin, :cell_padding, :box)
             box_opts[:padding] = cell_style[:cell_padding]
+            column = columns[o[:col]] || {}
+            align = o[:cell][:align] || column[:align]
+            box_opts[:text_align] = CELL_ALIGN[align] if CELL_ALIGN.key?(align)
             box = @layout.formatted_text_box(runs, **box_opts)
             hash = { content: box }
             hash[:col_span] = o[:col_span] if o[:col_span] > 1
@@ -464,9 +473,37 @@ module Carve
         end
       end
 
+      CELL_ALIGN = { "left" => :left, "center" => :center, "right" => :right }.freeze
+
+      # A cell without its own alignment inherits its column's: the table's
+      # `columns` metadata, overridden by the head rows (the HTML `thead`), a
+      # later row winning. Any other cell's alignment is local. The head is
+      # `rowGroups.headRows` when published, else the leading header rows.
+      # Vertical alignment is not drawn: `text_valign` overflows a table cell.
+      def column_alignments(node)
+        columns = Array(node[:columns]).map { |c| (c || {}).slice(:align) }
+        rows = Array(node[:rows])
+        declared = node.dig(:rowGroups, :headRows)
+        head = declared.is_a?(Integer) ? rows.first(declared) : rows.take_while { |row| header_row?(row) }
+        head.each do |row|
+          Array(row[:cells]).each_with_index do |cell, col|
+            next if cell[:span]
+
+            (columns[col] ||= {})[:align] = cell[:align] if cell[:align]
+          end
+        end
+        columns
+      end
+
+      # A `^` / `<` marker is not a header cell, but leaves its row in the head.
+      def header_row?(row)
+        content = Array(row[:cells]).reject { |cell| cell[:span] }
+        !content.empty? && content.all? { |cell| cell[:header] }
+      end
+
       # Resolve Carve's explicit span markers (a `<` cell = merge left, a `^`
       # cell = merge up) into per-cell col_span / row_span counts, returning
-      # rows of originator hashes {cell:, header:, col_span:, row_span:} with
+      # rows of originator hashes {cell:, header:, col:, col_span:, row_span:} with
       # marker cells dropped. Every covered grid position is explicit in Carve,
       # so a cell's column index equals its position in the row.
       def resolve_spans(rows)
@@ -486,7 +523,7 @@ module Carve
               else
                 # A leading marker has no cell to extend. Keep its grid slot
                 # so the table has a drawable cell in this row.
-                o = { cell: cell, header: cell[:header], col_span: 1, row_span: 1 }
+                o = { cell: cell, header: cell[:header], col: col, col_span: 1, row_span: 1 }
                 emitted << o
                 last = o
                 col_owner[col] = o
@@ -500,13 +537,13 @@ module Carve
                 bumped[owner.object_id] = true
               end
               if owner.nil?
-                o = { cell: cell, header: cell[:header], col_span: 1, row_span: 1 }
+                o = { cell: cell, header: cell[:header], col: col, col_span: 1, row_span: 1 }
                 emitted << o
                 col_owner[col] = o
               end
               # A valid owner's slot remains available for further `^` rows.
             else
-              o = { cell: cell, header: cell[:header], col_span: 1, row_span: 1 }
+              o = { cell: cell, header: cell[:header], col: col, col_span: 1, row_span: 1 }
               emitted << o
               last = o
               col_owner[col] = o
@@ -616,7 +653,8 @@ module Carve
             Array(pair[:annotation]).each { |part| emit_inline(part, ctx, out) }
             out << run(")", ctx)
           end
-        when "smart_punctuation" then out << run(smart_punctuation_text(node), ctx)
+        when "smart_punctuation"
+          out << run(smart_punctuation_text(node), ctx, fallback: node[:value])
         # A character the author escaped. The backslash is authoring syntax, so
         # the page shows the character - but the node has no children, so
         # without this arm it falls through to the branch that emits children
@@ -734,7 +772,9 @@ module Carve
         text.to_s.gsub(RESOLVED_NBSP, NBSP)
       end
 
-      def run(text, ctx)
+      # +fallback+ is the author's spelling of the same text, drawn instead when
+      # the run font cannot draw +text+ (a smart-typography glyph).
+      def run(text, ctx, fallback: nil)
         item = { text: resolve_nbsp(text) }
         if ctx[:code]
           # :box is a block-level pseudo-property (e.g. inherited from a user
@@ -760,9 +800,77 @@ module Carve
           item[:link] = ctx[:link]
           item.merge!(run_style("link"))
         end
+        font = item[:font] || ctx[:font_family] || base_font
+        item[:text] = drawable_text(item[:text], font, fallback: fallback)
         item
       end
 
+      # A character the font cannot encode raises inside HexaPDF and loses the
+      # whole document (carve-hexapdf#70). That is either a missing glyph (CJK
+      # in Times) or a glyph the font's encoding cannot reach (standard Type1
+      # Times has `lessequal`, WinAnsi has no slot for it).
+      def drawable_text(text, font, fallback: nil)
+        wrapper = font_wrapper(font)
+        return text if wrapper.nil? || text.each_char.all? { |ch| drawable?(wrapper, ch) }
+
+        if fallback && fallback.to_s.each_char.all? { |ch| drawable?(wrapper, ch) }
+          return fallback.to_s
+        end
+
+        text.each_char.map do |ch|
+          next ch if drawable?(wrapper, ch)
+
+          warn_missing_glyph(wrapper, ch)
+          drawable?(wrapper, REPLACEMENT) ? REPLACEMENT : ""
+        end.join
+      end
+
+      REPLACEMENT = "?"
+
+      def font_wrapper(font)
+        return font if font.respond_to?(:decode_codepoint)
+
+        name, opts = font.is_a?(Array) ? font : [font, {}]
+        return name if name.respond_to?(:decode_codepoint)
+
+        document = @c.document
+        name ||= document.config["font.default"]
+        document.fonts.add(name, variant: (opts || {})[:variant] || :none)
+      rescue StandardError
+        nil
+      end
+
+      # Mirrors HexaPDF: decode, let `font.on_invalid_glyph` (and so any
+      # configured `font.fallback`) supply a missing glyph, then encode. Tabs,
+      # line breaks and the like are layout controls, never drawn.
+      def drawable?(wrapper, char)
+        key = [wrapper, char]
+        return @drawable[key] if @drawable.key?(key)
+
+        @drawable[key] = encodable?(wrapper, char)
+      end
+
+      def encodable?(wrapper, char)
+        glyphs = [wrapper.decode_codepoint(char.ord)]
+        if glyphs.first.is_a?(::HexaPDF::Font::InvalidGlyph)
+          return true if glyphs.first.control_char?
+
+          glyphs = @c.document.config["font.on_invalid_glyph"].call(char.ord, glyphs.first)
+        end
+        glyphs.all? { |g| !g.is_a?(::HexaPDF::Font::InvalidGlyph) && g.font_wrapper.encode(g) }
+      rescue ::HexaPDF::Error
+        false
+      end
+
+      def warn_missing_glyph(wrapper, char)
+        return if @warned[[wrapper, char]]
+
+        @warned[[wrapper, char]] = true
+        name = wrapper.wrapped_font.full_name rescue wrapper.to_s
+        warn format("carve-hexapdf: font '%s' has no glyph for U+%04X %p; drawing %p instead",
+                    name, char.ord, char, REPLACEMENT)
+      end
+
       # Link/highlight styles are decoration overlays on a run that may already
       # carry a variant or code font; the font they inherit from +base+ must not
       # clobber it (only a font set explicitly on the key itself wins), and a
@@ -905,7 +1013,7 @@ module Carve
           meta, data = src.split(",", 2)
           return nil unless data
 
-          bytes = meta.include?(";base64") ? Base64.decode64(data) : data
+          bytes = meta.include?(";base64") ? data.unpack1("m") : data
           return StringIO.new(bytes)
         end
         return src if File.file?(src)

data/lib/carve/hexapdf/version.rb

@@ -2,6 +2,6 @@
 
 module Carve
   module Hexapdf
-    VERSION = "0.1.5"
+    VERSION = "0.1.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carve-hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - markup-carve
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-24 00:00:00.000000000 Z
+date: 2026-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carve-lang