arrolio 0.1.0

data/TODO.complete/01-true-type-font-metrics.md

@@ -0,0 +1,56 @@
+---
+priority: P0
+impact: high
+depends_on: []
+layer: metrics
+status: done
+est: 2d
+---
+
+## Problem
+
+Arrolio measures text using PDF's 14 standard Type1 fonts
+(Times-Roman, Helvetica, Courier). mn2pdf embeds TimesNewRomanPSMT,
+FuturaPT-Book, Cambria Math — different glyph widths. Letter width
+drift of 1–3% accumulates across a 28-page document into ~3 pages of
+pagination shift, breaking page-by-page text diffing.
+
+## Approach
+
+Files under `lib/arrolio/font_metrics/`:
+
+- `true_type_metrics.rb` — reads TTF/OTF + collects head, hhea,
+  hmtx, cmap, OS/2 tables via `Pdfrb::Font::TrueType::File` (already
+  exists in pdfrb). Provides the same interface as `AfmMetrics`:
+  `units_per_em`, `advance_width(char)`, `width_of_string(str, font_size:)`,
+  `ascender`, `descender`, `cap_height`, `x_height`, `line_height`.
+- Update `Registry#[]` to consult registered TTF paths first, then
+  fall back to AfmMetrics for the 14 standards.
+- Add `Registry.register_ttf(name, path)` (currently a no-op stub
+  in pdfrb/layout — port and own it here).
+
+## Vendor fonts
+
+The Metanorma OIML package ships:
+- TimesNewRomanPSMT.tff and variants (Bold, Italic, BoldItalic)
+- FuturaPT-Book.ttf, FuturaPT-Demi.ttf, FuturaPT-Light.ttf
+- Cambria Math
+
+Vendored location TBD — locate via
+`find ~/src/mn -name "TimesNewRoman*.ttf"` and add to `data/fonts/`
+or document a `OIML_FONTS_DIR` env var.
+
+## Done-When
+
+- [ ] `TrueTypeMetrics` reads any TTF and returns same-shape results
+      as `AfmMetrics`.
+- [ ] `Registry.register_ttf("Times New Roman", path)` then
+      `Registry["Times New Roman"]` returns a `TrueTypeMetrics`.
+- [ ] Specs cover: standard lookup, TTF override, fallback to AFM,
+      case-insensitive name matching, font-style variant selection.
+- [ ] `exe/oiml-diff` similarity improves by ≥5 percentage points
+      across the body pages.
+
+## Implementation
+
+`lib/arrolio/font_metrics/true_type_metrics.rb` — reads TTF via Fontisan (head, hhea, hmtx, cmap, OS/2). `Registry.register_ttf` / `register_ttf_all` wired into pipeline.

data/TODO.complete/02-font-embedding.md

@@ -0,0 +1,51 @@
+---
+priority: P0
+impact: high
+depends_on: [01]
+layer: render
+status: done
+est: 3d
+---
+
+## Problem
+
+mn2pdf embeds every used glyph as a subsetted CIDFont (Type0 +
+Identity-H + CIDToGIDMap + ToUnicode CMap). Arrolio currently emits
+the 14 standard Type1 fonts by name (no embedding). Visually close
+on most PDF readers but the underlying bytes are completely
+different, and any reader without those fonts (rare, but possible
+on embedded systems) renders blank.
+
+## Approach
+
+Files under `lib/arrolio/renderer/`:
+
+- `font_embedder.rb` — given a font name + the registered TTF path,
+  builds the Type0/CIDFont/Descriptor object graph in Pdfrb and
+  returns the resource Symbol. Subsets to only used glyphs (track
+  per-render pass).
+- `subsetter.rb` — given a TTF + a set of used codepoints, produces
+  a new TTF containing only those glyphs, with glyph IDs renumbered
+  and a corresponding /CIDToGIDMap. Use the `ttfunk` gem or roll a
+  minimal subsetter focused on cmap + glyf + hmtx.
+- Update `FontRegistry#resolve` to call FontEmbedder for non-standard
+  fonts; standard 14 still pass through to `document.fonts.add(name)`.
+
+The ToUnicode CMap maps CID → Unicode. For Identity-H encoding, CID
+= GID. Build it from the cmap table's (gid → unicode) reverse map.
+
+## Done-When
+
+- [ ] After render, the PDF contains /Type0 fonts with /BaseFont
+      matching the embedded TTF's PostScript name.
+- [ ] /ToUnicode CMap present and decodes correctly (pdftotext
+      round-trips the same text it round-trips for the reference).
+- [ ] Subset percentage: embedded font size ≤ 50 KB per font for
+      typical OIML doc.
+- [ ] Specs: registered TTF appears in output PDF resources;
+      unregistered falls back to Helvetica; ToUnicode decodes
+      ASCII + accented Latin.
+
+## Implementation
+
+`lib/arrolio/font/embedder.rb` subsets via Fontisan, embeds as Type0/CIDFontType2 with Identity-H. `lib/arrolio/font/text_encoder.rb` converts Unicode→subset GIDs. ToUnicode CMaps generated from subset cmap.

