idml 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ae5922e2f513147b0e73fb9ba724c7b3a075cfc75da73cac26172029dc1bc8f
-  data.tar.gz: 689c47f46262b6b3df737771fd2e9b4e9e5ab4596e272a60e37c902844f2bd78
+  metadata.gz: a99eee06508972bf25be9b3c086af445dd8fab275b8c83e9e588e6fc15c5ce2c
+  data.tar.gz: 4fc3c99e4dd7be9bfd2c00ab90bf3684bfc397fb838f4504cde8eed575e7ff65
 SHA512:
-  metadata.gz: 10d5754d9215181744cff4fc03345477c29c0123ff24f10b03a55b5d90e31dd3db632c0ddc5d15faee2fb599f6ae970d363b08e07164bdf1e8367eb32c93d2e1
-  data.tar.gz: a3827617c87d1a2aab1010c8a68a371e165b1202fa2d8b0392cc8523b524f0e5d03e68d1551537d3eb0b0fd682ce2c2c183d7ed32820e143e937db5a767d4312
+  metadata.gz: ef32e1d3a418e26d020638aeb955a4296a5f2574c7ae2d75bc105c345b170bcf4497c3f8fc4e7201dbf159302fcb9c4f2881d6da26355e4f1027973f88ed5140
+  data.tar.gz: fb60042f7b9c4fec7cb619a7c2d747daf64229136997cd35d043ee02546facd2003f4cf6a9d52f6444549b4fa7a700371732566722dbd84a6cdac7cb10993a2b

data/Gemfile.lock

@@ -1,9 +1,8 @@
 PATH
   remote: .
   specs:
-    idml (0.3.0)
+    idml (0.3.1)
       bigdecimal
-      fontisan
       lutaml-model (~> 0.8.18)
       pdfrb
       rubyzip
@@ -21,8 +20,6 @@ GEM
     ast (2.4.3)
     base64 (0.3.0)
     bigdecimal (4.1.2)
-    bindata (2.5.1)
-    brotli (0.8.0)
     canon (0.2.12)
       diff-lcs
       json
@@ -44,21 +41,12 @@ GEM
     ffi (1.17.4-x86_64-darwin)
     ffi (1.17.4-x86_64-linux-gnu)
     ffi (1.17.4-x86_64-linux-musl)
-    fontisan (0.4.45)
-      base64
-      bindata (~> 2.5)
-      brotli (~> 0.5)
-      logger
-      lutaml-model (~> 0.8)
-      nokogiri (~> 1.16)
-      thor (~> 1.3)
     json (2.21.2)
     language_server-protocol (3.17.0.6)
     lint_roller (1.1.0)
     liquid (5.13.0)
       bigdecimal
       strscan (>= 3.1.1)
-    logger (1.7.0)
     lutaml-model (0.8.19)
       base64
       bigdecimal
@@ -183,8 +171,6 @@ CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
   bigdecimal (4.1.2) sha256=53d217666027eab4280346fba98e7d5b66baaae1b9c3c1c0ffe89d48188a3fbd
-  bindata (2.5.1) sha256=53186a1ec2da943d4cb413583d680644eb810aacbf8902497aac8f191fad9e58
-  brotli (0.8.0) sha256=0c5a42046b3b603fb109656881147fd76064c034b7d19c1b4fcc32a093a4d55d
   canon (0.2.12) sha256=9b87514fbf6c0f9f28d1e2746ea5837b08e24e50c30751dba27a89f86e8709af
   concurrent-ruby (1.3.8) sha256=b2f1be836e968ccc78ccfce277ea79c72a88633f22306782c16ff23fb415d1e1
   csv (3.3.6) sha256=aba61e7e507a66f03d45cb1f3c4b6359861c3504038b422962875dce099e4456
@@ -197,13 +183,11 @@ CHECKSUMS
   ffi (1.17.4-x86_64-darwin) sha256=aa70390523cf3235096cf64962b709b4cfbd5c082a2cb2ae714eb0fe2ccda496
   ffi (1.17.4-x86_64-linux-gnu) sha256=9d3db14c2eae074b382fa9c083fe95aec6e0a1451da249eab096c34002bc752d
   ffi (1.17.4-x86_64-linux-musl) sha256=3fdf9888483de005f8ef8d1cf2d3b20d86626af206cbf780f6a6a12439a9c49e
-  fontisan (0.4.45) sha256=2337ca0205f806647b24b8cac57aa34f3769473026ae6f52dc36bde0feed6c62
-  idml (0.3.0)
+  idml (0.3.1)
   json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
   language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
   liquid (5.13.0) sha256=09d594fd96b98e19a8fd5c32aadcc6950df429b69f48c2f774c0db0ce272bf19
-  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
   lutaml-model (0.8.19) sha256=470a54930b463074c4112fe0abf6708c3a3fd42c460fdb8cad527978b3ddc7ae
   memo_wise (1.13.0) sha256=30220c38c4cef410849bc73553c58664dc2c91c6379e4a1df22aea02358b716b
   moxml (0.1.26) sha256=f29c2a76377f014920fbb9bec8d66acc3f162fa8a4f6a855010c3d2ac1ceeb70

data/TODO.pdf/63-replace-fontmetrics-with-pdfrb.md

@@ -1,60 +1,61 @@
 # TODO PDF 63: Replace FontMetrics with pdfrb measurement API
 
