arrolio 0.1.0

data/TODO.implementation/33-image-flowable.md

@@ -0,0 +1,59 @@
+---
+priority: P1
+phase: 10
+depends_on: [16]
+layer: media
+est: 2d
+status: in_progress
+---
+
+## Problem
+
+Need a real ImageFlowable (not the placeholder from the FO spike).
+It loads the image via Pdfrb, scales to target size, optionally
+aligns (left/center/right), and is not splittable. Wraps it as a
+Flowable that the engine places into a frame.
+
+## Approach
+
+File: `lib/arrolio/flowables/image_flowable.rb`.
+
+```ruby
+class Arrolio::Flowables::ImageFlowable < Arrolio::Flowable
+  def initialize(src, width: nil, height: nil, max_width: nil,
+                 max_height: nil, align: :left)
+  def natural_size -> [w, h]   # cached after first measurement
+  def height(target_width, context)
+  def render(canvas, x, y, width, context)
+  def splittable?; false; end
+end
+```
+
+Internals:
+- On first `natural_size` call, ask Pdfrb to load the image
+  (Pdfrb::ImageLoader dispatches by format: JPEG, PNG, PDF page).
+  Cache the loaded image reference + its pixel dimensions.
+- Scaling rules:
+  - Both `width:` and `height:` explicit → use as-is (may distort).
+  - Only `width:` → `height = width * natural_h / natural_w`.
+  - Only `height:` → symmetric.
+  - Neither, but `max_width:` / `max_height:` → scale down to fit,
+    never up.
+  - Neither → use natural size.
+
+Render:
+- `name = context.document.images.add(src)` (Pdfrb handles caching).
+- `canvas.image(name, at: [x + align_offset, y], width:, height:)`.
+
+Alignment offset: depends on `align` (:left = 0, :center = (width -
+img_w) / 2, :right = width - img_w).
+
+## Done-When
+
+- [ ] An 800×600 image with `width: 200` renders at 200×150.
+- [ ] Same image with `max_width: 1000` renders at natural size.
+- [ ] `align: :center` horizontally centres the image.
+- [ ] Image is not splittable; if it doesn't fit, engine advances.
+- [ ] PNG with alpha (SMask) renders correctly.
+- [ ] JPEG passthrough works (no re-encode).
+- [ ] Round-trip: rendered PDF re-read has expected /XObject.

data/TODO.implementation/34-svg-renderer.md

@@ -0,0 +1,58 @@
+---
+priority: P1
+phase: 10
+depends_on: [22]
+layer: media
+est: 3d
+status: pending
+---
+
+## Problem
+
+SVG inside documents (`<svg>...</svg>` blocks, FOP's
+`fo:instream-foreign-object`) need a renderer. The SVG renderer
+walks the SVG tree and emits drawing operations on a Canvas (Pdfrb
+content stream). Supports the FOP/Batik output subset.
+
+## Approach
+
+Files under `lib/arrolio/svg/`:
+
+- `document.rb` — wraps a parsed SVG (REXML); exposes `width`,
+  `height`, `view_box`, `root`.
+
+- `style.rb` — resolved style from element attributes (fill, stroke,
+  stroke_width, opacity, font_*). Inherits from parent. Class
+  method `color_to_pdf(color_string)` resolves named/hex to PDF
+  Canvas colour.
+
+- `transform_parser.rb` — `parse("translate(10,20) rotate(45)")`
+  → list of op/args. `to_matrix(transforms)` → 6-element affine.
+
+- `path_parser.rb` — `parse("M 10 10 L 90 10 Z")` → list of
+  `{cmd:, absolute:, args:}`. Supports M L H V C S Q T A Z.
+
+- `element.rb` — base class with `register "name"` class method;
+  `for_element(xml, style:)` dispatcher.
+
+- Element subclasses under `lib/arrolio/svg/element/`:
+  - `group.rb` (g) — applies transform + recurses.
+  - `path.rb` — PathState accumulator; emits move/line/curve/close.
+  - `rect.rb`, `circle.rb`, `ellipse.rb`, `line.rb`,
+    `polyline.rb`, `polygon.rb` — basic shapes.
+  - `text.rb` — single-line text.
+  - `image.rb` — embedded raster (data: URI or href).
+
+- `renderer.rb` — walks Document, dispatches to element classes,
+  maintains transform/style stack.
+
+## Done-When
+
+- [ ] `<rect width="100" height="50" fill="red"/>` renders a red rectangle.
+- [ ] `<circle cx="50" cy="50" r="20"/>` renders via Bezier approximation.
+- [ ] `<path d="M 10 10 L 90 10 L 50 90 Z" fill="red"/>` renders triangle.
+- [ ] `<g transform="translate(10,10)"><rect .../></g>` translates children.
+- [ ] Nested groups compose transforms correctly.
+- [ ] `<text x="10" y="20">Hello</text>` renders text.
+- [ ] `<image xlink:href="data:image/png;base64,..."/>` renders PNG.
+- [ ] Spec coverage for each element type.