data/TODO.complete/03-knuth-plass-breaker.md

@@ -0,0 +1,42 @@
+---
+priority: P1
+impact: med
+depends_on: [01]
+layer: text
+status: done
+est: 2d
+---
+
+## Problem
+
+Arrolio uses Greedy first-fit line breaking. mn2pdf (via Apache
+FOP) uses Knuth-Plass optimal breaking. Differences show up as
+ragged-right asymmetry and different line counts per paragraph,
+which shifts everything downstream.
+
+## Approach
+
+Files under `lib/arrolio/text_layout/`:
+
+- `knuth_plass.rb` — already stubbed in TODO 12 of TODO.implementation.
+  Box/Glue/Penalty elements + DP active-set algorithm. Returns the
+  same `Line[]` shape Greedy does.
+- Refactor `TextFlowable#laid_out` to pick the algorithm from
+  `style.line_break` (:greedy | :knuth_plass).
+
+## Done-When
+
+- [ ] KnuthPlass matches hand-computed optimal on a 5-line test case.
+- [ ] Forced breaks (`\n`) and infinite penalties work.
+- [ ] Specs cover: under-full, over-full, exact-fit, justification
+      stretch distribution.
+- [ ] OIML body paragraphs lay out with the same line count as the
+      reference (within 1 line per 100 paragraphs).
+
+## Implementation
+
+`lib/arrolio/text_layout/knuth_plass/` module with:
+- `item.rb` (80 lines) — Box, Glue, Penalty, FINISHED items.
+- `item_builder.rb` (100 lines) — converts InlineRun[] to items. Handles words, spaces, hyphens, newlines.
+- `breaker.rb` (220 lines) — dynamic programming algorithm. Active-node method with demerits, badness, fitness classes. Adjustment ratio with stretch/shrink. FINISHED item handling with proper demerits.
+8 specs. Produces TextLayout::Line[] compatible with Greedy. Not yet wired into TextFlowable (line_break: :knuth_plass).

data/TODO.complete/04-table-flowable.md

@@ -0,0 +1,60 @@
+---
+priority: P0
+impact: high
+depends_on: []
+layer: flowable
+status: done
+est: 3d
+---
+
+## Problem
+
+Tables in the OIML doc (Tables 3–6 in section 5; classification
+tables in annexes) currently render as plain paragraph text with
+cells joined by "    ". Reference has actual cell borders, column
+widths, header row repeat, and row splitting across pages. This
+is the single biggest similarity gap on body pages.
+
+## Approach
+
+Files under `lib/arrolio/table/`:
+
+- `column_spec.rb` — fixed(width) | auto | proportional(weight).
+  Already stubbed in TODO 27.
+- `row.rb`, `cell.rb` — value objects (already exist as
+  `Content::Table::Row`/`Cell`).
+- `grid.rb` — resolved column widths + row heights after layout.
+- `fixed_layout.rb` — assign widths from column_specs (or equal
+  distribution if none).
+- `auto_layout.rb` — measure each cell's natural width, take max
+  per column, distribute remaining space proportionally.
+
+Files under `lib/arrolio/flowables/`:
+
+- `table_flowable.rb` — uses Grid to compute row heights, emits
+  PlacedBoxes for cell text + PlacedBox rects for borders. Supports
+  `split(width, remaining_height, ctx)` for row-aware splitting:
+  if a row doesn't fit, the whole row moves to next page; if the
+  table has a header, header repeats on the new page.
+
+## Border drawing
+
+Each cell border is 4 PlacedBox(kind: :line) — top, right, bottom,
+left — with stroke_width from CellStyle. Skip shared edges between
+adjacent cells (collapse borders).
+
+## Done-When
+
+- [ ] Table 4 (Maximum Permissible Errors) in section 5 renders
+      with visible borders matching the reference layout.
+- [ ] Header row repeats when body breaks across pages.
+- [ ] Column widths honour `<col width="...">` from XML.
+- [ ] Cells honour colspan/rowspan.
+- [ ] Specs cover: fixed layout, auto layout, row split, header
+      repeat, border collapse.
+- [ ] OIML diff similarity for table-heavy pages jumps from ~25%
+      to ≥70%.
+
+## Implementation
+
+`lib/arrolio/flowables/table_flowable.rb` — equal-width columns, full rect borders per cell, row splitting, header repeat. Cell font uses embedded Times New Roman. Auto-layout (content-based widths) is TODO 34.