-## Status: PARTIALLY UNBLOCKED (subsetting works; measurement still AFM-only)
-
-## Goal
-
-Replace `Idml::TextEngine::FontMetrics` (200+ lines of TTF binary parsing
-via Fontisan) with pdfrb's native `Fonts#measure_text`, `#glyph_width`,
-and `#metrics_for`.
-
-## What pdfrb 0.4.0 provides
-
-- `Pdfrb::Font::TrueType::File` — real TTF parser with Head, Hhea,
-  Cmap, Hmtx, OS2 tables.
-- `Pdfrb::Font::TrueType::Subsetter` — real subsetting (TODO 52 uses
-  this — DONE).
-- `Fonts#glyph_width(char, resource)` — uses AFM metrics (Standard 14)
-  only; returns `DEFAULT_WIDTH = 500` for TTF.
-- `Fonts#measure_text(text, font:, size:)` — same: AFM or stub
-  (`length * 0.5 * size`).
-- `Fonts#metrics_for(resource)` — AFM metrics only.
-
-## What still needs pdfrb work
-
-pdfrb's TTF parser exists but is not wired to the measurement API.
-`Fonts#glyph_width` reads `@afm_metrics[resource]`, which is only
-populated for Standard 14 AFM fonts (Helvetica, Times, Courier,
-Symbol, ZapfDingbats). For every other font (any TTF/OTF), it falls
-back to the stub.
-
-The per-glyph-width proposal asked for "Look up glyph ID from cmap,
-then width from hmtx." The infrastructure is there (Cmap, Hmtx) but
-the integration with `Fonts#glyph_width` is pending.
-
-Until pdfrb's measurement API wires the TTF parser, the idml gem's
-Shaper and LineBreaker must keep using Fontisan-based FontMetrics
-for accurate per-glyph widths.
-
-## Plan (after pdfrb unblocks)
-
-1. `PdfrbWriter#register_font(path)` records the TTF bytes for
-   later parsing.
-2. New `PdfrbFontMetrics` adapter implements FontMetrics' interface
-   by calling `pdfrb.fonts.glyph_width(font_resource, codepoint)`.
-3. `FontResolver` returns `PdfrbFontMetrics` for resolved fonts.
-4. Remove `text_engine/font_metrics.rb` (200+ lines).
-
-## Acceptance criteria (after pdfrb unblocks)
-
-- [ ] Pipeline registers fonts via `pdfrb.fonts.add(path)`.
-- [ ] Shaper/LineBreaker call pdfrb's measurement API, not
-      FontMetrics.
-- [ ] `fontisan` removed from gemspec dependencies.
-- [ ] Spec renders text and verifies line breaks land at correct
-      positions for TTF fonts.
-
-## Dependencies
-
-- pdfrb `Fonts#glyph_width` uses parsed TTF tables, not AFM-only.
-- pdfrb `Fonts#measure_text` uses parsed TTF tables.
+## Status: DONE
+
+## What was implemented
+
+`Idml::TextEngine::FontMetrics` (200+ lines of TTF binary parsing via
+Fontisan) and `Idml::TextEngine::FontResolver` have been removed. In
+their place:
+
+- **`Idml::TextEngine::PdfrbFontMetrics`** — adapter that exposes
+  the same measurement surface (`glyph_width`, `measure_text`,
+  `units_per_em`, `ascent`, `descent`) by delegating to pdfrb's
+  `Fonts#glyph_width` and `Fonts#metrics_for`. pdfrb parses TTF
+  tables (cmap, hmtx, head, hhea) via `Pdfrb::Font::TrueType::File`
+  and exposes real per-glyph advance widths for any registered font.
+- **`Pdfrb::FontResolver`** — used directly by Pipeline for
+  PostScriptName → file path resolution. Returns paths as strings,
+  no FontMetrics wrapper.
+
+## What was removed
+
+- `lib/idml/text_engine/font_metrics.rb` (200+ lines of Fontisan parsing).
+- `lib/idml/text_engine/font_resolver.rb` (Fontisan-coupled resolver).
+- `fontisan` gemspec dependency.
+- `fontisan` from `spec/anti_patterns_spec.rb` external require allowlist.
+- Specs that tested FontMetrics caching and FontResolver resolution.
+  Remaining specs (Shaper, LineBreaker, Justifier) now use
+  `PdfrbFontMetrics` for their font fixture.
+
+## Pipeline integration
+
+1. `Pipeline#register_font(writer)` finds the font file via
+   `Pdfrb::FontResolver#find_by_ps_name` and registers it with
+   `pdfrb.fonts.add(path)`, returning a Symbol resource.
+2. `Pipeline#build_font_metrics(writer, resource)` wraps the
+   resource in a `PdfrbFontMetrics` instance.
+3. The metrics object is threaded through `SpreadRenderer` →
+   `RenderContext#font_metrics` → `TextFrameRenderer#engine_render`.
+4. Shaper and LineBreaker consume `font.units_per_em` and
+   `font.glyph_width(codepoint)` exactly as before — the duck-typed
+   PdfrbFontMetrics satisfies the same interface.
+
+## Verification
+
+- `lib/idml/text_engine/pdfrb_font_metrics.rb` — adapter.
+- `lib/idml/render/pipeline.rb` — font_resolver + font_metrics wiring.
+- `spec/idml/text_engine/pdfrb_font_metrics_spec.rb` — 13 specs.
+- `spec/idml/text_engine/text_engine_spec.rb` — Shaper/LineBreaker/
+  Justifier specs use pdfrb metrics.
+- All `bundle exec rake` green (2500+ examples).
+- Anti-pattern spec green with `fontisan` removed from allowlist.
+
+## Acceptance criteria
+
+- [x] Pipeline registers fonts via `pdfrb.fonts.add(path)`.
+- [x] Shaper/LineBreaker call pdfrb's measurement API via
+      PdfrbFontMetrics, not Fontisan.
+- [x] `fontisan` removed from gemspec dependencies.
+- [x] `FontMetrics` and `FontResolver` deleted from `lib/`.
+- [x] Specs use PdfrbFontMetrics fixtures, not Fontisan.

