ucode 0.1.0 → 0.1.1

data/TODO.full/11-fontist-org-audit-coverage.md

@@ -0,0 +1,140 @@
+# 11 — fontist.org: per-font ucode audit rendering (ALL fonts)
+
+## Goal
+
+Use ucode audit data from `fontist-archive-public/coverage/` to render
+per-font coverage information on fontist.org. This works for ALL
+fonts (open-license AND proprietary) because the audit YAML is
+metadata only — no font file redistribution needed.
+
+Pairs with TODO 10 (WOFF rendering for open-license). Together they
+give users:
+- Open-license fonts: actual glyphs + coverage stats
+- Proprietary fonts: coverage stats only (no glyph rendering)
+
+## Why a separate TODO
+
+Today fontist.org has `public/coverage/*.yaml` (audit data) but the
+unicode browser doesn't surface it. Users can't ask:
+- "Which fonts cover Sidetic?"
+- "Does Inter have CJK Unified Ideographs?"
+- "Show me glyphs in Noto Sans that Noto Serif is missing"
+
+The audit data answers all of these. This TODO wires it into the UI.
+
+## Scope
+
+### Phase A — Audit data layer
+
+1. New module: `src/lib/fonts/coverage.ts`:
+   - Loads a specific font's audit YAML: `fetch('/coverage/{slug}/{PSName}.yaml')`
+   - Parses the YAML (using `js-yaml` — needs to add as dependency)
+   - Returns a typed `FontCoverage` object
+
+2. **Type definitions** in `src/lib/fonts/types.ts`:
+   ```typescript
+   export interface FontCoverage {
+     source_sha256: string
+     family_name: string
+     postscript_name: string
+     total_codepoints: number
+     total_glyphs: number
+     blocks: {
+       name: string
+       range: string
+       covered: number
+       total: number
+       fill_ratio: number
+       complete: boolean
+     }[]
+     unicode_scripts: string[]
+     // ... etc
+   }
+   ```
+
+3. **Per-block index** — pre-compute a reverse index:
+   `block_id → list of fonts that cover it (with fill ratio)`.
+   Updated when coverage/ syncs. Lives at
+   `public/coverage/by-block.json` (generated by
+   `fontist-archive-private/bin/sync-from-private`).
+
+### Phase B — Coverage badge on font pages
+
+4. On `/fonts/{slug}` (FontStylePage), show:
+   - Total codepoints covered
+   - Per-block coverage bars (top 10 blocks by fill ratio)
+   - "View in unicode browser" button (sets active font + navigates
+     to /unicode/block/{slug})
+
+5. On `/families/{family-slug}` (FontFamilyPage), show:
+   - Aggregate coverage across all styles in the family
+   - Per-style breakdown
+
+### Phase C — Per-font unicode browser
+
+6. When user selects a font in the FontPicker (TODO 10):
+   - Load that font's audit YAML
+   - For each block in `/unicode`:
+     - Show fill ratio (%)
+     - Show "View N covered chars" → navigates to block filtered
+       to chars the font covers
+
+7. In the block grid (`UnicodeBlockGrid.vue`):
+   - Cells with chars the active font covers: render in the WOFF (TODO 10)
+   - Cells with chars the active font misses: gray out + tooltip
+     "Not covered by {font}"
+
+### Phase D — "Best font per block" view
+
+8. New page: `/unicode/best-fonts/{block-slug}`:
+   - Lists fonts sorted by fill ratio for that block
+   - Top result is the "canonical Tier 1 font" (matches ucode's
+     universal-set manifest — TODO.new 32)
+
+9. Useful for users asking "which font should I install for
+   Devanagari?" — the answer is the top of this list.
+
+### Phase E — Coverage comparison
+
+10. `/compare` page — already exists for visual font comparison.
+    Extend to show coverage diff:
+    - Pick 2+ fonts
+    - Show side-by-side: codepoints one covers that the other misses
+    - Reuse TODO.new/37 (coverage highlight reporter) infrastructure
+
+### Phase F — Proprietary fonts
+
+11. For proprietary fonts (Apple, Microsoft — flagged in
+    `fonts.json` via license field):
+    - No WOFF specimen (TODO 10 doesn't apply)
+    - Audit YAML IS available (TODO 09)
+    - Pages show coverage stats only + a note "WOFF specimen not
+      available — font is not open-license"
+
+## Acceptance
+
+- [ ] `src/lib/fonts/coverage.ts` parses audit YAMLs
+- [ ] `FontStylePage` shows per-block coverage stats
+- [ ] `FontPicker` selection drives coverage display on `/unicode`
+- [ ] Block grid shows covered/missing cells per active font
+- [ ] `/unicode/best-fonts/{block}` exists
+- [ ] `/compare` page shows coverage diff
+- [ ] Proprietary font pages show "coverage only" badge
+- [ ] Coverage reverse-index (`coverage/by-block.json`) is generated
+      by sync-from-private
+
+## Dependencies / blockers
+
+- **fontist-archive-public** — must have updated `coverage/` with ucode
+  audit shape (TODO 08 must land first)
+- **TODO 09** — archive structure includes coverage/ sync
+- **TODO 10** — FontPicker (Phase C uses it)
+
+## References
+
+- `public/coverage/*.yaml` — audit data
+- `src/pages/FontStylePage.vue` — font detail page
+- `src/pages/UnicodeBlockPage.vue` — block page (per-block coverage view)
+- [TODO 10](10-fontist-org-woff-glyphs.md) — WOFF rendering (pairs with this)
+- [TODO.new/37](../TODO.new/37-coverage-highlight-reporter.md) — highlight reporter
+- [TODO.new/36](../TODO.new/36-per-font-coverage-audit.md) — audit data layer

data/TODO.full/12-implementation-order.md

@@ -0,0 +1,216 @@
+# 12 — Implementation order (all TODO.full directives)
+
+## Goal
+
+Sequence all 11 TODOs (01-11) into a shipping plan with explicit
+dependencies, parallel tracks, and PR boundaries. Each TODO is one PR
+unless tightly coupled.
+
+## Critical path
+
+```
+                         ┌────────────────────────┐
+                         │  05 ucode 0.1.1 release │  ← unblocks everything
+                         └───────────┬────────────┘
+                                     │
+                ┌────────────────────┼─────────────────────┐
+                │                    │                      │
+                ▼                    ▼                      ▼
+   ┌────────────────────┐  ┌──────────────────┐  ┌──────────────────────┐
+   │  06 fontisan audit │  │  01-04 panglyph  │  │  (TODO.new 32-41     │
+   │     removal        │  │     bootstrap +  │  │   still in flight)   │
+   │  07 fontisan UCD   │  │     build + pub  │  └──────────┬───────────┘
+   │     removal        │  └────────┬─────────┘             │
+   │  (shipped as       │           │                       │
+   │   fontisan 0.3.0)  │           │                       │
+   └─────────┬──────────┘           │                       │
+             │                      │                       │
+             ▼                      ▼                       ▼
+   ┌────────────────────┐  ┌──────────────────────────────────┐
+   │  08 archive-       │  │  09 archive-public structure      │
+   │     private        │  │  (coverage + woff + unicode +     │
+   │     bin/build      │  │   panglyph all live here)         │
+   │     refactor       │  └─────────────┬────────────────────┘
+   └─────────┬──────────┘                │
+             │                           │
+             └───────────┬───────────────┘
+                         │
+                         ▼
+            ┌─────────────────────────┐
+            │  10 fontist.org WOFF    │
+            │     rendering           │
+            │  11 fontist.org audit   │
+            │     rendering           │
+            └─────────────────────────┘
+```
+
+## Phase 1 — Foundation releases
+
+### Track F1 — ucode 0.1.1 patch (TODO 05)
+
+**Repo**: `fontist/ucode`
+**Branch**: `release/0.1.1`
+**PR**: ucode/PR-XX
+
+- Bump version, write CHANGELOG, run tests
+- Open PR
+- **HARD GATE**: wait for explicit user authorization before tag/release
+- After merge: tag v0.1.1, `rake release` to rubygems
+
+**Estimated**: 1 session to prep; release timing depends on user.
+
+### Track F2 — panglyph repo bootstrap (TODO 01, 02)
+
+**Repo**: `fontist/panglyph` (NEW)
+**Branch**: `main` (initial commit)
+**PR**: N/A (initial repo creation)
+
+- Create the repo on GitHub
+- Bootstrap skeleton per TODO 02
+- README + LICENSE (OFL) + minimal gemspec + CLI stub
+- No build logic yet (TODO 03)
+
+**Estimated**: 1 session. No external dependencies.
+
+### Track F3 — fontisan cleanup (TODO 06, 07)
+
+**Repo**: `fontist/fontisan`
+**Branch**: `audit/remove-audit-and-ucd` (off main, not off `fix/ucdxml-real-shape-parsing`)
+**PR**: fontisan/PR-XX
+
+- Delete audit + UCD subsystems
+- Update README + CHANGELOG
+- Bump version to 0.3.0
+- Run specs to verify nothing else breaks
+
+**Estimated**: 2 sessions. Should land AFTER ucode 0.1.1 (so consumers
+have somewhere to migrate to).
+
+## Phase 2 — Pipeline wiring
+
+### Track P1 — fontist-archive-private refactor (TODO 08)
+
+**Repo**: `fontist/fontist-archive-private`
+**Branch**: `audit/use-ucode-and-fontisan-0-3`
+**PR**: archive-private/PR-XX
+
+- Blocked by F1 (ucode 0.1.1) + F3 (fontisan 0.3.0)
+- Refactor `bin/build` to call `ucode audit font` + `fontisan convert`
+- Remove UCD stub hack
+- Update Gemfile + CI workflow
+
+**Estimated**: 2 sessions.
+
+### Track P2 — panglyph build implementation (TODO 03)
+
+**Repo**: `fontist/panglyph`
+**Branch**: `feat/font-builder`
+**PR**: panglyph/PR-XX
+
+- Blocked by TODO.new 32-35 (universal set must exist as input)
+- Implement OutlineExtractor + FontAssembler + Woff2Writer
+- (May require extending fontisan with font-WRITING APIs — separate PR
+  to fontisan if so)
+
+**Estimated**: 4-5 sessions. Largest piece of new code.
+
+### Track P3 — panglyph publish pipeline (TODO 04)
+
+**Repo**: `fontist/panglyph`
+**Branch**: `feat/publish-pipeline`
+**PR**: panglyph/PR-XX
+
+- Blocked by P2 (build must produce artifacts)
+- Implement `panglyph publish` + CI workflow
+- Updates fontist-archive-public/panglyph/
+
+**Estimated**: 1 session.
+
+### Track P4 — fontist-archive-public structure (TODO 09)
+
+**Repo**: `fontist/fontist-archive-public`
+**Branch**: `audit/restructure-with-unicode-and-panglyph`
+**PR**: archive-public/PR-XX
+
+- Add `unicode/` directory (synced from ucode)
+- Add `panglyph/` directory (synced from panglyph)
+- Add three sync workflows (sync-private, sync-ucode, sync-panglyph)
+- Update README to document structure
+
+**Estimated**: 1-2 sessions.
+
+## Phase 3 — Consumer wiring
+
+### Track C1 — fontist.org WOFF rendering (TODO 10)
+
+**Repo**: `fontist/fontist.github.io`
+**Branch**: `feat/per-font-woff-rendering`
+**PR**: fontist.github.io/PR-XX
+
+- Blocked by P1 (WOFF specimens in archive-public) + P4 (structure)
+- useFontFace composable + FontPicker + grid rendering
+
+**Estimated**: 3 sessions.
+
+### Track C2 — fontist.org audit coverage (TODO 11)
+
+**Repo**: `fontist/fontist.github.io`
+**Branch**: `feat/per-font-audit-coverage`
+**PR**: fontist.github.io/PR-XX
+
+- Blocked by P1 (audit data in archive-public)
+- Can run in parallel with C1
+- Coverage data layer + per-block views + comparison
+
+**Estimated**: 3 sessions.
+
+## Sequencing rules
+
+1. **PR-per-TODO.** No bundled PRs.
+2. **Hard gate on tag/release.** ucode 0.1.1, fontisan 0.3.0, panglyph
+   17.0.0 tags all require explicit user authorization.
+3. **F3 (fontisan cleanup) must NOT land before F1 (ucode 0.1.1).**
+   Otherwise consumers have nowhere to migrate to.
+4. **P1 depends on F1 + F3.** Can't call `ucode audit font` if ucode
+   isn't published.
+5. **P2 + P3 (panglyph) can run in parallel with P1 (archive-private)
+   and P4 (archive-public).** Disjoint repos, no shared files.
+6. **C1 + C2 can run in parallel.** Different consumers of the same data.
+7. **External review doesn't block local progress.** If a PR is in
+   review, continue with the next TODO in the same track.
+
+## Branch naming
+
+- ucode: `audit/<track-slug>` or `release/<version>`
+- panglyph: `feat/<track-slug>` or `release/<version>`
+- fontisan: `audit/<track-slug>`
+- archive-private: `audit/<track-slug>`
+- archive-public: `audit/<track-slug>`
+- fontist.org: `feat/<track-slug>`
+
+## What's NOT in scope
+
+- **Color emoji font** (Noto Color Emoji uses CBDT/CBLC bitmap tables
+  — panglyph would need a separate path). Separate TODO if needed.
+- **Real-time glyph extraction service.** Users extracting glyphs on
+  demand. Out of scope; panglyph is pre-built.
+- **Per-version diff visualizer.** Tracking how a codepoint's glyph
+  changes across Unicode versions. Useful but separate.
+- **Mobile optimization of fontist.org.** Existing site is responsive;
+  no separate mobile work.
+
+## Acceptance
+
+- [ ] Every TODO 01-11 has an assigned branch + PR-per-TODO
+- [ ] Critical path is unambiguous
+- [ ] Parallel tracks identified explicitly
+- [ ] External dependencies (fontist/formulas, gem review) called out
+- [ ] Out-of-scope items listed
+
+## References
+
+- [TODO.new/39](../TODO.new/39-implementation-order-update-32-38.md) — prior sequencing
+- [TODO 01](01-panglyph-vision.md) — panglyph vision
+- [TODO 05](05-ucode-0-1-1-release.md) — ucode release (Phase 1)
+- [TODO 08](08-archive-private-bin-build.md) — pipeline (Phase 2)
+- [TODO 10](10-fontist-org-woff-glyphs.md) — consumer (Phase 3)

data/TODO.full/13-fontisan-font-writer-api.md

@@ -0,0 +1,189 @@
+# 13 — fontisan FontWriter: clean API for writing fonts from scratch
+
+## Goal
+
+Add a `Fontisan::FontWriter` class that lets callers assemble a new
+font file (TTF/OTF) from scratch — cmap + glyf + name + metrics +
+required housekeeping tables. This is the missing primitive panglyph
+(TODO.full/03) needs to actually produce a font.
+
+## Why this is a separate TODO
+
+fontisan today only **reads** fonts (cmap walk, glyf extraction) and
+**converts** between formats (TTF → WOFF via re-serialization of
+existing tables). Neither path can build a new font from scratch.
+
+panglyph needs to:
+1. Read outlines from N source fonts (fontisan already can)
+2. Write a single merged font with those outlines + a fresh cmap
+
+Step 2 is the gap. This TODO fills it with a clean, well-abstracted API.
+
+## Architectural principles
+
+Following the project's quality bar:
+
+### OCP — one class per table
+
+Each OpenType table is its own writer class, registered in a single
+dispatch. Adding a new table = adding a new class, NOT modifying
+existing code.
+
+```
+Fontisan::FontWriter (orchestrator)
+  └── Tables::* (one per OpenType table)
+        ├── Head
+        ├── Cmap
+        ├── Name
+        ├── Hmtx
+        ├── Hhea
+        ├── Glyf
+        ├── Loca
+        ├── Maxp
+        ├── Os2
+        └── Post
+```
+
+### MECE — single responsibility per class
+
+- `FontWriter` — orchestrates; holds the in-memory font model
+- `Tables::Head` — knows head table layout (35 fields, byte order)
+- `Tables::Cmap` — knows cmap subtable formats (4 for BMP, 12 for full)
+- `Tables::Glyf` — knows TrueType outline serialization
+- etc.
+
+### SSOT — table tags live in one place
+
+`Fontisan::FontWriter::TABLE_TAGS` constant. Adding a new table =
+adding to this constant; the orchestrator auto-discovers and calls
+the right writer.
+
+### Model-driven — typed structures, not hashes
+
+Outline points, name records, metrics — all typed structs/classes.
+No `attribute :foo, :hash` anywhere (per global rule).
+
+## API design
+
+```ruby
+# lib/fontisan/font_writer.rb
+
+module Fontisan
+  class FontWriter
+    autoload :Tables, "fontisan/font_writer/tables"
+    autoload :FontModel, "fontisan/font_writer/font_model"
+    autoload :Outline, "fontisan/font_writer/outline"
+    autoload :NameRecord, "fontisan/font_writer/name_record"
+    autoload :Metrics, "fontisan/font_writer/metrics"
+
+    def initialize(format: :ttf)
+      @format = format
+      @model = FontModel.new
+    end
+
+    # @param unicode_map [Hash{Integer => Integer}] cp → gid
+    def set_cmap(unicode_map)
+      @model.cmap = unicode_map
+    end
+
+    # @param gid [Integer]
+    # @param outline [Outline] points + flags
+    # @param metrics [Metrics] advance width + lsb
+    def add_glyph(gid, outline:, metrics:)
+      @model.glyphs[gid] = GlyphEntry.new(outline: outline, metrics: metrics)
+    end
+
+    # @param records [Array<NameRecord>] language-tagged name records
+    def set_name_records(records)
+      @model.names = records
+    end
+
+    # @param version [String] e.g. "Version 17.0.0"
+    def set_version(version)
+      @model.font_version = version
+    end
+
+    # Writes the font to +path+ in the initialized format (ttf or otf).
+    # @return [Pathname]
+    def write_to(path)
+      Tables::Assembler.new(@model, format: @format).write(path)
+    end
+  end
+end
+```
+
+## Typed data structures
+
+```ruby
+# lib/fontisan/font_writer/outline.rb
+class Fontisan::FontWriter::Outline < Struct.new(
+  :contours, :instructions, :is_composite, keyword_init: true
+)
+  # contours: Array<Array<Point>>
+  # instructions: String (byte stream) or nil
+  # is_composite: bool — true if this glyph is a composite reference
+end
+
+# lib/fontisan/font_writer/point.rb
+class Fontisan::FontWriter::Point < Struct.new(
+  :x, :y, :on_curve, keyword_init: true
+)
+end
+
+# lib/fontisan/font_writer/name_record.rb
+class Fontisan::FontWriter::NameRecord < Struct.new(
+  :name_id, :platform_id, :encoding_id, :language_id, :string, keyword_init: true
+)
+  # Standard name_ids per OpenType spec (0=family, 1=subfamily, etc.)
+end
+
+# lib/fontisan/font_writer/metrics.rb
+class Fontisan::FontWriter::Metrics < Struct.new(
+  :advance_width, :left_side_bearing, keyword_init: true
+)
+end
+
+# lib/fontisan/font_writer/glyph_entry.rb
+class Fontisan::FontWriter::GlyphEntry < Struct.new(
+  :outline, :metrics, keyword_init: true
+)
+end
+```
+
+## Scope
+
+### Phase A — Foundation (this TODO)
+
+1. Define `Fontisan::FontWriter` class with the API above.
+2. Define typed structs (Outline, Point, NameRecord, Metrics, GlyphEntry).
+3. Define `FontModel` — internal in-memory representation.
+4. Define `Tables::Assembler` — orchestrates table serialization.
+5. Implement `Tables::Head` (writes a fixed head table — simplest case).
+
+### Phase B — Real table writers (TODO.full/14)
+
+6. Implement `Tables::Cmap` (formats 4 + 12).
+7. Implement `Tables::Hmtx` + `Tables::Hhea` (metrics).
+8. Implement `Tables::Glyf` + `Tables::Loca` (TrueType outlines).
+9. Implement `Tables::Maxp`, `Tables::Os2`, `Tables::Post`, `Tables::Name`.
+
+### Phase C — Validation
+
+10. After writing, re-open with `Fontisan::Font.open` to verify the
+    output parses correctly (round-trip check).
+11. Validate against the OpenType spec checklist.
+
+## Acceptance
+
+- [ ] `Fontisan::FontWriter` class exists with documented API
+- [ ] All typed structs defined (no `:hash` attributes)
+- [ ] `Tables::Head` writes a valid head table byte sequence
+- [ ] Specs cover the public API + Head table serialization
+- [ ] Uses Ruby autoload (no require_relative)
+- [ ] No `send` to private methods; no `instance_variable_get/set`; no `respond_to?`
+
+## References
+
+- [TODO.full/03](03-panglyph-font-builder.md) — consumer (panglyph)
+- [TODO.full/14](14-fontisan-table-writers.md) — Phase B
+- OpenType specification: https://learn.microsoft.com/en-us/typography/opentype/spec/

data/TODO.full/14-fontisan-table-writers.md

@@ -0,0 +1,66 @@
+# 14 — fontisan table writers: real serialization for every required table
+
+## Goal
+
+Implement the per-table writer classes referenced by TODO 13. After
+this TODO, `Fontisan::FontWriter#write_to(path)` produces a valid
+TTF file that opens in any font consumer.
+
+## Scope
+
+One class per OpenType table, all under `Fontisan::FontWriter::Tables::*`:
+
+### `Tables::Head`
+- 35 fixed fields; writes the canonical head structure
+- Uses `BinData`-style binary packing (or `pack("...")` templates)
+
+### `Tables::Hhea` + `Tables::Hmtx`
+- Hhea: 18 fixed fields
+- Hmtx: per-glyph advanceWidth + lsb (long or short record based on glyph count)
+
+### `Tables::Maxp`
+- TrueType: 16 fields; numGlyphs populated from FontModel
+- CFF: 5 fields
+
+### `Tables::Name`
+- Multi-record: name_id × platform_id × encoding_id × language_id
+- Standard name_ids: 0=copyright, 1=family, 2=subfamily, 4=full name,
+  5=version, 6=PostScript name
+
+### `Tables::OS2`
+- 60+ fields (varies by version: v0=58, v5=68)
+- Includes the 4 ulUnicodeRange bitfields (computed from FontModel.cmap)
+
+### `Tables::Post`
+- Glyph names table; format 2 is most flexible
+- Per-glyph PostScript name index
+
+### `Tables::Cmap`
+- Subtable 4 (BMP, format 4) — segment mapping to delta
+- Subtable 12 (full Unicode, format 12) — sparse groups
+- Spliced into a single cmap table with proper platform/encoding headers
+
+### `Tables::Glyf` + `Tables::Loca`
+- TrueType outline serialization: contour count → endpoints → flags → x-coords → y-coords → instructions
+- Composite glyphs (referencing other glyphs by GID) supported
+- Loca: offsets into glyf (short format if all glyphs fit in 2-byte words, long otherwise)
+
+### `Tables::Assembler`
+- Computes table order (head + hhea + maxp + os2 + hmtx + cmap + post + loca + glyf + name)
+- Writes offset table + table directory
+- Aligns each table to 4-byte boundaries
+- Computes checksums per table + the head checkSumAdjustment
+
+## Acceptance
+
+- [ ] Each table class exists with `#bytes(model)` returning a String
+- [ ] `Tables::Assembler#write(path)` produces a TTF that opens via `Fontisan::Font.open`
+- [ ] All fields validate against the OpenType spec
+- [ ] Composite glyphs serialize correctly
+- [ ] Per-table specs cover edge cases (empty font, single glyph, full Unicode range)
+- [ ] Uses Ruby autoload
+
+## References
+
+- [TODO.full/13](13-fontisan-font-writer-api.md) — API design
+- OpenType spec (per-table reference)

data/TODO.full/15-panglyph-builder-real.md

@@ -0,0 +1,82 @@
+# 15 — panglyph Builder real implementation (uses FontWriter)
+
+## Goal
+
+Wire panglyph's `Builder` to actually produce a TTF using
+`Fontisan::FontWriter`. Replaces the stub from TODO.full/03 with a
+real pipeline that:
+
+1. Reads ucode's universal-set manifest
+2. Opens each Tier 1 source font via `Fontisan::Font.open`
+3. Walks the cmap → glyf for each codepoint
+4. Assembles a single TTF via `Fontisan::FontWriter`
+5. Validates the output
+
+## Why this is a separate TODO
+
+The skeleton classes exist (pushed in initial panglyph commit). They
+warn "stub" because fontisan couldn't write fonts. TODO 13 + 14 add
+that capability. This TODO makes panglyph USE it.
+
+## Scope
+
+1. Replace `OutlineExtractor#extract_many` stub with real fontisan calls:
+   ```ruby
+   font = Fontisan::Font.open(font_path, font_index:)
+   codepoints.each do |cp|
+     gid = font.cmap.unicode_map[cp]
+     next unless gid
+     outline_bytes = font.glyf.raw_bytes_for(gid)
+     advance_width = font.hmtx.advance_width(gid)
+     lsb = font.hmtx.lsb(gid)
+     extracted[cp] = Outline.new(
+       contours: parse_contours(outline_bytes),
+       instructions: parse_instructions(outline_bytes),
+       is_composite: font.glyf.composite?(gid),
+     )
+     metrics[cp] = Metrics.new(advance_width:, left_side_bearing: lsb)
+   end
+   ```
+
+2. Replace `FontAssembler#assemble` stub:
+   ```ruby
+   writer = Fontisan::FontWriter.new(format: :ttf)
+   writer.set_cmap(unicode_to_gid)
+   writer.set_name_records([
+     NameRecord.new(name_id: 1, platform_id: 3, encoding_id: 1, language_id: 0x409,
+                    string: "panglyph Unicode #{major_version}"),
+     # ...
+   ])
+   writer.set_version("Version #{ucd_version}")
+   outlines.each do |cp, outline|
+     gid = unicode_to_gid[cp]
+     writer.add_glyph(gid, outline:, metrics: metrics[cp])
+   end
+   writer.write_to(ttf_path)
+   ```
+
+3. Real `CoverageReport` — walks the output TTF's cmap, compares to manifest.
+
+4. Real `Publisher` — syncs to fontist-archive-public via git.
+
+## Performance considerations
+
+- 299,382 codepoints × ~1ms each = ~5 minutes for extraction
+- Outline parsing dominates CPU; parallelize per source font
+- Memory: hold all outlines in memory (~1.2GB estimated); use streaming
+  write to disk if low-memory CI runners complain
+
+## Acceptance
+
+- [ ] `bundle exec panglyph build 17.0.0` produces a TTF
+- [ ] Built TTF opens via `Fontisan::Font.open`
+- [ ] Built TTF's cmap contains every codepoint in the manifest
+- [ ] Built TTF renders in a browser (manual smoke test)
+- [ ] Build completes in <30 minutes on a single runner
+- [ ] No stubs remain in Builder / OutlineExtractor / FontAssembler
+
+## References
+
+- [TODO.full/03](03-panglyph-font-builder.md) — original skeleton
+- [TODO.full/13](13-fontisan-font-writer-api.md) — FontWriter API
+- [TODO.full/14](14-fontisan-table-writers.md) — table writers