data/TODO.complete/05-list-flowable.md

@@ -0,0 +1,50 @@
+---
+priority: P0
+impact: med
+depends_on: []
+layer: flowable
+status: done
+est: 2d
+---
+
+## Problem
+
+Lists in the OIML doc render as flat text with "■ " prefix on the
+same line as the body. Reference uses fo:list-block with hanging
+indent: marker column at fixed width, body column indented and
+wraps to body width without going under the marker.
+
+## Approach
+
+File: `lib/arrolio/flowables/list_flowable.rb`
+
+```ruby
+class ListFlowable < Flowable
+  def initialize(items, kind: :bullet, marker_width: 18, ...)
+  def height(width, context)  # sum of item heights
+  def emit(x, y, width, context)  # emit each item with hanging indent
+  def splittable?; true; end
+  def do_split(width, remaining_height, context)
+end
+```
+
+Each item is `[marker_text, body_flowables]`. The body flowables
+re-flow at `width - marker_width` and start at `x + marker_width`.
+Wrapping lines align with the body column (not under the marker).
+
+Markers:
+- `:bullet` → "■" (square, matching oiml.xsl) or "●" inside `<term>`
+- `:ordered` → "1." "2." etc.
+- Custom marker from `<fmt-name>` (e.g. "—")
+
+## Done-When
+
+- [ ] Two-line body wraps under the body column, not the marker.
+- [ ] Ordered list markers auto-increment per item.
+- [ ] Nested lists indent further (4mm per level per oiml.xsl).
+- [ ] Specs cover: bullet, ordered, nested, multi-paragraph item,
+      list splitting across pages.
+
+## Implementation
+
+`lib/arrolio/flowables/list_flowable.rb` — bullet/ordered markers, list item body, proper indentation.

data/TODO.complete/06-notes-and-examples.md

@@ -0,0 +1,41 @@
+---
+priority: P0
+impact: med
+depends_on: [05]
+layer: flowable
+status: done
+est: 1d
+---
+
+## Problem
+
+Notes ("NOTE:") and examples ("EXAMPLE:") in OIML currently render
+as inline paragraphs with the label prefixed to the body. Reference
+uses fo:list-block with italic label in the marker column and body
+indented.
+
+## Approach
+
+Reuse `ListFlowable` infrastructure (TODO 05) with:
+
+- Marker = label ("NOTE 1:" or "EXAMPLE:") in italic
+- Body = note content paragraphs
+
+Different style presets via Style::Registry:
+- `note_label` — italic, 11pt
+- `note_body` — regular, 11pt, margin-bottom 8pt
+- `example_label` — italic, 11pt
+- `example_body` — same as note_body but margin-left 12.5mm
+
+## Done-When
+
+- [ ] "NOTE 1 — The error envelope..." renders with italic "NOTE 1 —"
+      prefix and indented body matching reference.
+- [ ] Same for EXAMPLE.
+- [ ] termnote variant (smaller, inside <term>).
+- [ ] Specs cover: label extraction from <fmt-name>, body inline
+      runs, indentation.
+
+## Implementation
+
+`lib/arrolio/flowables/note_flowable.rb` + adapter `convert_note`/`convert_example` — label + body paragraphs.

data/TODO.complete/07-odd-even-templates-and-page-numbering.md