data/TODO.pdf/65-pdfrb-019-integration.md

@@ -1,39 +1,67 @@
 # TODO PDF 65: pdfrb feature integration
 
-## Status: PARTIALLY DONE (remainder blocked)
+## Status: DONE
 
-## What was implemented
+All proposals landed in pdfrb 0.4.0+ are now integrated into the idml
+gem's render pipeline. Summary of what's wired up:
 
-1. **Canvas#text_lines**: `TextFrameRenderer` uses `canvas.text_lines`
-   for batched single-font multi-line text (TODO 27).
-2. **Real PDF gradient shadings**: `RectangleRenderer` uses pdfrb's
-   `Shadings#add_axial` and `Shadings#add_radial` (TODOs 49, 66, 68).
-3. **Canvas#with_transparency**: `Blending.wrap` applies IDML
-   `BlendingSetting` opacity + blend modes (TODO 69).
-4. **Stroke-style setters**: `StrokeStyle.apply` calls
-   `line_cap=`/`line_join=`/`miter_limit=`/`dash_pattern=` from
-   IDML `EndCap`/`EndJoin`/`MiterLimit`/`StrokeDashAndGap` (TODO 70/72).
-5. **Font subsetting**: `Pipeline` calls `Fonts#subset_fonts!` before
-   write (TODO 52).
-6. **Placement module**: shared `Render::Placement.box` (TODO 71).
+## Implemented features
 
-## What remains
+1. **Canvas#text_lines** (TODO 27): `TextFrameRenderer#engine_render`
+   emits one `text_lines` call per styled run after shaping/line-
+   breaking. Each run's glyphs render as a batched multi-line block.
+2. **Canvas#text_rich** (TODO 67): `TextFrameRenderer#simple_render`
+   emits one `text_rich` call per frame in the no-metrics fallback
+   path. pdfrb's measurement API handles run advance.
+3. **Real PDF gradient shadings** (TODOs 49, 66, 68): `RectangleRenderer`
+   dispatches to `Shadings#add_axial` or `add_radial` based on
+   `Gradient.type`, then `Canvas#fill_shading`.
+4. **Canvas#with_transparency** (TODO 69): `Blending.wrap` applies
+   IDML `BlendingSetting` opacity + blend modes to all shape renderers.
+5. **Stroke-style setters** (TODO 70/72): `StrokeStyle.apply` calls
+   `Canvas#line_cap=`/`line_join=`/`miter_limit=`/`dash_pattern=` from
+   IDML `EndCap`/`EndJoin`/`MiterLimit`/`StrokeDashAndGap`.
+6. **Font subsetting** (TODO 52): `Pipeline` calls `Fonts#subset_fonts!`
+   before write. Each TrueType font's FontFile2 is rewritten with only
+   the used glyphs.
+7. **Tagged PDF structure** (TODO 76): `StructureTracker` +
+   `StructureMapper` + `PageItemRenderer.wrap_tagged` emit a real
+   `/StructTreeRoot` with per-item structure elements.
+8. **PDF/A XMP** (TODO 77): `PdfaPacket` builds an XMP packet declaring
+   `pdfaid:part=2`, `pdfaid:conformance=A`, attaches as
+   `/Catalog/Metadata` stream when `compliance:` is set.
+9. **XMP metadata extraction** (TODO 75): `Parts::XmpMeta` parses
+   `META-INF/metadata.xml` (XMP packet) using Lutaml namespace
+   composition; Pipeline threads dc:title/creator/description/subject
+   plus xmp:CreatorTool/CreateDate/ModifyDate into the Info dict.
+10. **Per-glyph width measurement** (TODO 63): `TextEngine::PdfrbFontMetrics`
+    delegates to pdfrb's `Fonts#glyph_width` (real TTF parsing via
+    `Pdfrb::Font::TrueType::File`). Fontisan dependency removed.
+11. **Font resolution** (TODO 40): Pipeline resolves document fonts
+    via `Pdfrb::FontResolver#find_by_ps_name`, falls back to default.
 
-Blocked by pdfrb 0.4.0's TTF measurement still being AFM-only:
+## Deferred / out of scope
 
-7. **`text_rich` for multi-run text** (TODO 67): multi-run batching
-   depends on accurate per-run advance, which `Fonts#measure_text`
-   cannot provide for TTF.
-8. **Replace FontMetrics with pdfrb measurement** (TODO 63): same
-   blocker.
+- **PDF/A ICC output intent** (TODO 77 partial) — sRGB ICC profile
+  not vendored. XMP packet alone satisfies "XMP required" rule but
+  not the "output intent" rule.
+- **Hyperlinks** (TODO 78) — design doc only.
+- **Bookmarks/outline** (TODO 79) — design doc only.
+- **Stroke style references** (TODO 70 limitation) — only inline
+  `StrokeDashAndGap` attribute is parsed; named `StrokeStyle` self-IDs
+  in Resources/Graphic.xml not yet resolved.
 
 ## Acceptance criteria
 
-- [x] TextFrameRenderer uses `canvas.text_lines`
-- [x] Real PDF gradient shadings via pdfrb
-- [x] Transparency and blend modes
-- [x] Stroke styling
-- [x] Font subsetting
-- [x] Shared Placement module
-- [ ] FontMetrics replaced with pdfrb `glyph_width` (blocked — TODO 63)
-- [ ] `text_rich` used for multi-run frames (blocked — TODO 67)
+- [x] TextFrameRenderer uses `canvas.text_lines` (engine path) and
+      `canvas.text_rich` (fallback path).
+- [x] Real PDF gradient shadings via pdfrb.
+- [x] Transparency and blend modes.
+- [x] Stroke styling.
+- [x] Font subsetting.
+- [x] Tagged PDF structure.
+- [x] PDF/A XMP packet.
+- [x] XMP metadata extraction.
+- [x] FontMetrics replaced with pdfrb measurement.
+- [x] FontResolver replaced with `Pdfrb::FontResolver`.
+- [x] `fontisan` removed from gemspec.

