fontisan 0.4.23 → 0.4.25

data/TODO.improvements/12-cbdt-fixture-bindata-conversion.md

@@ -0,0 +1,68 @@
+# 12 — `cbdt_fixture.rb` full BinData conversion
+
+## Priority
+P3
+
+## Problem
+
+`spec/support/cbdt_fixture.rb` was partially refactored in PR #107 (CBDT/CBLC use the new BinData models), but the remaining tables still hand-roll binary packing:
+
+- `head_table` — 19-element `[...].pack("NNNNnnNNnnnnnnnnnn")`
+- `hhea_table` — 16-element pack
+- `os2_table` — 43-element pack
+- `name_table` — manual record + offset arithmetic
+- `post_table` — manual pack
+- `hmtx_table` — `Array.new(num_glyphs) { [1000, 0] }.flatten.pack("n*")`
+- `cmap_table` / `format4_subtable` / `format12_subtable` — full cmap builder, ~80 lines
+
+~200 lines of pack/unpack that duplicate the layout knowledge in `Tables::*`. If any table layout changes, the fixture breaks silently — the same anti-pattern PR #107 already fixed for CBDT/CBLC.
+
+## Goal
+
+Every table builder in `cbdt_fixture.rb` constructs via BinData record (`Tables::Head`, `Tables::Hhea`, `Tables::Maxp`, `Tables::Os2`, `Tables::Name`, `Tables::Post`, `Tables::Hmtx`, `Tables::Cmap`). No more `[...].pack(...)` calls.
+
+The fixture's self-test (`spec/support/cbdt_fixture_spec.rb`) catches any drift between the fixture's output and the BinData models.
+
+## Approach
+
+For each table, replace the hand-rolled pack with a `Tables::*` BinData construction:
+
+```ruby
+# Before
+def head_table
+  [0x00010000, 0x00005000, ...].pack("NNNNnnNNnnnnnnnnnn")
+end
+
+# After
+def head_table
+  Tables::Head.new(
+    version_raw: 0x00010000,
+    font_revision: 0x00005000,
+    ...
+  ).to_binary_s
+end
+```
+
+For tables with field shapes that don't match the BinData record cleanly (e.g., `name_table`'s variable-length string storage), use the BinData record's nested array attributes.
+
+For `cmap_table`: extract the format-4 / format-12 subtable builders to a reusable `Tables::Cmap.from_mappings(mappings)` class method. The same logic is duplicated in `Subset::TableStrategy::Cmap::Builder` and `Subset::TableStrategy::ColorBitmapSubsetter` — DRY win across three call sites.
+
+## Out of scope
+
+- Refactoring the BinData models themselves — only changes the fixture's consumers.
+- Adding `Tables::Cmap.from_mappings` if the DRY extraction scope proves larger than the fixture alone (split into separate PR).
+
+## Effort
+
+~4 hours.
+
+## Dependencies
+
+None.
+
+## Acceptance criteria
+
+- `spec/support/cbdt_fixture.rb` contains zero `[...].pack` calls.
+- `spec/support/cbdt_fixture_spec.rb` self-test still passes (it round-trips via the BinData models; the assertions don't change).
+- All downstream specs that use `CbdtFixture` still pass.
+- Bundle size of the fixture file drops from ~300 lines to ~150.

data/TODO.improvements/13-split-octokit-fetcher.md

@@ -0,0 +1,45 @@
+# 13 — Split `OctokitFetcher` out of `fixture_downloader.rb`
+
+## Priority
+P3
+
+## Problem
+
+`spec/support/fixture_downloader.rb` (post-PR #111) is ~350 lines with two distinct concerns:
+
+1. **Retry / routing loop** (the `Downloader` class) — backoff, Retry-After, permanent-vs-transient classification.
+2. **Octokit URL dispatch** (the `OctokitFetcher` module) — release-asset, raw-file, contents-API routing.
+
+These are MECE-distinct. Bundling them in one file muddies the boundary; future changes to Octokit routing shouldn't require reading the retry loop.
+
+## Goal
+
+`OctokitFetcher` moves to its own file `spec/support/fixture_downloader/octokit_fetcher.rb`. The `Downloader` class becomes the only public surface in `spec/support/fixture_downloader.rb` and delegates to `OctokitFetcher` when needed.
+
+## Approach
+
+1. Create `spec/support/fixture_downloader/` directory.
+2. Move `OctokitFetcher` module to `spec/support/fixture_downloader/octokit_fetcher.rb`.
+3. Move `HttpStatusIo` and `Downloader` constants stay in `spec/support/fixture_downloader.rb`.
+4. Add a `module FixtureFonts::Downloader` autoload or simple `require_relative "fixture_downloader/octokit_fetcher"` from `fixture_downloader.rb`.
+
+Actually — for spec/support files, `require_relative` is acceptable (CLAUDE.md rule on autoload is for `lib/`). No autoload needed; the Rakefile's `require_relative` chain handles loading.
+
+## Out of scope
+
+- Splitting the Downloader further — it's cohesive.
+- Moving `fixture_downloader_spec.rb` — already sibling, fine where it is.
+
+## Effort
+
+~1 hour.
+
+## Dependencies
+
+None.
+
+## Acceptance criteria
+
+- `spec/support/fixture_downloader.rb` < 200 lines.
+- `spec/support/fixture_downloader/octokit_fetcher.rb` exists and contains all Octokit-specific code.
+- All existing specs pass unchanged.

data/TODO.improvements/14-rubocop-baseline-chip.md

@@ -0,0 +1,62 @@
+# 14 — Rubocop baseline chip (per-namespace)
+
+## Priority
+P3
+
+## Problem
+
+PR #111's `rubocop -A --auto-gen-config` baseline refresh tracked ~9600 remaining offenses. The `.rubocop_todo.yml` file is now ~800 lines of `Exclude:` lists. Layout/Style cops dominate (most are auto-correctable; the rest need manual fixes).
+
+Leaving the baseline in this state makes future rubocop improvements invisible — new offenses are buried in baseline noise, and contributors can't see whether their PR is clean vs. baseline-burdened.
+
+## Goal
+
+Reduce baseline count to < 1000 offenses via per-namespace PRs:
+
+| Namespace | Approximate count | Priority |
+|-----------|-------------------|----------|
+| `lib/fontisan/tables/` | ~3000 | High (well-understood) |
+| `lib/fontisan/ufo/compile/` | ~2500 | High |
+| `lib/fontisan/stitcher/` | ~800 | Medium |
+| `lib/fontisan/converters/` | ~500 | Medium |
+| `lib/fontisan/type1/` | ~400 | Medium |
+| `lib/fontisan/collection/` | ~300 | Medium |
+| `lib/fontisan/subset/` | ~300 | Medium (recent PR #106 work) |
+| `lib/fontisan/woff2/` | ~250 | Medium |
+| `lib/fontisan/optimizers/` | ~200 | Low |
+| `lib/fontisan/pipeline/` | ~200 | Low |
+| `lib/fontisan/commands/` | ~150 | Low |
+| `lib/fontisan/validators/` | ~100 | Low |
+| `lib/fontisan/binary/` | ~100 | Low |
+| `spec/` | ~1500 | Low |
+
+## Approach
+
+One PR per namespace. Each PR:
+
+1. Runs `rubocop -A lib/fontisan/<namespace>/` to auto-correct everything possible.
+2. Manually fixes what auto-correct couldn't (typically: complex Layout cops, naming).
+3. Updates `.rubocop_todo.yml` to drop the now-cleaned `Exclude:` entries.
+4. Verifies the full test suite still passes.
+
+Order: tables first (highest count, lowest risk — table parsing is purely structural).
+
+## Out of scope
+
+- Disabling cops project-wide — these are real issues, not noise.
+- Refactoring architectural patterns rubocop flags (e.g., long methods) — separate refactors.
+
+## Effort
+
+~30 minutes per namespace on average. ~7 hours total.
+
+## Dependencies
+
+None.
+
+## Acceptance criteria
+
+- `.rubocop_todo.yml` < 100 lines (from ~800).
+- `bundle exec rubocop` reports 0 offenses.
+- All existing specs pass after each namespace PR.
+- No behavior change (pure style/layout).

data/TODO.improvements/README.md

@@ -0,0 +1,57 @@
+# Fontisan Improvements Backlog
+
+This directory tracks all known improvement work, ordered by priority.
+Each file is `NN-short-name.md` where `NN` is the priority order.
+
+## Priorities
+
+### P0 — Correctness gaps (open bugs / silent failures)
+- [01 — CBDT/CBLC GID-stable propagation](01-cbdt-cblc-gid-stable-propagation.md)
+- [02 — Collection-mode outline-priority regression](02-collection-outline-priority.md)
+
+### P1 — High-value features
+- [03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)
+- [04 — UFO composite glyph encoding](04-ufo-composite-glyph-encoding.md)
+- [05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md)
+
+### P2 — Specialist feature parity
+- [x] ~~[07 — CPAL v1 header fields](07-cpal-v1-header-fields.md)~~ ✓ Done
+- [06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)
+- [08 — CFF standard string table](08-cff-standard-string-table.md)
+- [09 — Type 1 seac expansion](09-type1-seac-expansion.md)
+- [10 — UFO image set + feature writers](10-ufo-image-set-feature-writers.md)
+- [11 — kern groups.plist support](11-kern-groups-plist.md)
+
+### P3 — Code-quality cleanup
+- [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (commit `4c68f2a`)
+- [12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)
+- [14 — Rubocop baseline chip (per-namespace)](14-rubocop-baseline-chip.md)
+
+## Convention
+
+Each TODO file follows this template:
+
+```markdown
+# NN — Title
+
+## Priority
+P0 / P1 / P2 / P3
+
+## Problem
+What's broken or missing. Concrete examples.
+
+## Goal
+What good looks like. Acceptance criteria.
+
+## Approach
+Architecture-level sketch. Files to add/change. Constraints.
+
+## Out of scope
+Explicit non-goals.
+
+## Effort
+Rough estimate (hours/days).
+
+## Dependencies
+Other TODOs that must land first.
+```

data/benchmark/compile_benchmark.rb

@@ -24,10 +24,17 @@ module FontisanBench
       g.width = 500
       g.add_unicode(0xE000 + i) if i < 0x1000
       g.add_contour(Fontisan::Ufo::Contour.new([
-                                                 Fontisan::Ufo::Point.new(x: 0, y: 0, type: "line"),
-                                                 Fontisan::Ufo::Point.new(x: 100, y: 0, type: "line"),
-                                                 Fontisan::Ufo::Point.new(x: 100, y: 100, type: "offcurve"),
-                                                 Fontisan::Ufo::Point.new(x: 50, y: 150, type: "curve"),
+                                                 Fontisan::Ufo::Point.new(x: 0,
+                                                                          y: 0, type: "line"),
+                                                 Fontisan::Ufo::Point.new(
+                                                   x: 100, y: 0, type: "line",
+                                                 ),
+                                                 Fontisan::Ufo::Point.new(
+                                                   x: 100, y: 100, type: "offcurve",
+                                                 ),
+                                                 Fontisan::Ufo::Point.new(
+                                                   x: 50, y: 150, type: "curve",
+                                                 ),
                                                ]))
       font.glyphs["g#{i}"] = g
     end
@@ -38,7 +45,8 @@ module FontisanBench
     start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     yield
     elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-    puts format("%-40<label>s %8.<elapsed>.2f ms", label: label, elapsed: elapsed * 1000)
+    puts format("%-40<label>s %8.<elapsed>.2f ms", label: label,
+                                                   elapsed: elapsed * 1000)
     elapsed
   end
 end

data/docs/.vitepress/config.ts

@@ -322,6 +322,7 @@ export default defineConfig({
             { text: "ConversionOptions", link: "/api/conversion-options" },
             { text: "SfntFont", link: "/api/sfnt-font" },
             { text: "Type1Font", link: "/api/type1-font" },
+            { text: "Ufo::Layer", link: "/api/layer" },
           ],
         },
         {

data/docs/STITCHER_GUIDE.adoc

@@ -364,12 +364,56 @@ stitcher.write_to("out.ttf", format: :ttf, subfont: :main)
 # → out.ttf has glyf + CBDT + CBLC, emoji renders correctly
 ----
 
-Constraints:
+=== Outline-first cmap priority
+
+When a codepoint is covered by BOTH an outline donor and the CBDT
+donor, the cmap maps it to the outline glyph — never to the CBDT
+placeholder. The Cmap compiler follows first-wins semantics, and
+`GlyphCopier` runs before `CbdtPropagator` so the outline GID is
+registered first. This was the fix for the Emoticons cmap-loss bug
+where shared codepoints silently dropped out of the cmap.
+
+=== Placeholder name deconfliction
+
+CBDT placeholders are named after the source's glyph IDs
+(`"gid1"`, `"gid2"`, …), which is the SAME naming scheme
+`Source#extract_truetype_glyph` uses for outline glyphs from TTF
+donors. Without protection, a placeholder at `"gid110"` would
+silently overwrite an outline glyph at `"gid110"` from a different
+donor via `Layer#add` — the original cmap-loss vector for the
+Essenfont CJK Ext G regression.
+
+The Stitcher resolves this with two pieces:
+
+* `Ufo::Layer#add` RAISES `Ufo::GlyphExistsError` on name conflict.
+  Silent overwrites are no longer possible. Callers that want to
+  replace an existing glyph use the explicit `Ufo::Layer#put`.
+* `Stitcher::UniqueGlyphName.in(target, base)` allocates a
+  non-colliding name (`"gid110"`, then `"gid110.1"`, `"gid110.2"`,
+  …). `GlyphCopier` and `CbdtPropagator` both call it before every
+  `Layer#add`, so each glyph lands at its own GID slot without
+  touching the others.
+
+=== Limitations
 
 * Only ONE CBDT source per Stitcher. Multiple CBDT sources raise
   `Fontisan::MultipleCbdtSourcesError`.
-* The CBDT source is processed first (GIDs 0..N-1) so the CBLC's GID
-  references remain valid in the output.
+* **GID stability for overlapping codepoint ranges.** The raw-bytes
+  CBDT/CBLC propagation (`CbdtPropagator#propagate_tables_into`)
+  copies the source's CBLC verbatim. CBLC indexes glyphs by SOURCE
+  GID. After placeholder renaming (`"gid110"` → `"gid110.1"`), the
+  compiled GID no longer matches the source GID, so CBLC's source-
+  GID-indexed bitmaps can dangle. This is masked in the typical
+  Essenfont case (CBDT donor NotoColorEmoji and outline donors
+  cover disjoint codepoint ranges) but would produce wrong bitmaps
+  for any stitch where CBDT and outline sources share codepoint
+  ranges. A proper fix requires a CBLC rebuild pass that walks the
+  compiled cmap to remap source GIDs to compiled GIDs — tracked as
+  follow-up.
+* **Collection-mode single-face coverage.** Each face is compiled
+  independently; `CbdtPropagator` currently requires at least one
+  outline codepoint per face. Collection-mode coverage of the
+  outline-first cmap-priority invariant is tracked as follow-up.
 
 == CLI
 

data/docs/api/layer.md

@@ -0,0 +1,89 @@
+---
+title: Ufo::Layer
+---
+
+# `Ufo::Layer`
+
+A single layer in a UFO source. A `Layer` holds a set of glyphs keyed by name. The default layer is `public.default` per UFO 3.
+
+```ruby
+layer = Fontisan::Ufo::Layer.new                       # => "public.default"
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+layer["A"]                                             # => the glyph
+layer.size                                             # => 1
+```
+
+## Naming contract
+
+Glyph names are the layer's primary key. Two distinct glyphs with the same name cannot coexist — adding the second would silently destroy the first, a class of bug that has historically cost real data (e.g. the CJK Ext G cmap loss when CBDT placeholders collided with outline glyphs sharing `"gid{N}"` names).
+
+To make that contract unbreakable, the API exposes two methods with named semantics:
+
+| Method | Behavior on conflict |
+|--------|----------------------|
+| `Layer#add(glyph)` | **Raises** `Ufo::GlyphExistsError` (the safe default) |
+| `Layer#put(glyph)` | Overwrites the existing glyph (explicit replace) |
+
+Callers that need auto-renaming — insert without giving up on a collision — call `Stitcher::UniqueGlyphName.in(target, base)` first to allocate a free name, then `Layer#add` the glyph under that name.
+
+## API
+
+### `Layer.new(name = "public.default")`
+
+Initialize an empty layer.
+
+### `#add(glyph) -> Glyph`
+
+Insert `glyph`. Raises `Ufo::GlyphExistsError` if a glyph with the same name is already present.
+
+```ruby
+layer = Fontisan::Ufo::Layer.new
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+
+layer.add(Fontisan::Ufo::Glyph.new(name: "A"))
+# => raises Fontisan::Ufo::GlyphExistsError: a glyph named "A" already exists
+```
+
+The original glyph is preserved when the second `add` raises — the layer is never partially mutated.
+
+### `#put(glyph) -> Glyph`
+
+Insert `glyph`, replacing any existing glyph with the same name. Use this when the caller has positively decided the previous glyph (if any) should be discarded.
+
+```ruby
+layer.put(Fontisan::Ufo::Glyph.new(name: "A"))  # overwrites the prior "A"
+```
+
+### `#[](glyph_name) -> Glyph, nil`
+
+Look up a glyph by name.
+
+### `#each { |glyph| ... }`
+
+Iterate over glyphs (no ordering guarantee).
+
+### `#size -> Integer`
+
+Number of glyphs in the layer.
+
+## `Ufo::GlyphExistsError`
+
+Raised by `Layer#add` on a name conflict. Carries the colliding name so callers can branch programmatically:
+
+```ruby
+begin
+  layer.add(glyph)
+rescue Fontisan::Ufo::GlyphExistsError => e
+  puts "name #{e.name.inspect} already taken"
+  # Decide: layer.put(glyph) to overwrite, or
+  # unique = Fontisan::Stitcher::UniqueGlyphName.in(target, e.name)
+  # layer.add(glyph.dup_as(name: unique))
+end
+```
+
+The error class is a sibling of `Layer` (not nested inside it) so the namespace stays flat — both `Ufo::Layer` and `Ufo::GlyphExistsError` live directly under `Fontisan::Ufo`.
+
+## See also
+
+- `docs/STITCHER_GUIDE.adoc` — `UniqueGlyphName`, `GlyphCopier`, and `CbdtPropagator` all build on the Layer naming contract.
+- `docs/UFO_COMPILATION.adoc` — how layers feed the TTF/OTF/CFF2 compilers.

data/docs/cli/subset.md

@@ -18,8 +18,23 @@ fontisan subset <font> [options]
 |--------|-------------|
 | `--chars TEXT` | Characters to include |
 | `--file FILE` | File containing characters |
+| `--unicodes RANGE` | Unicode ranges (`"U+0000-007F"`) |
+| `--glyphs LIST` | Glyph names/IDs |
 | `--output FILE` | Output file path |
-| `--format FORMAT` | Output format |
+| `--format FORMAT` | Output format (`ttf`, `woff`, `woff2`, …) |
+| `--profile PROFILE` | Subsetting profile (default: `pdf`) |
+| `--retain-gids` | Preserve original glyph IDs |
+
+## Profiles
+
+| Profile | Tables included | Use case |
+|---------|-----------------|----------|
+| `pdf` | core + glyf/loca | PDF embedding (smallest) |
+| `web` | core + glyf/loca + GSUB/GPOS + **CBDT/CBLC** | Web fonts that retain color-emoji bitmaps |
+| `minimal` | core only | Smallest valid font |
+| `full` | every standard table | Lossless re-export |
+
+The `web` profile is the one to reach for when the subset must still render color emoji in a browser: it preserves the CBDT (bitmap data) and CBLC (bitmap location) tables, and the paired subsetter rewrites them to keep only the bitmaps for the retained glyphs.
 
 ## Examples
 
@@ -27,13 +42,17 @@ fontisan subset <font> [options]
 # Subset to specific characters
 fontisan subset font.ttf --chars "ABCDEF" --output subset.ttf
 
-# Subset from file
-fontisan subset font.ttf --file chars.txt --output subset.ttf
+# Web subset that retains color-emoji bitmaps
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁😂🤣😊" \
+  --profile web \
+  --format woff2 \
+  --output emoji.woff2
 
-# Subset and convert format
-fontisan subset font.ttf --chars "Hello" --format woff2
+# PDF embedding profile (drops CBDT/CBLC, smaller output)
+fontisan subset font.ttf --chars "ABC" --profile pdf --output pdf-subset.ttf
 ```
 
 ## Detailed Documentation
 
-For comprehensive documentation including unicode ranges and advanced subsetting, see the [subset command guide](/guide/cli/subset).
+For comprehensive documentation including unicode ranges, profile selection, and CBDT/CBLC behavior, see the [subset command guide](/guide/cli/subset).

data/docs/guide/cli/subset.md

@@ -28,6 +28,7 @@ fontisan subset FONT [options]
 | `--glyphs LIST` | Glyph names/IDs |
 | `--output PATH` | Output file |
 | `--output-format FORMAT` | Output format |
+| `--profile PROFILE` | Subsetting profile (`pdf`, `web`, `minimal`, `full`; default `pdf`) |
 | `--retain-gids` | Retain glyph IDs |
 
 ## Examples
@@ -86,6 +87,36 @@ fontisan subset font.ttf --chars "ABC" --output-format woff2 --output subset.wof
 
 ## Subsetting Strategies
 
+### Profile selection
+
+The `--profile` option controls which font tables the subset retains. The right choice depends on what the subset is for:
+
+| Profile | When to use | Notable tables dropped |
+|---------|-------------|------------------------|
+| `pdf` (default) | PDF embedding, smallest valid output | GSUB, GPOS, CBDT, CBLC |
+| `web` | Browser/web font, **retains color-emoji bitmaps** | nothing that browsers need |
+| `minimal` | Absolute smallest core that still renders | glyf/loca, CBDT/CBLC, GSUB/GPOS |
+| `full` | Lossless re-export | (none) |
+
+```bash
+# Web subset that keeps color-emoji bitmaps so 😀 renders in color
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁😂🤣😊" \
+  --profile web \
+  --output-format woff2 \
+  --output emoji.woff2
+
+# PDF embedding — drops color bitmaps for size
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀" \
+  --profile pdf \
+  --output emoji-pdf.ttf
+```
+
+#### Web profile and CBDT/CBLC
+
+The `web` profile is the only built-in profile that retains CBDT (Color Bitmap Data) and CBLC (Color Bitmap Location) tables. The subsetter walks CBLC to find each retained glyph's bitmap block, rewrites CBDT to keep only those blocks, and rebuilds CBLC's IndexSubTableArray to point at the new offsets. Glyph IDs are remapped through the subset's `GlyphMapping`, so the output CBLC references subset GIDs, not source GIDs.
+
 ### Web Font Optimization
 
 ```bash

data/docs/guide/color-fonts/bitmaps.md

@@ -144,6 +144,23 @@ fontisan convert bitmap-font.ttf --to ttf --output bitmap-font.ttf
 fontisan convert bitmap-font.ttf --to ttf --no-bitmaps --output outline-only.ttf
 ```
 
+### Subsetting color-emoji fonts
+
+The `web` subsetting profile retains CBDT and CBLC tables and rewrites them to keep only the bitmaps for retained glyphs. Use it when subsetting a color-emoji source for browser delivery:
+
+```bash
+# Keep only 😀 + 😁 bitmaps; output WOFF2 for web
+fontisan subset NotoColorEmoji.ttf \
+  --chars "😀😁" \
+  --profile web \
+  --output-format woff2 \
+  --output emoji-subset.woff2
+```
+
+Other profiles (`pdf`, `minimal`, `full`) drop CBDT/CBLC — pick them when the subset doesn't need color-emoji rendering (e.g. PDF embedding where the subsetter is just selecting glyphs for outlines).
+
+See the [subset CLI docs](/cli/subset) and `docs/STITCHER_GUIDE.adoc` (CBDT/CBLC passthrough section) for the full story, including the GID-stability caveat when CBDT and outline donors cover overlapping codepoint ranges in stitch mode.
+
 ## Comparison
 
 | Feature | sbix | CBDT/CBLC |

data/lib/fontisan/cli.rb

@@ -360,7 +360,8 @@ module Fontisan
 
       # Handle --show-options
       if options[:show_options]
-        show_recommended_options(source_format, options[:to].is_a?(Array) ? options[:to].first : options[:to])
+        show_recommended_options(source_format,
+                                 options[:to].is_a?(Array) ? options[:to].first : options[:to])
         return
       end
 

data/lib/fontisan/collection/writer.rb

@@ -95,7 +95,8 @@ module Fontisan
       #
       # @return [String] TTC header binary
       def write_ttc_header
-        [TTC_TAG, VERSION_1_0_MAJOR, VERSION_1_0_MINOR, @fonts.size].pack("a4nnN")
+        [TTC_TAG, VERSION_1_0_MAJOR, VERSION_1_0_MINOR,
+         @fonts.size].pack("a4nnN")
       end
 
       # Write offset table

data/lib/fontisan/commands/validate_collection_command.rb

@@ -81,7 +81,13 @@ module Fontisan
         Check.new(
           name: :glyph_cap,
           passed: over.empty?,
-          message: over.empty? ? nil : "faces over cap: #{over.map { |s| "##{s.index}=#{s.glyph_count}" }.join(', ')}",
+          message: if over.empty?
+                     nil
+                   else
+                     "faces over cap: #{over.map do |s|
+                       "##{s.index}=#{s.glyph_count}"
+                     end.join(', ')}"
+                   end,
         )
       end
 

data/lib/fontisan/commands.rb

@@ -21,7 +21,8 @@ module Fontisan
     autoload :TablesCommand, "fontisan/commands/tables_command"
     autoload :UnicodeCommand, "fontisan/commands/unicode_command"
     autoload :UnpackCommand, "fontisan/commands/unpack_command"
-    autoload :ValidateCollectionCommand, "fontisan/commands/validate_collection_command"
+    autoload :ValidateCollectionCommand,
+             "fontisan/commands/validate_collection_command"
     autoload :ValidateCommand, "fontisan/commands/validate_command"
     autoload :VariableCommand, "fontisan/commands/variable_command"
   end

data/lib/fontisan/converters/collection_converter.rb

@@ -173,7 +173,12 @@ module Fontisan
             io.read(8) # signature + flavor
             io.rewind
             flavor = File.binread(path, 4, 4)&.unpack1("N")
-            flavor == Woff2::CollectionDecoder::TTC_FLAVOR ? :woff2_collection : (raise Error, "Not a WOFF2 collection: #{path}")
+            if flavor == Woff2::CollectionDecoder::TTC_FLAVOR
+              :woff2_collection
+            else
+              (raise Error,
+                     "Not a WOFF2 collection: #{path}")
+            end
           elsif Parsers::DfontParser.dfont?(io)
             :dfont
           else

data/lib/fontisan/converters/svg_generator.rb

@@ -192,7 +192,9 @@ palette_index: 0)
       def build_glyph_to_codepoints(cmap)
         return {} unless cmap
 
-        cmap.unicode_mappings.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, gid), h|
+        cmap.unicode_mappings.each_with_object(Hash.new do |h, k|
+          h[k] = []
+        end) do |(cp, gid), h|
           h[gid] << cp
         end
       rescue StandardError => e

data/lib/fontisan/stitcher/collection_result.rb

@@ -9,7 +9,8 @@ module Fontisan
 
     # Return value of {Stitcher#write_collection}. Carries the output path,
     # total bytes, and one {SubfontStats} per declared subfont.
-    CollectionResult = Struct.new(:path, :bytes, :subfonts, keyword_init: true) do
+    CollectionResult = Struct.new(:path, :bytes, :subfonts,
+                                  keyword_init: true) do
       def face_count
         subfonts.size
       end

data/lib/fontisan/stitcher/glyph_copier.rb

@@ -89,7 +89,8 @@ module Fontisan
         bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
       end
 
-      def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
+      def copy_glyph_into(target_font, name:, source:, donor_gid:,
+codepoint: nil)
         original = source.glyph_for_gid(donor_gid)
         return unless original
 

data/lib/fontisan/stitcher/partition_strategy/by_block.rb

@@ -403,7 +403,9 @@ module Fontisan
         private
 
         def group_by_block(cp_map)
-          cp_map.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, label), h|
+          cp_map.each_with_object(Hash.new do |h, k|
+            h[k] = []
+          end) do |(cp, label), h|
             block_label = find_block_label(cp) || :other
             h[block_label] << [cp, label]
           end