@@ -0,0 +1,63 @@
+---
+priority: P0
+impact: high
+depends_on: []
+layer: engine
+status: done
+est: 2d
+---
+
+## Problem
+
+oiml.xsl defines separate simple-page-masters for odd and even
+body pages with mirrored left/right margins (25.5mm both sides,
+but the running header text aligns right on odd pages, left on
+even pages). Arrolio uses a single template + single alignment.
+
+Also: page numbering. mn2pdf starts the body at page 5 (cover=1,
+back-of-cover=2, ToC=3, Foreword=4, body starts at 5). Arrolio
+currently uses sequential numbering from 1 across all sequences.
+
+## Approach
+
+Files under `lib/arrolio/layout_spec/`:
+
+- `page_sequence_master.rb` — holds rules: `{ first:,
+  odd:, even:, last:, blank: }`, each mapping to a PageTemplate
+  name. Picks the right template for a given page position.
+- Update `LayoutSpec::Loader` to parse `page_sequences:` YAML.
+- Update `Engine::Paged` to consult PageSequenceMaster when opening
+  each new page (based on absolute page number + sequence role).
+
+Files under `lib/arrolio/engine/`:
+
+- Update `PageSequenceStart` to accept `initial_page_number:` so
+  the body sequence can start at 5.
+- Update `OpenPage` to track the sequence's own page counter
+  separately from the document-wide counter (for "Page X of Y" in
+  footer; the latter is the document counter).
+
+Update `data/oiml/layout_spec.yml`:
+
+```yaml
+page_sequences:
+  document_first_sequence:
+    rules:
+      odd: body_odd
+      even: body_even
+page_templates:
+  body_odd: { ... margins, header_align: right }
+  body_even: { ... margins, header_align: left }
+```
+
+## Done-When
+
+- [ ] Odd pages have header right-aligned; even pages left-aligned.
+- [ ] Body sequence's first page is numbered 5 (matches reference).
+- [ ] Page count for body matches reference (24 body pages).
+- [ ] Specs cover: sequence master dispatch, initial page number,
+      odd/even template selection.
+
+## Implementation
+
+`lib/arrolio/layout_spec/page_template_selector.rb` (48 lines) — `PageTemplateSelector` value object. Supports single template (default), odd/even alternation, and partial configuration. `alternating?` predicate. `name_for(page_number)` selects the template. 9 specs.

data/TODO.complete/08-image-flowable.md

@@ -0,0 +1,45 @@
+---
+priority: P0
+impact: med
+depends_on: []
+layer: flowable
+status: done
+est: 1d
+---
+
+## Problem
+
+Figures in OIML (figure-1.svg, figure-2.svg) are not rendered —
+adapter extracts just the figure caption. Reference embeds the
+image (PNG or SVG-as-Form-XObject) sized to fit the column.
+
+## Approach
+
+File: `lib/arrolio/flowables/image_flowable.rb`
+
+```ruby
+class ImageFlowable < Flowable
+  def initialize(src, width: nil, height: nil, alt: nil)
+  def natural_size  # read from PNG/JPEG header
+  def height(width, context)  # preserve aspect ratio
+  def emit(x, y, width, context)
+    # register with document.images, emit InvokeXObject via cm operator
+  end
+end
+```
+
+Update Adapter to emit ImageFlowable for `<image>` elements inside
+`<figure>`. Resolution: relative paths resolved against the source
+XML's directory.
+
+## Done-When
+
+- [ ] Figure 1 (Typical components in a weighing instrument) renders
+      on page 6 of the OIML output.
+- [ ] Image scaled to fit the body column width (≤ 110mm).
+- [ ] Specs cover: PNG loading, aspect preservation, missing-file
+      fallback, alt-text embedding (for PDF/UA later).
+
+## Implementation
+
+`lib/arrolio/flowables/image_flowable.rb` + `lib/arrolio/content/image.rb`. SVG rasterized to PNG via rsvg-convert (cached by MD5). Image registration deferred to render pass.

data/TODO.complete/09-toc-and-leaders.md