data/TODO.implementation/35-svg-as-form-xobject.md

@@ -0,0 +1,38 @@
+---
+priority: P2
+phase: 10
+depends_on: [34]
+layer: media
+est: 1d
+status: pending
+---
+
+## Problem
+
+SVG diagrams that repeat on every page (logos, watermarks) currently
+re-render each time. Better: render once into a Form XObject, then
+`canvas.draw_xobject(name, at:, scale:)` on every page. Cuts render
+time and PDF size.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/svg/form_xobject_builder.rb` — takes an SVG Document,
+  renders it once into a `Pdfrb::Model::Cos::Stream` with
+  `/Type /XObject`, `/Subtype /Form`, `/BBox`. Returns the OID.
+
+- Modify `Arrolio::SVG::Renderer` to optionally emit into a Form
+  XObject stream instead of directly into a page's canvas.
+
+- ImageFlowable and other consumers gain an option to wrap their
+  rendering in a Form XObject when the same image is placed > N times
+  (heuristic for "this repeats").
+
+## Done-When
+
+- [ ] SVG rendered as Form XObject appears identical to inline render.
+- [ ] Form XObject reused across 10 pages produces a PDF smaller than
+      rendering inline 10 times.
+- [ ] Form XObject can be scaled/positioned per page.
+- [ ] Round-trip: rendered PDF re-read has /XObject /Form.

data/TODO.implementation/36-inline-builder.md

@@ -0,0 +1,50 @@
+---
+priority: P1
+phase: 11
+depends_on: [10]
+layer: inline
+est: 1d
+status: pending
+---
+
+## Problem
+
+A paragraph is a list of InlineRuns. Authoring those runs by hand is
+tedious. The InlineBuilder DSL lets authors compose runs declaratively:
+`.text("Hello ")`, `.bold("world")`, `.color(:red) { .text("apple") }`.
+Style spans (bold, italic, colour) become first-class.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/inline_builder.rb` — builder DSL on top of Style::Diff:
+
+```ruby
+builder = Arrolio::InlineBuilder.new(base_style)
+builder.text("Hello ")
+builder.bold("world")            # creates run with bold-weight style
+builder.italic(" and italic")
+builder.color(:red) { |b| b.text(" apple") }
+builder.link("Click here", ref_id: "ch1")
+runs = builder.runs   # => [Run("Hello ", base), Run("world", base+bold), ...]
+```
+
+- `lib/arrolio/style/diff.rb` (extended from TODO 04) — given a base
+  Definition + overrides hash, produces a new Definition. Used by
+  InlineBuilder's `bold`/`italic`/`color` helpers.
+
+Helpers:
+- `bold(str)` / `bold { ... }` — `font_weight: "bold"`.
+- `italic(str)` / `italic { ... }` — `font_style: "italic"`.
+- `color(c, str)` / `color(c) { ... }` — `fill_color: c`.
+- `size(n, str)` / `size(n) { ... }` — `font_size: n`.
+- `font(name, str)` — `font_name: name`.
+
+## Done-When
+
+- [ ] `InlineBuilder.new(style).text("a").bold("b").runs.length == 2`.
+- [ ] Bold helper sets `font_weight: "bold"` on the run's style.
+- [ ] Color helper overrides only `fill_color`, keeps other props.
+- [ ] Nested helpers compose (`.bold { .color(:red) { .text("x") } }`).
+- [ ] Link helper creates a HyperlinkRun (TODO 37).