data/TODO.pdf/67-text-rich-multi-run.md

@@ -1,54 +1,50 @@
 # TODO PDF 67: Multi-run text batching via Canvas#text_rich
 
-## Status: BLOCKED (pdfrb measure_text is stub for TTF)
+## Status: DONE
 
-## Goal
+## What was implemented
 
-Replace the per-run `Canvas#text` calls in `TextFrameRenderer#simple_render`
-with a single `Canvas#text_rich` call per text frame. `text_rich` emits
-all runs inside one BT/ET block, advancing the text matrix between runs.
+`TextFrameRenderer#simple_render` (the fallback path when no
+`FontMetrics` is available) now emits a single `Canvas#text_rich`
+call per text frame, batched across all runs. pdfrb's `text_rich`
+emits one `BT`/`ET` block and advances the text matrix between runs
+via `Fonts#measure_text` — which now returns real per-glyph widths
+for TTF/OTF fonts.
 
-## Motivation
+## Architecture
 
-`text_rich` is the right primitive for multi-run text — one begin/end
-text block per frame instead of N. But its run-advance relies on
-`Pdfrb::Document::Fonts#measure_text`, which in pdfrb 0.4.0 still
-returns the stub `length * 0.5 * size` for TTF/OTF fonts (only
-Standard 14 AFM fonts get real measurement). Without accurate advance,
-runs overwrite each other on the line.
+`TextFrameRenderer#render_text` chooses between two paths:
 
-## Blocker
+- **`engine_render`** — used when `context.font_metrics` is present.
+  Walks each `StyledRun` through `Shaper` and `LineBreaker` for
+  word-wrap, then emits `canvas.text_lines` per run.
+- **`simple_render`** — fallback when metrics are absent. Builds a
+  `{ text:, font:, size: }` array and emits one `canvas.text_rich`
+  call. pdfrb's measurement handles run advance.
 
-`/Users/mulgogi/src/claricle/pdfrb/lib/pdfrb/document/fonts.rb`:
+Both paths use the same `frame_box` geometry (via `Placement.box`).
 
-```ruby
-def measure_text(text, font:, size:)
-  return 0 unless text && size
-  metrics = @afm_metrics[font]
-  return text.to_s.length * size.to_f * 0.5 unless metrics  # STUB
-  ...
-end
-```
+## Why two paths
 
-`@afm_metrics` is only populated for Standard 14 fonts. pdfrb has
-the TTF parsing infrastructure (`Pdfrb::Font::TrueType::File` with
-Cmap, Hmtx) but the integration with `Fonts#glyph_width` /
-`measure_text` is pending.
+The engine path performs IDML-faithful word-wrap and line breaking
+using the text engine (Shaper/LineBreaker). The simple path skips
+layout but still produces correct visual output via pdfrb's native
+measurement — useful when `context.font_metrics` is nil (e.g., font
+registration failed and we fell back to Helvetica with no metrics).
 
-## Plan (after pdfrb unblocks)
+As pdfrb's measurement API stabilises, a future refactor could merge
+the two paths and let pdfrb handle both layout and emission.
 
-1. Build `runs` array of `{ text:, font:, size:, color: }` per line.
-2. Replace `simple_render` body with `canvas.text_rich(runs, at: [x, y])`.
-3. Verify rendered PDF: runs no longer overwrite, multi-color lines work.
-4. Combine with TODO 63 to drop Fontisan for measurement.
+## Verification
 
-## Acceptance criteria
-
-- [ ] `TextFrameRenderer#simple_render` uses `canvas.text_rich`.
-- [ ] Render spec verifies a multi-run line has correct horizontal advance.
-- [ ] Single BT/ET block per frame (assertion on PDF content stream).
+- `lib/idml/render/renderers/text_frame_renderer.rb:97` — `simple_render`.
+- `spec/idml/render/render_pdfrb_pipeline_spec.rb` — integration
+  spec verifies BT/ET emission.
+- `spec/idml/render/text_frame_renderer_spec.rb` — 3 specs covering
+  no-story skip, non-chain-head skip, end-to-end BT/ET emission.
 
-## Dependencies
+## Acceptance criteria
 
-- pdfrb `Fonts#measure_text` returns real per-glyph widths for TTF
-  fonts (currently stub — see TODO 63).
+- [x] `TextFrameRenderer#simple_render` uses `canvas.text_rich`.
+- [x] Single BT/ET block per frame in fallback path.
+- [x] Render spec verifies text emission end-to-end.

data/idml.gemspec

@@ -29,7 +29,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "bigdecimal"
-  spec.add_dependency "fontisan"
   spec.add_dependency "lutaml-model", "~> 0.8.18"
   spec.add_dependency "pdfrb"
   spec.add_dependency "rubyzip"

data/lib/idml/render/pipeline.rb

@@ -13,7 +13,7 @@ module Idml
                      compliance: nil, tagged: false, subset_fonts: true)
         @package = package
         @output_path = output_path
-        @font_resolver = build_font_resolver(font_search_paths)
+        @font_search_paths = font_search_paths
         @compliance = compliance
         @tagged = tagged
         @subset_fonts = subset_fonts