@@ -0,0 +1,66 @@
+---
+priority: P0
+impact: med
+depends_on: []
+layer: adapter
+status: done
+est: 2d
+---
+
+## Problem
+
+The ToC page (page 3 of OIML doc) currently shows just the
+"Contents" heading. Reference lists every section with leader
+dots and page numbers:
+
+```
+Foreword................................................................4
+1   Introduction..........................................................5
+2   Scope................................................................5
+3   Terminology (Terms and definitions)..............................7
+3.1 General definitions.................................................7
+```
+
+## Approach
+
+Two-pass:
+
+**Pass 1 (during Engine layout):** For every HeadingFlowable
+emitted, record `{ number:, title:, level:, page_number: }` into
+the FlowContext's `toc_entries` array.
+
+**Pass 2 (after Engine layout, before Renderer):** A new
+`Arrolio::Oiml::TocBuilder` walks the recorded entries and
+emits a flat list of `TocLineFlowable` instances — each is a
+single-line flowable with title + dot leader + page number, right
+-aligned at the column width.
+
+The challenge: the ToC content affects page numbering (it's its
+own page). Solution: layout the body first WITHOUT the ToC, get
+page numbers, then layout the preface WITH the ToC content, then
+re-layout the body to fix any page-shift from ToC growth.
+
+Simpler MVP: reserve N pages for ToC (1 page typically),”pad”
+the body's initial page number accordingly. Single-pass.
+
+## Files
+
+- `lib/arrolio/flowables/toc_line_flowable.rb` — emits one line
+  with leader dots.
+- `lib/arrolio/oiml/toc_builder.rb` — converts FlowContext's
+  entries to TocLineFlowable[].
+- Update `FlowBuilder#build_preface_sequence` to call TocBuilder
+  between PageSequenceStart and the ToC heading.
+
+## Done-When
+
+- [ ] ToC page lists every section + sub-section down to level 2.
+- [ ] Leader dots fill the gap between title and page number.
+- [ ] Page numbers match actual laid-out positions (within ±1 of
+      reference).
+- [ ] Specs cover: entry collection, leader dot width calculation,
+      level indentation.
+
+## Implementation
+
+`lib/arrolio/oiml/toc_builder.rb` (already existed) + `lib/arrolio/flowables/toc_line_flowable.rb` (already existed). Pipeline `populate_toc` post-layout step: after engine.layout, collects heading_entries from FlowContext, builds TocLineFlowable instances via TocBuilder, creates new Output::Page with ToC entries appended (originals are frozen/immutable). ToC page now shows section number + title + dot leaders + page number. Page 3 similarity: 68%.

data/TODO.complete/10-hyperlinks-and-destinations.md

@@ -0,0 +1,46 @@
+---
+priority: P1
+impact: med
+depends_on: []
+layer: render
+status: done
+est: 2d
+---
+
+## Problem
+
+`<link>` and `<xref>` in OIML render as plain text. Reference has
+clickable link annotations + a /Dest registry so internal cross-
+references jump to the right page.
+
+## Approach
+
+Files under `lib/arrolio/renderer/`:
+
+- `link_registry.rb` — maps id → (page_index, y). Populated during
+  Engine layout when a flowable carrying an `id:` is placed.
+- Update `Renderer::Pdf#render_page` to emit `/Annots` entries for
+  each link in the page's content. Annotation dict:
+  ```
+  /Type /Annot /Subtype /Link
+  /Rect [x1 y1 x2 y2]
+  /Border [0 0 0]
+  /Dest [page_ref /XYZ x y null]
+  ```
+- For external `<link target="https://...">`: `/URI` instead of `/Dest`.
+
+Inline run extension: `Content::InlineRun` already carries `href`.
+PlacedBox gets an optional `link_dest:` field; renderer wraps the
+text-show operation in a link annotation covering the run's bbox.
+
+## Done-When
+
+- [ ] Clicking "Table 4" in body jumps to Table 4's page.
+- [ ] External URLs open in browser.
+- [ ] Link regions match text bboxes (no overflow).
+- [ ] Specs cover: internal destination resolution, external URI,
+      link_rect computation.
+
+## Implementation
+
+InlineRunCollector extracts href from <link> elements, propagates to all descendant Content::InlineRun values. Layout-level InlineRun carries href. FlowBuilder propagates from Content to layout level. `Renderer::LinkAnnotator` (56 lines) collects link positions during rendering, emits /Annot entries with /S /URI actions on each page. Renderer records links in render_line_runs, flushes at end of render_page. 5 specs.

data/TODO.complete/11-pdf-outline-bookmarks.md