data/TODO.implementation/37-hyperlink.md

@@ -0,0 +1,53 @@
+---
+priority: P1
+phase: 11
+depends_on: [36, 22]
+layer: inline
+est: 2d
+status: pending
+---
+
+## Problem
+
+Hyperlinks (`<a href="...">` in HTML, `fo:basic-link` in FO) need
+both inline rendering (the visible text) and annotation emission (a
+PDF link annotation over the run's bounding box). The bounding box
+isn't known until layout — link annotations are added in a
+post-layout pass.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/hyperlink.rb` — `Hyperlink < InlineRun` with
+  `destination` (URI string or internal destination name).
+  Carries an `annotation_id` that the renderer fills in after
+  placement.
+
+- `lib/arrolio/output/link_annotation.rb` — `LinkAnnotation` value
+  object: `rect` (x, y, w, h), `destination` (URI or page ref),
+  `border_style`.
+
+Engine integration:
+- During TextFlowable render, track each Hyperlink run's bounding box
+  (compute from line position + run width).
+- After all body content is placed, walk the Output tree collecting
+  Hyperlinks → emit `LinkAnnotation[]` per page.
+- PDF renderer (TODO 22) walks LinkAnnotations → emits `/Annots`
+  array entries on each page.
+
+Two kinds of destination:
+- **External** (URI): `/S /URI /URI (https://...)`.
+- **Internal** (page reference): `/S /GoTo /D [page_ref /Fit]`.
+  Requires a destination registry (TODO 41).
+
+## Done-When
+
+- [ ] A paragraph with a hyperlink run renders the text in blue
+      underline (style default) and emits a clickable annotation.
+- [ ] External URI links open correctly when the PDF is viewed.
+- [ ] Internal links jump to the correct page (integration with
+      TODO 41 destinations).
+- [ ] Multiple hyperlinks on the same page each get distinct
+      `/Annots` entries.
+- [ ] Re-read PDF has the expected annotation structure.

data/TODO.implementation/38-sub-superscript.md

@@ -0,0 +1,44 @@
+---
+priority: P2
+phase: 11
+depends_on: [10]
+layer: inline
+est: 1d
+status: pending
+---
+
+## Problem
+
+Footnote markers, mathematical exponents, chemical formulae all need
+sub/superscript: small text raised (or lowered) relative to the
+baseline. The TextLayout must place these correctly without breaking
+the line height.
+
+## Approach
+
+Extend `Arrolio::InlineRun` (TODO 10) with two style properties:
+- `text_rise` (Float, in points) — vertical offset from baseline.
+  Positive = superscript; negative = subscript.
+- The existing `font_size` already supports smaller sizes.
+
+Add helper methods to `InlineBuilder` (TODO 36):
+- `superscript(str)` → `style.with(font_size: size * 0.7,
+  text_rise: size * 0.5)`.
+- `subscript(str)` → `style.with(font_size: size * 0.7,
+  text_rise: -(size * 0.2))`.
+
+TextLayout integration:
+- When measuring a run with `text_rise`, line height calculation
+  accounts for the raised extent (extends above ascender).
+- When rendering, emit `canvas.text(...)` with Pdfrb's `Tz` (rise)
+  parameter (PDF text-rise operator).
+
+## Done-When
+
+- [ ] `superscript("2")` renders smaller and raised.
+- [ ] `subscript("n")` renders smaller and lowered.
+- [ ] Line containing a superscript doesn't have its height reduced
+      (the rise doesn't push out of the line box; line_height is
+      generous enough).
+- [ ] "x² + y²" renders correctly with raised 2's.
+- [ ] "H₂O" renders with subscript 2.

data/TODO.implementation/39-leader-and-field-runs.md

@@ -0,0 +1,60 @@
+---
+priority: P1
+phase: 12
+depends_on: [13, 17]
+layer: xref
+est: 2d
+status: in_progress
+---
+
+## Problem
+
+Two cross-reference primitives:
+
+1. **Leader**: stretchy dot/rule that fills the space between two
+   runs on a line (for TOC entries: "Chapter 1 ........... 12").
+2. **FieldRun**: page-number fields resolved at render time via
+   FlowContext (`page_number`, `page_number_citation`,
+   `page_count`).
+
+Both must integrate with TextLayout: a Leader takes the residual
+space after the line's other runs; a FieldRun produces text after
+context lookup.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/leader.rb` — `Leader < InlineRun` with
+  `leader_pattern` (`:dots`, `:rule`, `:space`), `leader_length_min`,
+  `leader_length_max`. Method `fill_text(available_width, measurer)`
+  returns the dot string that fits.
+
+- `lib/arrolio/field_run.rb` — base `FieldRun < InlineRun` with
+  `resolve(context) -> String`.
+
+- Under `lib/arrolio/field_run/`:
+  - `page_number.rb` — `PageNumberField` returns
+    `context.page_number.to_s`.
+  - `page_number_citation.rb` — `PageNumberCitationField` returns
+    `context.citation_for(ref_id).to_s` (empty if unresolved).
+  - `page_count.rb` — `PageCountField` returns
+    `context.total_pages.to_s` (empty in pass 1).
+
+TextLayout integration:
+- Leaders are width=0 during line breaking (they take residual space).
+- After all other runs on a line are placed, compute the slack;
+  Leader fills it with dots.
+- FieldRuns are width=estimated ("000") in pass 1; in pass 2 they
+  have resolved text and re-flow if necessary (rare).
+
+## Done-When
+
+- [ ] TOC line `"Chapter 1" + leader + "12"` renders as
+      `"Chapter 1 ........... 12"`.
+- [ ] `leader_pattern: :rule` renders a horizontal line.
+- [ ] `PageNumberField` in footer renders "3" on page 3.
+- [ ] `PageCountField` renders "7" on every page of a 7-page doc.
+- [ ] `PageNumberCitationField` referencing a section on page 5
+      renders "5".
+- [ ] Spec coverage for each.

data/TODO.implementation/40-bookmark-outline.md

@@ -0,0 +1,45 @@
+---
+priority: P1
+phase: 12
+depends_on: [22, 26]
+layer: xref
+est: 2d
+status: pending
+---
+
+## Problem
+
+PDF outlines (the bookmark panel in viewers) let users navigate.
+Each entry is a title + destination. The outline tree mirrors the
+document's section structure. Currently Arrolio doesn't emit one.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/output/outline_node.rb` — value object: `title`,
+  `destination` (page_ref + viewport), `children` (Array), `parent`.
+
+- `lib/arrolio/renderer/pdf/outline_emitter.rb` — walks the
+  OutlineNode tree, builds Pdfrb objects:
+  - `/Outlines` (root dict) on Catalog.
+  - `/Type /Outlines`, `/First`, `/Last`, `/Count`.
+  - Per outline entry: `/Title`, `/Parent`, `/Dest` (page ref + view),
+    `/First`/`/Last`/`Next`/`Prev`/`Count` for hierarchy.
+
+Engine integration:
+- During pass 1, when placing a flowable that has a `bookmark_target`
+  attribute, record `context.record_bookmark(ref_id, page_number, y)`.
+- After pass 1, build the OutlineNode tree from recorded bookmarks.
+- Pass 2 emits the outline via OutlineEmitter.
+
+Bookmark target source: `Content::Section` carries an `id`; the
+content adapter (or the Composer) registers these as bookmark targets.
+
+## Done-When
+
+- [ ] A document with 3 sections produces a 3-entry outline.
+- [ ] Nested sections produce nested outline entries.
+- [ ] Clicking an outline entry in a viewer jumps to the right page.
+- [ ] Outline `/Count` reflects open/closed state default.
+- [ ] Re-read PDF has the expected `/Outlines` structure.

data/TODO.implementation/41-destinations.md

@@ -0,0 +1,52 @@
+---
+priority: P1
+phase: 12
+depends_on: [22, 39]
+layer: xref
+est: 1d
+status: pending
+---
+
+## Problem
+
+Internal hyperlinks (`PageNumberCitationField` links,
+`Hyperlink` runs pointing to a section) need named destinations
+that resolve to specific (page, viewport) pairs. Currently nothing
+records where a `ref_id` lands.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/destination.rb` — `Destination = Struct.new(:ref_id,
+  :page_number, :x, :y, :zoom, keyword_init: true)`. The `ref_id`
+  is the author's identifier (e.g. "section_3"); page_number and
+  viewport are filled in during layout.
+
+- `lib/arrolio/output/destination_registry.rb` — collects
+  `Destination` instances during pass 1; resolves by `ref_id` in
+  pass 2.
+
+- `lib/arrolio/renderer/pdf/destination_emitter.rb` — emits:
+  - **Named destinations**: `/Names /Dests << /Name (page_ref /Fit) >>
+    >>` on Catalog (or a dedicated Names dict).
+  - **Page-relative destinations**: stored inline in the link
+    annotation's `/D` array.
+
+Engine integration:
+- When the engine places a flowable with a `destination_id`
+  attribute, record a Destination at the current page number and the
+  flowable's top y.
+- Pass 2 walks the Output tree; for each Hyperlink or
+  PageNumberCitationField pointing to a `ref_id`, look up the
+  Destination.
+
+## Done-When
+
+- [ ] A section heading with `id: "intro"` records a Destination
+      pointing to its page.
+- [ ] A hyperlink to "intro" jumps to the correct page in a viewer.
+- [ ] A `PageNumberCitationField` referencing "intro" shows the
+      correct page number.
+- [ ] Missing `ref_id` raises a clear error during pass 2.
+- [ ] Re-read PDF has the expected `/Names /Dests` or `/Dests` dict.

data/TODO.implementation/42-toc-builder.md

@@ -0,0 +1,52 @@
+---
+priority: P1
+phase: 12
+depends_on: [39, 41]
+layer: xref
+est: 2d
+status: pending
+---
+
+## Problem
+
+Authoring a TOC by hand is tedious. The TOC builder walks the
+Content tree's sections, produces a flowable list of TOC entries —
+each is `"section_title" + Leader + "page_number_citation"` — and
+inserts it where the author marked a TOC placeholder.
+
+## Approach
+
+File: `lib/arrolio/toc_builder.rb`.
+
+```ruby
+class Arrolio::TocBuilder
+  def initialize(content_document, levels: 1..3, style: :toc_entry)
+  def build -> [TextFlowable, TextFlowable, ...]
+end
+```
+
+Algorithm:
+1. Walk `content_document.sections`; collect headings up to `levels`.
+2. For each heading, build a `TextFlowable` containing:
+   - `[InlineRun.new(section.title, style: indent_style(level)),
+      Leader.new,
+      PageNumberCitationField.new(ref_id: section.id)]`
+3. Indent per level (level 1 = no indent, level 2 = 12pt, level 3 = 24pt).
+
+Engine integration: the author places a `TocPlaceholder` flowable in
+the content stream. The engine replaces it with `TocBuilder.build`'s
+output at the start of pass 1.
+
+Two-pass effect: TOC entries need their cited page numbers, which
+aren't known until pass 1 completes. The TOC must be laid out in
+pass 1 with estimated widths; in pass 2 the field runs resolve and
+the TOC text is final.
+
+## Done-When
+
+- [ ] A 3-section document produces a TOC with 3 entries.
+- [ ] Each entry has the section title left, dot leader filling
+      middle, page number right.
+- [ ] Multi-page TOC flows correctly across pages.
+- [ ] Nested sections (level 2, 3) indent visibly.
+- [ ] Page numbers in TOC match actual page numbers from pass 1.

data/TODO.implementation/43-footnotes.md

@@ -0,0 +1,51 @@
+---
+priority: P2
+phase: 13
+depends_on: [20]
+layer: page
+est: 3d
+status: pending
+---
+
+## Problem
+
+Footnotes: inline reference number in body text, footnote body at
+the bottom of the page where the reference appears. The footnote
+region shrinks the body frame on that page; footnotes flow into it.
+If a footnote doesn't fit, it continues on the next page (with the
+body reference pointing to the original page).
+
+## Approach
+
+Files:
+
+- `lib/arrolio/footnote.rb` — `Footnote = Struct.new(:id, :content,
+  :marker, keyword_init: true)`. `content` is a Flowable list.
+
+- `lib/arrolio/output/footnote_region.rb` — a special Region placed
+  at the bottom of the body, separated by a horizontal rule.
+
+- `lib/arrolio/engine/footnote_collector.rb` — pass-1 hook: when a
+  Footnote flowable is placed on page N, register it on page N's
+  footnote region. Body frame on page N shrinks by the footnote
+  region's height.
+
+Engine integration:
+- Pass 1: place body flowables; when a footnote is encountered,
+  compute its height; reserve space at the bottom of the current
+  page's body; place the footnote content there.
+- If the footnote doesn't fit even alone on a fresh page, split it:
+  first part on the current page, continuation on next.
+
+Marker scheme: per-document counter; numeric by default, restart
+option per page or per section.
+
+## Done-When
+
+- [ ] A paragraph with one footnote renders the marker in body and
+      the footnote text at the page bottom.
+- [ ] Footnote region is separated from body by a horizontal rule.
+- [ ] Body frame shrinks to make room for footnotes.
+- [ ] Long footnote splits across pages.
+- [ ] Multiple footnotes on one page render in order.
+- [ ] Round-trip: re-read PDF has footnotes in expected positions.

data/TODO.implementation/44-multi-column.md

@@ -0,0 +1,45 @@
+---
+priority: P2
+phase: 13
+depends_on: [20]
+layer: page
+est: 3d
+status: pending
+---
+
+## Problem
+
+Magazines, newspapers, and some technical docs use multi-column body
+layout. Body content flows column-by-column; when one column fills,
+the next column on the same page begins; only when all columns are
+full does the engine advance to the next page.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/layout_spec/columns.rb` — `Columns = Struct.new(:count,
+  :gap, :balance, keyword_init: true)`. `count` = number of columns;
+  `gap` = gutter width; `balance` = bool (balance last page's columns).
+
+- `lib/arrolio/engine/column_layout.rb` — manages N parallel Frames
+  on a page. Body flowables fill column 1 first; when column 1's
+  frame is full, advance to column 2; etc.
+
+- `lib/arrolio/engine/column_balancer.rb` — for `balance: true` on
+  the last page, distribute content evenly across columns (uses
+  Breaker from TODO 14 with the column height as target).
+
+PageTemplate gains a `columns:` attribute that the engine consults
+when constructing the body frame.
+
+## Done-When
+
+- [ ] A 2-column layout places body content in left column first,
+      then right column on the same page.
+- [ ] Content overflows to next page only when both columns are full.
+- [ ] Column gap is respected.
+- [ ] `balance: true` produces roughly equal column heights on the
+      last page.
+- [ ] Footnotes (TODO 43) integrate: footnote region spans full
+      page width below the columns.

data/TODO.implementation/45-page-numbering-and-section-tracking.md

@@ -0,0 +1,50 @@
+---
+priority: P2
+phase: 13
+depends_on: [26, 39]
+layer: page
+est: 2d
+status: pending
+---
+
+## Problem
+
+Two related features:
+
+1. **Page numbering schemes**: front matter uses roman numerals (i,
+   ii, iii); body uses arabic (1, 2, 3) restarting at 1. Currently
+   Arrolio has only one global counter.
+2. **Section title in running header**: every body page's header
+   shows the current top-level section's title. Requires tracking
+   which section is "current" as content flows.
+
+## Approach
+
+Files:
+
+- `lib/arrolio/page_numbering_scheme.rb` — value object: `format`
+  (`:arabic`, `:roman_lower`, `:roman_upper`, `:alpha_lower`,
+  `:alpha_upper`), `start` (Integer, default 1), `prefix`, `suffix`.
+  Method `render(n)` → String.
+
+- Extend `PageSequenceMaster` (TODO 25) with `:page_numbering`
+  attribute. Each sequence can have its own scheme; restarting at
+  sequence start.
+
+- Extend `FlowContext` with `current_section` attribute. When the
+  engine places a Section heading flowable, it updates
+  `context.current_section = section`. Static content with
+  `{ text: context.current_section.title }` then resolves correctly.
+
+- Add `SectionTitleField < FieldRun` that returns
+  `context.current_section.title`.
+
+## Done-When
+
+- [ ] Front matter pages show roman numerals (i, ii, iii).
+- [ ] Body pages show arabic numerals starting from 1.
+- [ ] Section title in header changes as content crosses section
+      boundaries.
+- [ ] Multi-level section: header shows "Chapter 3" while body is in
+      Chapter 3, regardless of subsection depth.
+- [ ] Spec coverage for each scheme + section tracking.