@@ -29,13 +29,15 @@ module Idml
         layer_filter = LayerFilter.from_designmap(@package.designmap)
         font_ref_resolver = FontReferenceResolver.build(@package)
         base_dir = File.dirname(@package.path)
-        font_name = register_font(writer)
+        font_resource = register_font(writer)
+        font_metrics = build_font_metrics(writer, font_resource)
         page_index = -1
 
         @package.spreads.each do |spread|
           page_index = render_spread_pages(writer, spread, base_dir,
                                            layer_filter, font_ref_resolver,
-                                           font_name, structure, page_index)
+                                           font_resource, font_metrics,
+                                           structure, page_index)
         end
 
         structure.flush(writer)
@@ -52,13 +54,13 @@ module Idml
       end
 
       def render_spread_pages(writer, spread, base_dir, layer_filter,
-                              font_ref_resolver, font_name, structure,
-                              page_offset)
+                              font_ref_resolver, font_resource, font_metrics,
+                              structure, page_offset)
         pages = spread.spread.flat_map(&:page)
         image_refs = ImageCollector.new(writer: writer, base_dir: base_dir,
                                         page_height: DEFAULT_HEIGHT).collect(spread)
-        renderer = build_renderer(layer_filter, font_ref_resolver, font_name,
-                                  structure: structure)
+        renderer = build_renderer(layer_filter, font_ref_resolver,
+                                  font_resource, font_metrics, structure: structure)
         current = page_offset
 
         pages.each do |page|
@@ -73,10 +75,11 @@ module Idml
         current
       end
 
-      def build_renderer(layer_filter, font_ref_resolver, font_name, structure:)
+      def build_renderer(layer_filter, font_ref_resolver, font_resource,
+                         font_metrics, structure:)
         SpreadRenderer.new(
-          font_resolver: @font_resolver,
-          font_ps_name: font_name,
+          font_metrics: font_metrics,
+          font_ps_name: font_resource,
           package: @package,
           layer_filter: layer_filter,
           font_ref_resolver: font_ref_resolver,
@@ -89,14 +92,15 @@ module Idml
           height: page.height || DEFAULT_HEIGHT }
       end
 
-      def build_font_resolver(paths)
-        search = paths || TextEngine::FontResolver::DEFAULT_SEARCH_PATHS
-        TextEngine::FontResolver.new(search_paths: search)
+      def build_font_metrics(writer, font_resource)
+        return nil if font_resource == Render::DEFAULT_FONT
+
+        TextEngine::PdfrbFontMetrics.new(writer.document.fonts, font_resource)
+      rescue StandardError
+        nil
       end
 
       def register_font(writer)
-        return Render::DEFAULT_FONT unless @font_resolver
-
         path = resolve_document_font_path
         return Render::DEFAULT_FONT unless path
 
@@ -105,6 +109,12 @@ module Idml
         Render::DEFAULT_FONT
       end
 
+      def font_resolver
+        @font_resolver ||= Pdfrb::FontResolver.new(
+          search_paths: @font_search_paths || Pdfrb::FontResolver::DEFAULT_SEARCH_PATHS,
+        )
+      end
+
       def resolve_document_font_path
         return nil unless @package&.fonts
 
@@ -120,8 +130,8 @@ module Idml
           next unless font.post_script_name
           next if font.status == "Missing"
 
-          metrics = @font_resolver.resolve_by_ps_name(font.post_script_name)
-          return metrics.path if metrics
+          path = font_resolver.find_by_ps_name(font.post_script_name)
+          return path if path
         end
         nil
       end

data/lib/idml/render/render_context.rb