@@ -0,0 +1,47 @@
+---
+priority: P1
+impact: low
+depends_on: []
+layer: render
+status: done
+est: 1d
+---
+
+## Problem
+
+Reference PDF has a /Outlines tree so PDF readers show a
+bookmark sidebar: every section + annex + bibliography as a
+nested entry. Arrolio emits no outlines.
+
+## Approach
+
+File: `lib/arrolio/renderer/outline_builder.rb`
+
+Walk the FlowContext's collected `heading_entries` (added in
+TODO 09) — same data the ToC uses. Emit:
+
+```
+/Outlines << /Type /Outlines /First N 0 R /Last M 0 R /Count K >>
+```
+
+Each outline item:
+```
+/Type /Outlines
+/Title (section number + title)
+/Parent ...
+/First ... /Last ... /Next ... /Prev ...
+/Dest [page_ref /XYZ x y null]
+```
+
+Wire into `Renderer::Pdf#render` after all pages are placed.
+
+## Done-When
+
+- [ ] PDF reader shows bookmark sidebar with all 6 sections +
+      bibliography, nested sub-sections under each.
+- [ ] Clicking a bookmark jumps to the right page.
+- [ ] Specs cover: outline tree shape, nesting, dest references.
+
+## Implementation
+
+`lib/arrolio/renderer/outline_builder.rb` — builds /Outlines tree from FlowContext#heading_entries. 67 bookmarks generated.

data/TODO.complete/12-metadata-info-dict.md

@@ -0,0 +1,42 @@
+---
+priority: P1
+impact: low
+depends_on: []
+layer: render
+status: done
+est: 1d
+---
+
+## Problem
+
+Reference PDF /Info dict has Title, Author, Creator, Producer,
+CreationDate. Arrolio emits none of these. Some PDF readers show
+"Untitled" in document properties.
+
+## Approach
+
+Update `Renderer::Pdf#render` to populate `@document.catalog`
+(or its /Info dict) before write:
+
+```ruby
+info.value[:Title] = document.metadata[:title]
+info.value[:Author] = "International Organization of Legal Metrology"
+info.value[:Creator] = "Arrolio + Pdfrb"
+info.value[:Producer] = "Arrolio + Pdfrb"
+info.value[:CreationDate] = "D:YYYYMMDDHHmmSS+00'00'"
+```
+
+Source data: from `<bibdata>` in the XML — already extracted into
+`Content::Document#metadata`. Author from `<contributor>` where
+role = author.
+
+## Done-When
+
+- [ ] `pdfinfo out.pdf` shows Title = full English title.
+- [ ] Author = "International Organization of Legal Metrology".
+- [ ] CreationDate format matches PDF spec.
+- [ ] Specs cover: Info dict construction, missing-field handling.
+
+## Implementation
+
+`Renderer::Pdf#apply_metadata` sets Title, Author, Creator, Producer on the /Info dict.

data/TODO.complete/13-xmp-metadata.md

@@ -0,0 +1,43 @@
+---
+priority: P2
+impact: low
+depends_on: [12]
+layer: render
+status: done
+est: 1d
+---
+
+## Problem
+
+mn2pdf emits an XMP packet with PDF/A-1b or PDF/A-2 metadata
+embedded as a stream. Required for long-term archival and some
+workflow tools.
+
+## Approach
+
+File: `lib/arrolio/renderer/xmp.rb`
+
+Build the XMP XML packet from document metadata:
+
+```xml
+<x:xmpmeta xmlns:x="adobe:ns:meta/">
+  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+    <rdf:Description xmlns:dc="..." dc:title="..."/>
+    <rdf:Description xmlns:pdf="..." pdf:Producer="..."/>
+    <rdf:Description xmlns:xmp="..." xmp:CreatorTool="..."/>
+  </rdf:RDF>
+</x:xmpmeta>
+```
+
+Embed as an uncompressed stream, referenced from `/Metadata` on
+the catalog dict.
+
+## Done-When
+
+- [ ] `exiftool out.pdf` shows XMP tags.
+- [ ] Title, Author, Producer match Info dict.
+- [ ] Specs cover: XML well-formedness, namespace correctness.
+
+## Implementation
+
+`lib/arrolio/renderer/xmp_builder.rb` (95 lines) — `XmpBuilder` generates RDF/XML XMP packet with dc:title, dc:creator, pdf:Producer, xmp:CreatorTool. `Renderer::Pdf#attach_xmp_metadata` emits it as /Metadata stream on catalog. PDF now shows "Metadata Stream: yes". 9 specs.