fontisan 0.4.11 → 0.4.12

data/docs/TTX.adoc

@@ -0,0 +1,176 @@
+= TTX (FontTools XML) Support
+
+fontisan can read and write the TTX format — the human-readable
+XML representation of OpenType fonts defined by Adobe/FontTools'.
+`ttx` tool. TTX is the standard interchange format for OpenType
+table data: every binary table has a corresponding XML element,
+and round-tripping TTX ↔ binary preserves the table contents.
+
+== Why TTX
+
+* **Diff-friendly**: TTX is text, so changes to a font's tables can
+  be reviewed in version control.
+* **Edit-friendly**: you can hand-edit table values without writing
+  binary parsers.
+* **Tool interchange**: any tool that understands TTX (fontTools,
+  AFDKO's `ttx`, several IDE plugins) can read fontisan's output
+  and vice versa.
+
+== What fontisan supports
+
+[cols="1,3", options="header"]
+|===
+| Capability | Notes
+
+| Read `.ttx` (parse XML → typed tables)
+| Every standard table that fontisan parses as binary also has a
+  TTX parser entry. Unknown tables fall through to a binary-blob
+  representation.
+
+| Write `.ttx` (typed tables → XML)
+| Same coverage as the read path. Each table knows how to render
+  itself as TTX.
+
+| CLI `fontisan export FONT --format ttx`
+| Dumps every table or a subset via `--tables`.
+
+| CLI `fontisan info FONT` (auto-detect)
+| Auto-detects `.ttx` files alongside binary formats. No
+  `--format` flag needed.
+
+| Per-table type mapping (lib/fontisan/models/ttx/tables/*.rb)
+| `head`, `hhea`, `maxp`, `name`, `OS/2`, `post` have typed
+  representations; everything else is `BinaryTable` (raw bytes).
+|===
+
+== CLI usage
+
+[source,bash]
+----
+# Dump the entire font as TTX
+fontisan export MyFont.ttf --format ttx --output MyFont.ttx
+
+# Dump just the head + name tables
+fontisan export MyFont.ttf --format ttx --tables head name --output subset.ttx
+
+# Read a TTX file (auto-detected)
+fontisan info MyFont.ttx
+fontisan validate MyFont.ttx
+----
+
+== Ruby API
+
+=== Generate TTX from a loaded font
+
+[source,ruby]
+----
+require "fontisan"
+
+font = Fontisan::FontLoader.load("MyFont.ttf")
+generator = Fontisan::Export::TtxGenerator.new(font, "MyFont.ttf")
+ttx_xml = generator.generate
+File.write("MyFont.ttx", ttx_xml)
+----
+
+=== Parse TTX into typed tables
+
+[source,ruby]
+----
+require "fontisan/export"
+
+ttx_xml = File.read("MyFont.ttx")
+parser = Fontisan::Export::TtxParser.new
+tt_font = parser.parse(ttx_xml)
+
+puts "sfnt version: #{tt_font.sfnt_version}"
+puts "tables: #{tt_font.tables.keys.join(', ')}"
+
+head = tt_font.tables["head"]
+puts "units per em: #{head.units_per_em}" if head
+----
+
+=== Round-trip
+
+Read TTX → modify → write TTX:
+
+[source,ruby]
+----
+parser = Fontisan::Export::TtxParser.new
+tt_font = parser.parse(File.read("MyFont.ttx"))
+
+# Bump units-per-em (caution: this rescales visually)
+tt_font.tables["head"].units_per_em = 2048
+
+# Re-emit as TTX
+generator = Fontisan::Export::TtxGenerator.from_tt_font(tt_font)
+File.write("MyFont-edited.ttx", generator.generate)
+----
+
+== Typed table coverage
+
+fontisan's TTX layer is a parallel hierarchy to the binary
+`Tables::*` classes. Each TTX table class lives under
+`Fontisan::Models::Ttx::Tables`:
+
+[cols="1,1", options="header"]
+|===
+| Binary table | TTX class
+
+| `head`
+| `Models::Ttx::Tables::HeadTable`
+
+| `hhea`
+| `Models::Ttx::Tables::HheaTable`
+
+| `maxp`
+| `Models::Ttx::Tables::MaxpTable`
+
+| `name`
+| `Models::Ttx::Tables::NameTable`
+
+| `OS/2`
+| `Models::Ttx::Tables::Os2Table`
+
+| `post`
+| `Models::Ttx::Tables::PostTable`
+
+| (any other)
+| `Models::Ttx::Tables::BinaryTable` — raw bytes, no typed
+  interpretation
+|===
+
+Adding a new typed TTX representation = one file under
+`models/ttx/tables/` + one entry in the parser dispatch table.
+
+== Compatibility with fontTools `ttx`
+
+fontisan's TTX output is byte-compatible with fontTools `ttx`
+output for the typed tables. The XML element names, attribute
+names, and value formats match the fontTools schema.
+
+The `BinaryTable` representation differs slightly: fontTools
+emits a hex-dumped `<hexdata>` block for tables it doesn't
+understand; fontisan emits the same format.
+
+== Related formats
+
+fontisan also exports YAML and JSON via the same `fontisan export`
+command — useful for scripting and AI/automation pipelines where
+XML's verbosity is a drawback:
+
+[source,bash]
+----
+fontisan export MyFont.ttf --format yaml --output MyFont.yaml
+fontisan export MyFont.ttf --format json --output MyFont.json
+----
+
+== See also
+
+* link:UFO_COMPILATION.adoc[UFO Compilation Guide] — UFO is a
+  richer source format than TTX (full glyph outlines + naming +
+  features); use TTX for binary-table inspection, UFO for source
+  editing.
+* link:AFDKO_MIGRATION.adoc[AFDKO Migration Guide] — fontisan
+  replaces AFDKO's `ttx` command.
+* link:FEATURE_PARITY.adoc[Feature Parity] — every external tool
+  fontisan replaces.

data/docs/UFO_COMPILATION.adoc

@@ -110,10 +110,288 @@ ufo = Fontisan::Ufo::Convert::FromBinData.convert(ttf)
 Fontisan::Ufo::Writer.new(ufo).write("MyFont.ufo")
 ----
 
+== Conversion wrappers (Phase 3)
+
+For every binary format fontisan can write, there's a UFO → that
+format wrapper under `Ufo::Convert`. They split into two flavors:
+
+1-step wrappers (compile + write directly): `ToTtf`, `ToOtf`,
+`ToOtf2`.
+
+2-step wrappers (compile to TTF/OTF in a tmpfile, then encode):
+`ToWoff`, `ToWoff2`, `ToDfont`, `ToTtc`, `ToOtc`, `ToPfb`,
+`ToPfa`.
+
+The 2-step chain looks like:
+
+....
+UFO → Compile::*Compiler → tmpfile → FontLoader.load →
+       WoffWriter / Woff2Encoder / DfontBuilder /
+       Collection::Builder / Type1::PFB/PFAGenerator → output
+....
+
+The tmpfile is auto-cleaned (`Dir.mktmpdir`); the original UFO is
+never mutated.
+
+Use the unified dispatcher to pick a format by symbol:
+
+[source,ruby]
+----
+require "fontisan"
+
+ufo = Fontisan::Ufo::Font.open("MyFont.ufo")
+
+# 1-step
+Fontisan::Ufo::Convert.convert(ufo, to: :ttf, output_path: "MyFont.ttf")
+Fontisan::Ufo::Convert.convert(ufo, to: :otf, output_path: "MyFont.otf")
+
+# 2-step
+Fontisan::Ufo::Convert.convert(ufo, to: :woff2, output_path: "MyFont.woff2")
+Fontisan::Ufo::Convert.convert(ufo, to: :pfb,    output_path: "MyFont.pfb")
+----
+
+Format keys: `:ttf`, `:otf`, `:otf2`, `:woff`, `:woff2`, `:dfont`,
+`:ttc`, `:otc`, `:pfb`, `:pfa`. Unknown keys raise `ArgumentError`.
+
+For per-format options (zlib level, brotli quality, etc.) call the
+wrapper module directly — options forward through:
+
+[source,ruby]
+----
+Fontisan::Ufo::Convert::ToWoff2.convert(ufo,
+  output_path: "MyFont.woff2",
+  compiler: :otf,             # intermediate format
+  brotli_quality: 11,         # passed to Woff2Encoder
+  transform_tables: true)
+----
+
+== Glyph-processing filters (Phase 2)
+
+Filters sit between the UFO model and the binary compilers. Each is
+a stateless module under `Ufo::Compile::Filters` with a `.run(glyphs,
+**opts)` entry that mutates the glyph list in place. They're
+registered in `Filters::REGISTRY` so the compiler (or any caller)
+can apply them by symbol:
+
+[source,ruby]
+----
+glyphs = ufo.layers.default_layer.glyphs.values
+Fontisan::Ufo::Compile::Filters.apply(
+  %i[cubic_to_quadratic reverse_contour_direction sort_contours],
+  glyphs
+)
+----
+
+Available filters:
+
+[cols="1,3", options="header"]
+|===
+| Filter | What it does
+
+| `cubic_to_quadratic`
+| Convert cubic Bezier curves to quadratic (TrueType only supports
+  quadratic; UFO sources typically use cubic).
+
+| `reverse_contour_direction`
+| Reverse point order in every contour (TrueType wants clockwise
+  outer winding; UFO is PostScript counter-clockwise).
+
+| `decompose_components`
+| Replace composite-glyph components with their base glyph's
+  contours.
+
+| `flatten_components`
+| Collapse nested component chains (A→B→C becomes A→C).
+
+| `transformations`
+| Apply a 2×3 affine matrix to every glyph's contours + components
+  (mirroring, slant, scaling, custom offsets).
+
+| `sort_contours`
+| Rotate each contour to start with an on-curve point and sort
+  contours within each glyph by Y (descending) for hinting
+  compatibility.
+
+| `propagate_anchors`
+| Copy anchors from base glyphs to composite glyphs (transformed by
+  the component matrix) so the GPOS mark feature writer can find
+  them on composites.
+|===
+
+Adding a new filter = one file under `compile/filters/` + one entry
+in `REGISTRY`. No edits to other filters required (OCP).
+
+== Feature writers (Phase 2)
+
+Feature writers extract GSUB/GPOS feature data from a UFO source
+into structured form for the table builders to encode. Each writer
+extends `FeatureWriters::Base` with a `#write` method that returns
+either a `FeatureOutput` value object or `nil` (when the UFO has
+no data for the feature).
+
+[source,ruby]
+----
+require "fontisan/ufo/compile/feature_writers"
+
+font = Fontisan::Ufo::Font.open("MyFont.ufo")
+Fontisan::Ufo::Compile::FeatureWriters::DEFAULT_WRITERS.each do |writer_cls|
+  output = writer_cls.new(font).write
+  next unless output
+
+  puts "#{output.table_tag} / #{output.feature_tag} (lookup #{output.lookup_type})"
+end
+----
+
+Available writers:
+
+[cols="1,1,3", options="header"]
+|===
+| Writer | GPOS / GSUB | What it emits
+
+| `FeatureWriters::Kern`
+| GPOS lookup 2 (`kern`)
+| PairPos kerning pairs from `font.kerning` (parsed from
+  `kerning.plist`).
+
+| `FeatureWriters::Kern2`
+| GPOS lookup 2 (`kern`, format 2)
+| Same pair data as Kern, tagged for the extended PairPos format
+  (device tables, cross-stream values). Use when you need
+  sub-pixel kerning.
+
+| `FeatureWriters::Gdef`
+| GDEF
+| GlyphClassDef — classifies every glyph as base/ligature/mark/
+  spacing. Prefers `public.openTypeCategory` lib entry; falls
+  back to heuristic (mark anchors, `.liga` suffix).
+
+| `FeatureWriters::Mark`
+| GPOS lookup 4 (`mark`)
+| MarkToBase attachment. Pairs every glyph with a `_<name>`
+  anchor (mark) against every glyph with the matching `<name>`
+  anchor (base).
+
+| `FeatureWriters::Mkmk`
+| GPOS lookup 6 (`mkmk`)
+| MarkToMark attachment. Same convention as Mark but pairs marks
+  with other marks. Anchors are `_<name>mkmk` (attach-from) ↔
+  `<name>mkmk` (attach-to).
+
+| `FeatureWriters::Curs`
+| GPOS lookup 3 (`curs`)
+| Cursive attachment. Emits entry/exit anchor positions for
+  joining-script glyphs.
+|===
+
+`FeatureWriters::DEFAULT_WRITERS = [Gdef, Kern, Mark, Mkmk, Curs]`.
+The compiler runs all by default; each returns `nil` when the UFO
+has no data for its feature, so it's safe to always run them all.
+
+Adding a new writer = one file under `compile/feature_writers/` +
+one entry in `DEFAULT_WRITERS`. No edits to other writers required
+(OCP).
+
+Prerequisite for Mark / Mkmk / Curs: run
+`Filters::PropagateAnchors` first so composite glyphs carry their
+inherited anchors.
+
+=== Usage examples
+
+==== Kern (pair kerning)
+
+Extract kerning pairs from a UFO's `kerning.plist`:
+
+[source,ruby]
+----
+font = Fontisan::Ufo::Font.open("MyFont.ufo")
+out = Fontisan::Ufo::Compile::FeatureWriters::Kern.new(font).write
+
+out.data[:pairs].each do |pair|
+  puts "#{pair[:left]} + #{pair[:right]} = #{pair[:value]}"
+end
+# A + V = -80.0
+# A + W = -60.0
+# ...
+----
+
+==== Gdef (glyph classification)
+
+Classify every glyph for GDEF:
+
+[source,ruby]
+----
+out = Fontisan::Ufo::Compile::FeatureWriters::Gdef.new(font).write
+out.data[:classes].each { |name, cls| puts "#{name}: #{cls}" }
+# A: 1 (base)
+# f_f_i.liga: 2 (ligature)
+# acutecomb: 3 (mark)
+# ...
+----
+
+==== Mark (mark-to-base attachment)
+
+Pair diacritical marks with base glyphs:
+
+[source,ruby]
+----
+out = Fontisan::Ufo::Compile::FeatureWriters::Mark.new(font).write
+out.data[:attachments]["top"][:marks]   # => {"acutecomb" => [100, 600], ...}
+out.data[:attachments]["top"][:bases]   # => {"A" => [100, 700], "B" => [90, 700], ...}
+----
+
+==== Mkmk (mark-to-mark attachment)
+
+Stack marks above each other:
+
+[source,ruby]
+----
+out = Fontisan::Ufo::Compile::FeatureWriters::Mkmk.new(font).write
+out.data[:attachments]["top"][:marks]       # => {"acutecomb" => [100, 650]}
+out.data[:attachments]["top"][:base_marks]  # => {"dieresiscomb" => [100, 700]}
+----
+
+==== Curs (cursive joining)
+
+Emit entry/exit anchors for Arabic-script glyphs:
+
+[source,ruby]
+----
+out = Fontisan::Ufo::Compile::FeatureWriters::Curs.new(font).write
+out.data[:attachments]["alef"]  # => {entry: [0, 100], exit: [100, 100]}
+out.data[:attachments"]["beh"]  # => {entry: [50, 50], exit: nil}
+----
+
+== CLI
+
+`fontisan ufo` exposes the four common operations:
+
+[source,bash]
+----
+# Compile a UFO to a binary font
+fontisan ufo build MyFont.ufo --output MyFont.ttf [--to otf|otf2]
+
+# Convert in either direction (UFO ↔ binary)
+fontisan ufo convert MyFont.ufo MyFont.woff2
+fontisan ufo convert MyFont.ttf  MyFont.ufo
+
+# Structural checks (no .notdef, no family name, etc.)
+fontisan ufo validate MyFont.ufo
+
+# Render one glyph as a standalone SVG
+fontisan ufo extract MyFont.ufo A A.svg
+----
+
+The `build` and `convert` commands route through the
+`Ufo::Convert.convert` dispatcher, so adding a new format = one
+registry entry — no CLI edits.
+
 == See also
 
+* link:AFDKO_MIGRATION.adoc[AFDKO Migration Guide] — switching from
+  `makeotf` / `otf2ttf` / `ttx` to fontisan's UFO pipeline.
 * link:CFF2_SUPPORT.adoc[CFF2 Support Guide] — variable-font blend
-  operators, FDSelect, subroutines, VariationStore
+  operators, FDSelect, subroutines, VariationStore.
 * link:VARIABLE_FONT_OPERATIONS.adoc[Variable Font Operations] —
-  reading and modifying existing variable fonts
-- link:STITCHER_GUIDE.adoc[Stitcher Guide] — multi-source assembly
+  reading and modifying existing variable fonts.
+* link:STITCHER_GUIDE.adoc[Stitcher Guide] — multi-source assembly.
+

data/lib/fontisan/stitcher/source.rb

@@ -336,10 +336,15 @@ module Fontisan
 
       # Apply a 2×3 affine matrix [a, b, c, d, e, f] to each point of
       # a simple component, appending the transformed contours.
-      #   x' = a*x + c*y + e
-      #   y' = b*x + d*y + f
+      # The math is delegated to +Transformation#apply+ so the
+      # affine-matrix logic lives in one place (DRY) — same code path
+      # the UFO Transformations filter uses.
       def flatten_simple_component(simple, ufo_glyph, matrix)
-        a, b, c, d, e, f = matrix
+        transform = Ufo::Transformation.new(
+          a: matrix[0], b: matrix[1],
+          c: matrix[2], d: matrix[3],
+          e: matrix[4], f: matrix[5]
+        )
         num_contours = simple.end_pts_of_contours&.size || 0
         return if num_contours.zero?
 
@@ -350,13 +355,12 @@ module Fontisan
           ufo_points = points.map do |pt|
             x = (pt[:x] || pt["x"]).to_f
             y = (pt[:y] || pt["y"]).to_f
-            tx = a * x + c * y + e
-            ty = b * x + d * y + f
+            tx, ty = transform.apply(x, y)
             on_curve = pt[:on_curve].nil? || pt[:on_curve]
             type = on_curve ? "line" : "offcurve"
-            Fontisan::Ufo::Point.new(x: tx, y: ty, type: type)
+            Ufo::Point.new(x: tx, y: ty, type: type)
           end
-          ufo_glyph.add_contour(Fontisan::Ufo::Contour.new(ufo_points))
+          ufo_glyph.add_contour(Ufo::Contour.new(ufo_points))
         end
       end
 

data/lib/fontisan/subset/table_subsetter.rb

@@ -56,6 +56,8 @@ module Fontisan
         @options = options
         @glyf_data = nil
         @loca_offsets = nil
+        @subset_bbox = nil      # [xMin, yMin, xMax, yMax] over actual subset glyphs
+        @subset_max_advance = 0 # largest advanceWidth in subset hmtx
       end
 
       # Subset a table by tag
@@ -110,10 +112,12 @@ module Fontisan
         data
       end
 
-      # Subset hhea table (update numberOfHMetrics)
+      # Subset hhea table (update numberOfHMetrics + advanceWidthMax)
       #
-      # Updates the numberOfHMetrics field to reflect the number of
-      # horizontal metrics in the subset font.
+      # Updates numberOfHMetrics to reflect the subset's glyph count and
+      # recomputes advanceWidthMax from the subset's actual hmtx. The
+      # source TTC's advanceWidthMax covers every donor font and is far
+      # larger than any per-block subset needs.
       #
       # @param table [Hhea] Parsed hhea table
       # @param hmtx [Hmtx, nil] Optional parsed hmtx table (for calculating metrics)
@@ -128,9 +132,18 @@ module Fontisan
                               calculate_number_of_h_metrics
                             end
 
-        # Update numberOfHMetrics field (at offset 34, uint16)
+        # numberOfHMetrics at offset 34 (uint16)
         data[34, 2] = [new_num_h_metrics].pack("n")
 
+        # advanceWidthMax at offset 10 (uint16). Recompute from subset
+        # hmtx so a per-block subset doesn't keep the source TTC's
+        # max (which can be 4x larger than any glyph in the subset).
+        # Tables are processed alphabetically (hhea before hmtx), so
+        # we read hmtx directly here rather than relying on a cached
+        # value from subset_hmtx.
+        new_max = compute_subset_max_advance
+        data[10, 2] = [new_max].pack("n") if new_max.positive?
+
         data
       end
 
@@ -152,14 +165,18 @@ module Fontisan
         # Build new hmtx data
         data = String.new(encoding: Encoding::BINARY)
 
+        max_advance = 0
         mapping.old_ids.each do |old_id|
           metric = table.metric_for(old_id)
           next unless metric
 
-          data << [metric[:advance_width]].pack("n")
+          advance = metric[:advance_width]
+          max_advance = advance if advance && advance > max_advance
+          data << [advance].pack("n")
           data << [metric[:lsb]].pack("n")
         end
 
+        @subset_max_advance = max_advance
         data
       end
 
@@ -264,8 +281,32 @@ module Fontisan
       #
       # @param table [Head] Parsed head table
       # @return [String] Binary data of subset head table
+      # Subset head table (recompute bbox from actual subset glyphs)
+      #
+      # The source TTC's head.xMin/yMin/xMax/yMax covers every donor
+      # font in the collection — far larger than any per-block subset.
+      # Browsers and layout engines use head bbox (plus hhea + OS/2)
+      # to compute line height and clip text; a too-large bbox makes
+      # glyphs render at the wrong visual size.
+      #
+      # @param _table [Head] Parsed head table (unused; we re-serialize
+      #   directly from font.table_data so we don't lose other fields)
+      # @return [String] Binary data of subset head table
       def subset_head(_table)
-        font.table_data["head"]
+        # Trigger glyf build (which populates @subset_bbox) if not done.
+        glyf = font.table("glyf")
+        build_glyf_and_loca(glyf) unless @glyf_data
+
+        data = font.table_data["head"].dup
+
+        if @subset_bbox
+          x_min, y_min, x_max, y_max = @subset_bbox
+          # head layout: xMin at offset 36, yMin 38, xMax 40, yMax 42
+          # (each int16, big-endian, signed)
+          data[36, 8] = [x_min, y_min, x_max, y_max].pack("n4")
+        end
+
+        data
       end
 
       # Subset OS/2 table (optionally prune Unicode ranges)
@@ -295,6 +336,32 @@ module Fontisan
         mapping.size
       end
 
+      # Compute the largest advanceWidth across all subset glyphs by
+      # reading the source hmtx directly. Called from subset_hhea
+      # because hhea is processed before hmtx (alphabetical order).
+      #
+      # @return [Integer] max advanceWidth, or 0 if no metrics found
+      def compute_subset_max_advance
+        hmtx = font.table("hmtx")
+        return 0 unless hmtx
+
+        unless hmtx.parsed?
+          hhea = font.table("hhea")
+          maxp = font.table("maxp")
+          hmtx.parse_with_context(hhea.number_of_h_metrics, maxp.num_glyphs)
+        end
+
+        max_advance = 0
+        mapping.old_ids.each do |old_id|
+          metric = hmtx.metric_for(old_id)
+          next unless metric
+
+          advance = metric[:advance_width]
+          max_advance = advance if advance && advance > max_advance
+        end
+        max_advance
+      end
+
       # Build glyf and loca tables together
       #
       # This method extracts glyph data for all glyphs in the mapping,
@@ -318,6 +385,17 @@ module Fontisan
         @loca_offsets = []
         current_offset = 0
 
+        # Track union bbox across all subset glyphs. Glyph binary layout:
+        #   int16 numberOfContours (offset 0)
+        #   int16 xMin (offset 2)
+        #   int16 yMin (offset 4)
+        #   int16 xMax (offset 6)
+        #   int16 yMax (offset 8)
+        bbox_x_min = 1 << 30
+        bbox_y_min = 1 << 30
+        bbox_x_max = -(1 << 30)
+        bbox_y_max = -(1 << 30)
+
         # Process glyphs in mapping order
         mapping.old_ids.each do |old_id|
           @loca_offsets << current_offset
@@ -334,6 +412,21 @@ module Fontisan
           # Extract glyph data
           glyph_data = glyf_table.raw_data[offset, size]
 
+          # Update bbox union. Each glyph has at least 10 bytes of
+          # header (numberOfContours + 4 int16 bbox fields).
+          if glyph_data.bytesize >= 10
+            _n, gx_min, gy_min, gx_max, gy_max = glyph_data[0, 10].unpack("n5")
+            # Treat as signed int16
+            gx_min = (gx_min ^ 0x8000) - 0x8000
+            gy_min = (gy_min ^ 0x8000) - 0x8000
+            gx_max = (gx_max ^ 0x8000) - 0x8000
+            gy_max = (gy_max ^ 0x8000) - 0x8000
+            bbox_x_min = gx_min if gx_min < bbox_x_min
+            bbox_y_min = gy_min if gy_min < bbox_y_min
+            bbox_x_max = gx_max if gx_max > bbox_x_max
+            bbox_y_max = gy_max if gy_max > bbox_y_max
+          end
+
           # Check if compound glyph and remap components
           if compound_glyph?(glyph_data)
             glyph_data = remap_compound_glyph(glyph_data)
@@ -346,6 +439,11 @@ module Fontisan
 
         # Add final offset
         @loca_offsets << current_offset
+
+        # Stash union bbox if we saw at least one non-empty glyph.
+        return if bbox_x_min > bbox_x_max
+
+        @subset_bbox = [bbox_x_min, bbox_y_min, bbox_x_max, bbox_y_max]
       end
 
       # Check if glyph data represents a compound glyph