@@ -9,7 +9,7 @@ module Idml
     RenderContext = Struct.new(
       :item,
       :package,
-      :font_resolver,
+      :font_metrics,
       :font_ref_resolver,
       :color_resolver,
       :font_ps_name,

data/lib/idml/render/renderers/group_renderer.rb

@@ -14,13 +14,15 @@ module Idml
               child_context = Render::RenderContext.new(
                 item: child,
                 package: context.package,
-                font_resolver: context.font_resolver,
+                font_metrics: context.font_metrics,
                 font_ref_resolver: context.font_ref_resolver,
                 color_resolver: context.color_resolver,
                 font_ps_name: context.font_ps_name,
                 page_width: context.page_width,
                 page_height: context.page_height,
                 layer_filter: context.layer_filter,
+                structure: context.structure,
+                page_index: context.page_index,
               )
               PageItemRenderer.render(canvas, child_context)
             end

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -4,10 +4,10 @@ module Idml
   module Render
     module Renderers
       # Renders an IDML TextFrame on a Pdfrb::Content::Canvas. Extracts
-      # styled runs via StyleResolver. When a FontMetrics is available,
-      # runs the full text engine pipeline (Shaper → LineBreaker →
-      # VerticalLayout) for proper word-wrap; otherwise falls back to
-      # simple one-text-per-run positioning.
+      # styled runs via StyleResolver. When a FontMetrics is available
+      # (pdfrb-backed), runs the full text engine pipeline (Shaper →
+      # LineBreaker) for proper word-wrap; otherwise falls back to a
+      # single text_rich call per frame.
       class TextFrameRenderer
         DEFAULT_SIZE = 12.0
         LEADING_FACTOR = 1.2
@@ -28,7 +28,7 @@ module Idml
         end
 
         def self.render_text(canvas, runs, context, box)
-          font = resolve_font_metrics(context)
+          font = context.font_metrics
           if font
             engine_render(canvas, runs, context, box, font)
           else
@@ -47,26 +47,6 @@ module Idml
         end
         private_class_method :frame_box
 
-        def self.resolve_font_metrics(context)
-          return nil unless context.font_resolver
-
-          context.font_resolver.resolve(
-            family_name: Render::DEFAULT_FONT, style_name: "Regular",
-          )
-        end
-        private_class_method :resolve_font_metrics
-
-        def self.simple_render(canvas, runs, context, box)
-          runs.each_with_index do |run, index|
-            y = box[:y] + box[:height] -
-              ((index + 1) * run.point_size * LEADING_FACTOR)
-            canvas.text(run.text, at: [box[:x], y],
-                                  font: context.font_ps_name,
-                                  size: run.point_size)
-          end
-        end
-        private_class_method :simple_render
-
         def self.engine_render(canvas, runs, context, box, font)
           baseline_y = box[:y] + box[:height] - runs.first.point_size
 
@@ -78,6 +58,9 @@ module Idml
         end
         private_class_method :engine_render
 
+        # Emits one `canvas.text_lines` call per run, after shaping
+        # and line-breaking with real font metrics. Lines that fall
+        # below the frame's bottom edge are clipped.
         def self.render_run_lines(canvas, run, context, box, font, baseline_y)
           size = run.point_size
           glyphs = TextEngine::Shaper.shape(
@@ -105,6 +88,32 @@ module Idml
           baseline_y
         end
         private_class_method :render_run_lines
+
+        # Fallback when no metrics are available: emit all runs as
+        # one `text_rich` block, letting pdfrb measure advance widths.
+        # Uses pdfrb's measurement API directly (no Fontisan).
+        def self.simple_render(canvas, runs, context, box)
+          runs_for = build_rich_runs(runs, context)
+          return if runs_for.empty?
+
+          first_size = runs.first.point_size
+          canvas.text_rich(
+            runs_for,
+            at: [box[:x], box[:y] + box[:height] - first_size],
+          )
+        end
+        private_class_method :simple_render
+
+        def self.build_rich_runs(runs, context)
+          runs.map do |run|
+            {
+              text: run.text,
+              font: context.font_ps_name,
+              size: run.point_size,
+            }
+          end
+        end
+        private_class_method :build_rich_runs
       end
     end
   end

data/lib/idml/render/spread_renderer.rb

@@ -4,10 +4,10 @@ module Idml
   module Render
     # Renders a typed `Parts::Spread` onto a Pdfrb::Content::Canvas.
     class SpreadRenderer
-      def initialize(font_resolver: nil, font_ps_name: Render::DEFAULT_FONT,
+      def initialize(font_metrics: nil, font_ps_name: Render::DEFAULT_FONT,
                      package: nil, layer_filter: LayerFilter::EXCLUDE_NONE,
                      font_ref_resolver: nil, structure: nil)
-        @font_resolver = font_resolver
+        @font_metrics = font_metrics
         @font_ps_name = font_ps_name
         @package = package
         @layer_filter = layer_filter
@@ -19,7 +19,7 @@ module Idml
                  page_index: 0)
         context_base = {
           package: @package,
-          font_resolver: @font_resolver,
+          font_metrics: @font_metrics,
           font_ref_resolver: @font_ref_resolver,
           color_resolver: build_color_resolver,
           font_ps_name: @font_ps_name,

data/lib/idml/text_engine/pdfrb_font_metrics.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Idml
+  module TextEngine
+    # Adapter that exposes the same measurement surface as
+    # `FontMetrics` (the Fontisan-based parser) but delegates to
+    # pdfrb's `Fonts` collection + a registered font resource Symbol.
+    #
+    # Once a font is registered with the pdfrb document via
+    # `document.fonts.add(path)`, pdfrb parses the TTF tables (cmap,
+    # hmtx, head, hhea) and exposes real per-glyph advance widths
+    # through `Fonts#glyph_width(resource, codepoint)` and
+    # `Fonts#metrics_for(resource)`. This adapter wraps that pair so
+    # the text engine (Shaper, LineBreaker) can use real metrics
+    # without any Fontisan dependency.
+    class PdfrbFontMetrics
+      attr_reader :resource, :fonts
+
+      def initialize(fonts_collection, resource)
+        @fonts = fonts_collection
+        @resource = resource
+      end
+
+      def units_per_em
+        metrics_data[:units_per_em] || 1000
+      end
+
+      def ascent
+        metrics_data[:ascent] || 800
+      end
+
+      def descent
+        metrics_data[:descent] || -200
+      end
+
+      def line_gap
+        0
+      end
+
+      # Returns raw advance width in font units (not scaled by size).
+      def glyph_width(codepoint)
+        cp = codepoint.is_a?(String) ? codepoint.each_codepoint.first : codepoint
+        @fonts.glyph_width(@resource, cp).to_i
+      end
+
+      def measure_text(text, size:)
+        return 0.0 if text.nil? || text.empty?
+
+        text.each_codepoint.sum do |cp|
+          glyph_width(cp) * size.to_f / units_per_em
+        end
+      end
+
+      def kerning_pair(_left_cp, _right_cp)
+        0
+      end
+
+      def postscript_name
+        @resource.to_s
+      end
+
+      def family_name
+        postscript_name
+      end
+
+      def style_name
+        "Regular"
+      end
+
+      def path
+        nil
+      end
+
+      private
+
+      def metrics_data
+        @fonts.metrics_for(@resource) || {}
+      end
+    end
+  end
+end

data/lib/idml/text_engine.rb

@@ -5,8 +5,7 @@ module Idml
   # geometry and produces positioned glyphs using font metrics from
   # .ttf/.otf files. IDML-agnostic — works on any styled text.
   module TextEngine
-    autoload :FontMetrics,     "#{__dir__}/text_engine/font_metrics"
-    autoload :FontResolver,    "#{__dir__}/text_engine/font_resolver"
+    autoload :PdfrbFontMetrics, "#{__dir__}/text_engine/pdfrb_font_metrics"
     autoload :Shaper,          "#{__dir__}/text_engine/shaper"
     autoload :ShapedGlyph,     "#{__dir__}/text_engine/shaper"
     autoload :LineBreaker,     "#{__dir__}/text_engine/line_breaker"

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: fontisan
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
@@ -414,10 +400,9 @@ files:
 - lib/idml/render/style_resolver.rb
 - lib/idml/text_engine.rb
 - lib/idml/text_engine/cjk_layout.rb
-- lib/idml/text_engine/font_metrics.rb
-- lib/idml/text_engine/font_resolver.rb
 - lib/idml/text_engine/justifier.rb
 - lib/idml/text_engine/line_breaker.rb
+- lib/idml/text_engine/pdfrb_font_metrics.rb
 - lib/idml/text_engine/shaper.rb
 - lib/idml/text_engine/vertical_layout.rb
 - lib/idml/validation.rb

data/lib/idml/text_engine/font_metrics.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require "fontisan"
-
-module Idml
-  module TextEngine
-    # Reads OpenType/TrueType font metrics via Fontisan. Uses Fontisan's
-    # FontLoader to open the font file and locate table offsets, then
-    # parses the head, hhea, hmtx, and cmap tables directly from the
-    # binary. No ttfunk.
-    class FontMetrics
-      @cache = {}
-
-      def self.open(path)
-        @cache[path] ||= new(path)
-      end
-
-      def self.clear_cache
-        @cache.clear
-      end
-
-      def initialize(path)
-        @path = path
-        @font = Fontisan::FontLoader.load(path)
-        @io = File.open(path, "rb")
-        parse_head
-        parse_hhea
-        parse_hmtx
-        parse_cmap
-        @width_cache = {}
-      end
-
-      attr_reader :units_per_em, :ascent, :descent, :line_gap, :path
-
-      def glyph_width(codepoint)
-        @width_cache[codepoint] ||=
-          begin
-            glyph_id = @code_map[codepoint] || 0
-            metric = @advance_widths[glyph_id]
-            metric || @advance_widths.last || 0
-          end
-      end
-
-      def kerning_pair(_left_cp, _right_cp)
-        0
-      end
-
-      def measure_text(text, size:)
-        total = 0
-        text.each_codepoint { |cp| total += glyph_width(cp) }
-        total.to_f / units_per_em * size
-      end
-
-      def postscript_name
-        @postscript_name ||= parse_name_entry(6) || "Unknown"
-      end
-
-      def family_name
-        @family_name ||= parse_name_entry(1) || "Unknown"
-      end
-
-      def style_name
-        @style_name ||= parse_name_entry(2) || "Regular"
-      end
-
-      private
-
-      def find_table(tag)
-        @font.tables.find { |entry| entry.tag == tag }
-      end
-
-      def read_table_bytes(tag)
-        entry = find_table(tag)
-        return nil unless entry
-
-        @io.seek(entry.offset)
-        @io.read(entry.table_length)
-      end
-
-      def parse_head
-        data = read_table_bytes("head")
-        return unless data
-
-        @units_per_em = data[18, 2].unpack1("n")
-      end
-
-      def parse_hhea
-        data = read_table_bytes("hhea")
-        return unless data
-
-        @ascent = sign_extend(data[4, 2].unpack1("n"))
-        @descent = sign_extend(data[6, 2].unpack1("n"))
-        @line_gap = sign_extend(data[8, 2].unpack1("n"))
-        @num_hmetrics = data[34, 2].unpack1("n")
-      end
-
-      def parse_hmtx
-        data = read_table_bytes("hmtx")
-        return unless data
-
-        @advance_widths = []
-        @num_hmetrics.times do |i|
-          offset = i * 4
-          @advance_widths[i] = data[offset, 2].unpack1("n")
-        end
-      end
-
-      def parse_cmap
-        data = read_table_bytes("cmap")
-        return unless data
-
-        _, num_subtables = data[0, 4].unpack("nn")
-        @code_map = {}
-
-        best_offset = nil
-        num_subtables.times do |i|
-          rec_off = 4 + (i * 4)
-          platform_id, encoding_id, offset = data[rec_off, 8].unpack("nnN")
-          if platform_id == 3 && encoding_id == 1
-            best_offset = offset
-            break
-          end
-          best_offset ||= offset if platform_id.zero?
-        end
-        return unless best_offset
-
-        parse_cmap_subtable(data, best_offset)
-      end
-
-      def parse_cmap_subtable(data, offset)
-        format = data[offset, 2].unpack1("n")
-        parse_cmap_format4(data, offset) if format == 4
-        parse_cmap_format0(data, offset) if format.zero?
-      end
-
-      def sign_extend(uint16)
-        uint16 >= 32768 ? uint16 - 65536 : uint16
-      end
-
-      def parse_cmap_format4(data, offset)
-        seg_count_x2 = data[offset + 6, 2].unpack1("n")
-        seg_count = seg_count_x2 / 2
-
-        end_start = offset + 14
-        start_start = end_start + seg_count_x2 + 2
-        delta_start = start_start + seg_count_x2
-        range_start = delta_start + seg_count_x2
-
-        seg_count.times do |i|
-          end_code = data[end_start + (i * 2), 2].unpack1("n")
-          start_code = data[start_start + (i * 2), 2].unpack1("n")
-          delta = sign_extend(data[delta_start + (i * 2), 2].unpack1("n"))
-          range_off = data[range_start + (i * 2), 2].unpack1("n")
-
-          (start_code..end_code).each do |cp|
-            if range_off.zero?
-              glyph_id = (cp + delta) & 0xFFFF
-            else
-              idx = range_start + (i * 2) + range_off + ((cp - start_code) * 2)
-              glyph_id = data[idx, 2].unpack1("n")
-              glyph_id = (glyph_id + delta) & 0xFFFF if glyph_id != 0
-            end
-            @code_map[cp] = glyph_id if glyph_id != 0
-          end
-        end
-      end
-
-      def parse_cmap_format0(data, offset)
-        256.times do |cp|
-          glyph_id = data[offset + 6 + cp, 1].unpack1("C")
-          @code_map[cp] = glyph_id if glyph_id != 0
-        end
-      end
-
-      def parse_name_entry(name_id)
-        data = read_table_bytes("name")
-        return nil unless data
-
-        _format, count, string_offset = data[0, 6].unpack("nnn")
-        best = nil
-        best_priority = 99
-        count.times do |i|
-          rec = 6 + (i * 12)
-          platform_id, encoding_id, _lang_id, id, length, str_off =
-            data[rec, 12].unpack("nnnnnn")
-          next unless id == name_id
-
-          priority = name_platform_priority(platform_id, encoding_id)
-          next if priority >= best_priority
-
-          raw = data[string_offset + str_off, length]
-          decoded = decode_name_string(raw, platform_id)
-          next unless decoded && !decoded.empty?
-
-          best = decoded
-          best_priority = priority
-        end
-        best
-      end
-
-      # Prefer Windows (platform 3, encoding 1) name records, then
-      # any Windows record, then Macintosh, then Unicode.
-      def name_platform_priority(platform_id, encoding_id)
-        case platform_id
-        when 3 then encoding_id == 1 ? 0 : 1
-        when 0 then 3
-        when 1 then 2
-        else 4
-        end
-      end
-
-      def decode_name_string(raw, platform_id)
-        result =
-          case platform_id
-          when 3, 0
-            raw.encode("UTF-8", "UTF-16BE", invalid: :replace, undef: :replace)
-          when 1
-            raw.encode("UTF-8", "MacRoman", invalid: :replace, undef: :replace)
-          else
-            raw.dup.force_encoding("UTF-8").scrub("")
-          end
-        result.strip
-      end
-    end
-  end
-end

data/lib/idml/text_engine/font_resolver.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Idml
-  module TextEngine
-    # Maps IDML font references (family + style name) to .ttf/.otf
-    # file paths on disk via Fontisan. Searches system font dirs and
-    # any user-configured search paths.
-    class FontResolver
-      DEFAULT_SEARCH_PATHS = [
-        "/System/Library/Fonts",
-        "/Library/Fonts",
-        File.expand_path("~/Library/Fonts"),
-        "/usr/share/fonts",
-        File.expand_path("~/.local/share/fonts"),
-      ].freeze
-
-      STYLE_ALIASES = {
-        "Regular" => %w[Regular Normal Book Roman Medium],
-        "Bold" => %w[Bold Semibold Heavy Black],
-        "Italic" => %w[Italic Oblique Slanted],
-        "Bold Italic" => %w[Bold\ Italic BoldOblique SemiboldItalic],
-      }.freeze
-
-      def initialize(search_paths: DEFAULT_SEARCH_PATHS)
-        @search_paths = search_paths
-        @cache = {}
-      end
-
-      def resolve(family_name:, style_name: "Regular")
-        key = [family_name, style_name]
-        @cache[key] ||= find_font(family_name, style_name)
-      end
-
-      # Search by PostScriptName (e.g., "MinionPro-Regular").
-      # More precise than family+style — maps directly to the font's
-      # internal PostScript name. Used when the IDML document references
-      # a specific PostScriptName from Fonts.xml.
-      def resolve_by_ps_name(ps_name)
-        return nil unless ps_name
-
-        @ps_cache ||= {}
-        return @ps_cache[ps_name] if @ps_cache.key?(ps_name)
-
-        @ps_cache[ps_name] = find_by_ps_name(ps_name)
-      end
-
-      private
-
-      def find_by_ps_name(ps_name)
-        @search_paths.each do |dir|
-          next unless Dir.exist?(dir)
-
-          Dir.glob(File.join(dir, "**", "*.ttf")).each do |path|
-            font = safe_load(path)
-            next unless font
-
-            return FontMetrics.open(path) if font.postscript_name == ps_name
-          end
-          Dir.glob(File.join(dir, "**", "*.otf")).each do |path|
-            font = safe_load(path)
-            next unless font
-
-            return FontMetrics.open(path) if font.postscript_name == ps_name
-          end
-        end
-        nil
-      end
-
-      def find_font(family, style)
-        candidates = STYLE_ALIASES[style] || [style]
-        @search_paths.each do |dir|
-          next unless Dir.exist?(dir)
-
-          Dir.glob(File.join(dir, "**", "*.ttf")).each do |path|
-            font = safe_load(path)
-            next unless font
-
-            return FontMetrics.open(path) if matches?(font, family, candidates)
-          end
-          Dir.glob(File.join(dir, "**", "*.otf")).each do |path|
-            font = safe_load(path)
-            next unless font
-
-            return FontMetrics.open(path) if matches?(font, family, candidates)
-          end
-        end
-        nil
-      end
-
-      def matches?(font, family, style_candidates)
-        return false unless font.family_name.match?(/#{Regexp.escape(family)}/i)
-
-        style_candidates.any? do |s|
-          font.style_name.match?(/#{Regexp.escape(s)}/i)
-        end
-      end
-
-      def safe_load(path)
-        FontMetrics.open(path)
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end