fontisan 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 999173c7fe3caa0568c7bc29b87184b1f167c5885b5e66c9c7c7f0f884d2523e
-  data.tar.gz: a9bf5e401b1b08672ced56f71b7ff5d6ab6b60e83b4ba1932ef43582c5d3a528
+  metadata.gz: 519952f147a10de9f78f3e30eb4456a077f35cb24099bb65781e7b1c2c4e59a3
+  data.tar.gz: c37e0f9d37bf0512cd7c0ed9be19e0eac5a9c74eb057c951d1a2dba4237c5f11
 SHA512:
-  metadata.gz: 9b770784dbac538d4d3998b1e908eedd5cb010f72897a0dc94b28e32f1150c6fdb99d384703760360dd1b01855de725ef786c34b173854ca8fd869b23ad6a8d6
-  data.tar.gz: 5b64092d77f6c19fc2e40fe40114722652000c49a36b22ae0dacccb86236d5529fe7d9c183bc4bd3141998d44a59b44ae2d5954bf675bb86fb489ff380a7b490
+  metadata.gz: c5702491e2326da5f357b5c89904896763c0f57dc807022b11b1d203ab1b4158372595c5059f0fff3143631323048a543e9b2f3046ded97e868d5cf105e518cc
+  data.tar.gz: 2f9f010ab0079fedfec7932313231bf7d002b2fed7af6476c459918e92e6d9c01300dac46594b64d16874b95924026bcd1a9779fe53ae1d2ea65240464256616

data/CHANGELOG.md

@@ -7,6 +7,42 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- `Fontisan::Ufo::Compile::Avar` — builds the OpenType `avar` (Axis
+  Variation) table with per-axis non-linear maps (defaults to identity
+  -1/0/1 mapping).
+- `Fontisan::Ufo::Compile::Hvar` — builds the OpenType `HVAR`
+  (Horizontal Metrics Variation) table with advance-width deltas per
+  glyph.
+- `Fontisan::Ufo::Compile::Mvar` — builds the OpenType `MVAR`
+  (Metrics Variation) table for font-wide metric deltas (ascender,
+  descender, etc.).
+- `Fontisan::Ufo::Compile::Stat` — builds the OpenType `STAT` (Style
+  Attributes) table with design axes, axis value tables, and elided
+  fallback name ID.
+- `Fontisan::Ufo::Compile::ItemVariationStore` — shared builder for
+  the ItemVariationStore structure used by HVAR and MVAR
+  (VariationRegionList + ItemVariationData with int8/int16 delta
+  packing).
+- `Fontisan::Ufo::Compile::VariableTtf` — orchestrator that compiles
+  a default UFO master plus variation masters into a single variable
+  TTF (emits fvar, gvar, HVAR, MVAR, avar, STAT alongside the standard
+  TTF tables).
+- `TtfCompiler#build_tables` — extracted public method returning the
+  TTF table hash without writing, so `VariableTtf` can reuse the
+  standard table pipeline.
+
+### Fixed
+
+- `Stitcher` silently dropped compound (composite) TrueType glyphs
+  from TTF donors. The O(1) extraction path only handled `simple?`
+  glyphs and returned `nil` for compounds. Compound glyphs are now
+  recursively flattened (with affine transforms applied) into simple
+  contours, making them self-contained. Affected donors include
+  NotoSansCuneiform (U+12399), NotoSansTaiTham (594 glyphs),
+  NotoSerifDivesAkuru (414), NotoSerifTaiYo (1007), and others.
+
 ### Removed
 
 - Audit subsystem (`Fontisan::Audit`, `Fontisan::Commands::Audit*`,

data/lib/fontisan/stitcher/source.rb

@@ -16,6 +16,8 @@ module Fontisan
     # the raw CBDT/CBLC tables into the output instead of extracting
     # outlines. The glyph data lives in the bitmap tables, not in glyf.
     class Source
+      MAX_COMPOUND_DEPTH = 32
+
       attr_reader :font
 
       def initialize(font)
@@ -219,14 +221,19 @@ module Fontisan
       end
 
       def extract_truetype_glyph(gid, cache)
-        simple = cache[:glyf].glyph_for(gid, cache[:loca], cache[:head])
-        return nil unless simple
-        return nil unless simple.respond_to?(:simple?) && simple.simple?
+        raw = cache[:glyf].glyph_for(gid, cache[:loca], cache[:head])
+        return nil unless raw
 
         name = gid.zero? ? ".notdef" : "gid#{gid}"
         glyph = Fontisan::Ufo::Glyph.new(name: name)
         glyph.width = glyph_width(gid)
-        copy_simple_contours(simple, glyph)
+
+        if raw.respond_to?(:simple?) && raw.simple?
+          copy_simple_contours(raw, glyph)
+        elsif raw.respond_to?(:compound?) && raw.compound?
+          flatten_compound_into(raw, glyph, cache, Set.new)
+        end
+
         add_cmap_unicodes(gid, glyph)
         glyph
       rescue StandardError
@@ -253,6 +260,62 @@ module Fontisan
         end
       end
 
+      # Recursively flatten a CompoundGlyph's components into the UFO
+      # glyph as contours (with transforms applied). This makes the
+      # extracted glyph self-contained — it doesn't depend on the
+      # component glyphs being present in the target font.
+      #
+      # Only components with ARGS_ARE_XY_VALUES are flattened by offset.
+      # Point-index alignment (rare) is skipped — those components
+      # contribute nothing, but the rest of the compound is preserved.
+      def flatten_compound_into(compound, ufo_glyph, cache, visited, depth = 0)
+        return if depth > MAX_COMPOUND_DEPTH
+        return if visited.include?(compound.glyph_id)
+
+        visited = visited.dup.add(compound.glyph_id)
+
+        compound.components.each do |component|
+          next unless component.args_are_xy?
+
+          raw = cache[:glyf].glyph_for(component.glyph_index, cache[:loca], cache[:head])
+          next unless raw
+
+          matrix = component.transformation_matrix
+
+          if raw.respond_to?(:simple?) && raw.simple?
+            flatten_simple_component(raw, ufo_glyph, matrix)
+          elsif raw.respond_to?(:compound?) && raw.compound?
+            flatten_compound_into(raw, ufo_glyph, cache, visited, depth + 1)
+          end
+        end
+      end
+
+      # 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
+      def flatten_simple_component(simple, ufo_glyph, matrix)
+        a, b, c, d, e, f = matrix
+        num_contours = simple.end_pts_of_contours&.size || 0
+        return if num_contours.zero?
+
+        num_contours.times do |ci|
+          points = simple.points_for_contour(ci)
+          next unless points && !points.empty?
+
+          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
+            on_curve = pt[:on_curve].nil? || pt[:on_curve]
+            type = on_curve ? "line" : "offcurve"
+            Fontisan::Ufo::Point.new(x: tx, y: ty, type: type)
+          end
+          ufo_glyph.add_contour(Fontisan::Ufo::Contour.new(ufo_points))
+        end
+      end
+
       # Add Unicode codepoints from the cmap that map to this gid.
       def add_cmap_unicodes(gid, glyph)
         cmap = @font.table("cmap")

data/lib/fontisan/ufo/compile/avar.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `avar` (Axis Variation) table.
+      #
+      # avar defines non-linear interpolation curves for each axis.
+      # For axes with linear interpolation (the common case), each
+      # axis gets 3 default maps: (-1→-1, 0→0, 1→1).
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/avar
+      module Avar
+        # @param axes [Array<Hash>] axis definitions (tag + optional maps)
+        # @return [String] avar table bytes
+        def self.build(axes:)
+          return nil if axes.nil? || axes.empty?
+
+          io = +""
+          io << [0x00010000].pack("N") # version 1.0
+          io << [0].pack("n")          # reserved
+          io << [axes.size].pack("n")  # axisCount
+
+          axes.each do |axis|
+            maps = axis[:maps] || default_maps
+            io << [maps.size].pack("n")
+            maps.each do |from, to|
+              io << [f2dot14(from), f2dot14(to)].pack("nn")
+            end
+          end
+
+          io
+        end
+
+        def self.default_maps
+          [[-1.0, -1.0], [0.0, 0.0], [1.0, 1.0]].freeze
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+        private_class_method :default_maps, :f2dot14
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/hvar.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `HVAR` (Horizontal Metrics Variation) table.
+      #
+      # Stores advance-width variation deltas per glyph, enabling
+      # variable-font renderers to adjust spacing without loading gvar.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/HVAR
+      module Hvar
+        # @param default_widths [Array<Integer>] advance widths for default master
+        # @param master_widths [Array<Array<Integer>>] advance widths per master
+        # @param axis_count [Integer]
+        # @return [String] HVAR table bytes
+        def self.build(default_widths:, master_widths:, axis_count:)
+          glyph_count = default_widths.size
+          master_count = master_widths.size
+
+          # Compute deltas: deltas[glyph][master] = master_width - default_width
+          deltas = Array.new(glyph_count) do |gid|
+            Array.new(master_count) do |mid|
+              master_widths.dig(mid, gid).to_i - default_widths[gid].to_i
+            end
+          end
+
+          store = ItemVariationStore.build(
+            axis_count: axis_count,
+            master_count: master_count,
+            item_count: glyph_count,
+            deltas: deltas,
+          )
+
+          # HVAR header: version(4) + itemVariationStoreOffset(4) +
+          # advanceWidthMappingOffset(4) + lsbMappingOffset(4) + rsbMappingOffset(4)
+          [0x00010000, 20].pack("NN") + [0, 0, 0].pack("NNN") + store
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/item_variation_store.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Shared builder for the ItemVariationStore structure used by
+      # HVAR, MVAR, and other variation tables.
+      #
+      # The ItemVariationStore consists of:
+      #   1. A VariationRegionList (defines axis regions)
+      #   2. One or more ItemVariationData (delta sets per item)
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/otvarcommonformats
+      module ItemVariationStore
+        # @param axis_count [Integer]
+        # @param master_count [Integer] number of masters (one region per master)
+        # @param item_count [Integer] number of items (glyphs for HVAR, metrics for MVAR)
+        # @param deltas [Array<Array<Integer>>] deltas[item][master] = delta value
+        # @return [String] ItemVariationStore bytes
+        def self.build(axis_count:, master_count:, item_count:, deltas:)
+          # Build regions: one per master, each with peak=1.0 on its axis
+          regions = build_regions(axis_count, master_count)
+          region_list = serialize_region_list(regions, axis_count)
+
+          # Build ItemVariationData: one data block covering all items
+          var_data = serialize_variation_data(item_count, master_count, deltas)
+
+          # Assemble the store
+          # Header layout: format(uint16) + variationRegionListOffset(uint32)
+          # + itemVariationDataCount(uint16) + itemVariationDataOffsets[1](uint32)
+          #             = 2 + 4 + 2 + 4 = 12 bytes total before region list
+          header_size = 8 # format(2) + regionListOffset(4) + itemVariationDataCount(2)
+          offsets_array_size = 4 # one data block → one offset
+          region_list_offset = header_size + offsets_array_size
+          var_data_offset = region_list_offset + region_list.bytesize
+
+          store = +""
+          store << [1].pack("n")                    # format = 1
+          store << [region_list_offset].pack("N")   # variationRegionListOffset
+          store << [1].pack("n")                    # itemVariationDataCount
+          store << [var_data_offset].pack("N")      # itemVariationDataOffsets[0]
+          store << region_list
+          store << var_data
+          store
+        end
+
+        def self.build_regions(axis_count, master_count)
+          Array.new(master_count) do |master_idx|
+            Array.new(axis_count) do |axis_idx|
+              if axis_idx == master_idx
+                { start: -1.0, peak: 1.0, end: 1.0 }
+              else
+                { start: -1.0, peak: 0.0, end: 1.0 }
+              end
+            end
+          end
+        end
+
+        def self.serialize_region_list(regions, axis_count)
+          io = +""
+          io << [axis_count].pack("n") # axisCount
+          io << [regions.size].pack("n") # regionCount
+          regions.each do |region|
+            region.each do |coords|
+              io << [f2dot14(coords[:start]), f2dot14(coords[:peak]), f2dot14(coords[:end])].pack("nnn")
+            end
+          end
+          io
+        end
+
+        def self.serialize_variation_data(item_count, region_count, deltas)
+          # Determine if all deltas fit in int8 (-128..127)
+          all_short = deltas.flatten.any? { |d| !d.between?(-127, 127) }
+          short_count = all_short ? region_count : 0
+
+          io = +""
+          io << [item_count].pack("n")     # itemCount
+          io << [short_count].pack("n")    # shortDeltaCount
+          io << [region_count].pack("n")   # regionIndexCount (all regions)
+          region_count.times { |i| io << [i].pack("n") } # regionIndices
+
+          deltas.each do |item_deltas|
+            item_deltas.each_with_index do |delta, i|
+              io << (i < short_count ? [delta].pack("s>") : [delta].pack("c"))
+            end
+          end
+
+          io
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+        private_class_method :build_regions, :serialize_region_list,
+                             :serialize_variation_data, :f2dot14
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/mvar.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `MVAR` (Metrics Variation) table.
+      #
+      # Stores deltas for font-wide metrics (ascender, descender, etc.)
+      # so they can vary across the design space.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/MVAR
+      module Mvar
+        HEADER_SIZE = 10 # majorVersion(2) + minorVersion(2) + valueRecordSize(2) +
+        #                valueRecordCount(2) + itemVariationStoreOffset(2)
+        VALUE_RECORD_SIZE = 8 # tag(4) + outerIndex(2) + innerIndex(2)
+
+        # @param default_metrics [Hash<Symbol, Integer>] e.g. { hasc: 800, hdsc: -200 }
+        # @param master_metrics [Array<Hash<Symbol, Integer>>] per master
+        # @param axis_count [Integer]
+        # @return [String] MVAR table bytes
+        def self.build(default_metrics:, master_metrics:, axis_count:)
+          tags = default_metrics.keys
+          return nil if tags.empty?
+
+          master_count = master_metrics.size
+
+          deltas = []
+          records = +""
+          tags.each_with_index do |tag, idx|
+            tag_bytes = tag.to_s.ljust(4, " ")[0, 4]
+            delta = master_metrics.dig(0, tag).to_i - default_metrics[tag].to_i
+            records << tag_bytes
+            records << [0, idx].pack("nn") # outerIndex=0, innerIndex=idx
+            deltas << [delta]
+          end
+
+          store = ItemVariationStore.build(
+            axis_count: axis_count,
+            master_count: master_count,
+            item_count: tags.size,
+            deltas: deltas,
+          )
+
+          store_offset = HEADER_SIZE + records.bytesize
+
+          io = +""
+          io << [1].pack("n")                # majorVersion
+          io << [0].pack("n")                # minorVersion
+          io << [VALUE_RECORD_SIZE].pack("n")
+          io << [tags.size].pack("n")        # valueRecordCount
+          io << [store_offset].pack("n")     # itemVariationStoreOffset (Offset16)
+          io << records
+          io << store
+          io
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/stat.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `STAT` (Style Attributes) table.
+      #
+      # Describes style attributes for each axis and named instances.
+      # Required for proper font matching in operating systems.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/STAT
+      module Stat
+        HEADER_SIZE = 20
+        DESIGN_AXIS_RECORD_SIZE = 8 # tag(4) + nameID(2) + ordering(2)
+        AXIS_VALUE_OFFSET_SIZE = 4  # uint32 per axis value
+
+        # @param axes [Array<Hash>] axis definitions with tag + name_id + ordering
+        # @param axis_values [Array<Hash>] value records per axis
+        # @param elided_name_id [Integer, nil] fallback name ID
+        # @return [String] STAT table bytes
+        def self.build(axes:, axis_values: nil, elided_name_id: nil)
+          return nil if axes.nil? || axes.empty?
+
+          design_axis_count = axes.size
+          axis_value_list = axis_values || []
+          axis_value_count = axis_value_list.size
+
+          design_axes = serialize_design_axes(axes)
+          value_tables, value_offsets = serialize_axis_values(axis_value_list, design_axes.bytesize)
+
+          header = serialize_header(
+            design_axis_count: design_axis_count,
+            design_axes_size: design_axes.bytesize,
+            axis_value_count: axis_value_count,
+            elided_name_id: elided_name_id,
+          )
+
+          io = +""
+          io << header
+          io << design_axes
+          axis_value_list.each_index do |i|
+            io << [value_offsets[i]].pack("N")
+          end
+          io << value_tables
+          io
+        end
+
+        def self.serialize_header(design_axis_count:, design_axes_size:, axis_value_count:, elided_name_id:)
+          design_axes_offset = HEADER_SIZE
+          offset_to_axis_value_offsets = design_axes_offset + design_axes_size
+
+          [
+            0x00010001, # version 1.1
+            DESIGN_AXIS_RECORD_SIZE,
+            design_axis_count,
+            design_axes_offset,
+            axis_value_count,
+            offset_to_axis_value_offsets,
+            elided_name_id || 0,
+          ].pack("NnnNnNn")
+        end
+
+        def self.serialize_design_axes(axes)
+          io = +""
+          axes.each_with_index do |axis, i|
+            tag = (axis[:tag] || axis["tag"] || "    ").to_s.ljust(4, " ")[0, 4]
+            name_id = axis[:name_id] || axis["name_id"] || 0
+            ordering = axis[:ordering] || axis["ordering"] || i
+            io << tag
+            io << [name_id, ordering].pack("nn")
+          end
+          io
+        end
+
+        # Each AxisValueTable is Format 1 (nominal): format(2) + axisIndex(2)
+        # + flags(2) + valueNameID(2) + value(F2DOT14) = 10 bytes.
+        def self.serialize_axis_values(axis_values, design_axes_size)
+          value_tables = +""
+          value_offsets = []
+          base = HEADER_SIZE + design_axes_size + (axis_values.size * AXIS_VALUE_OFFSET_SIZE)
+
+          axis_values.each do |av|
+            value_offsets << (base + value_tables.bytesize)
+            format = 1
+            axis_idx = av[:axis_index] || av["axis_index"] || 0
+            flags = av[:flags] || av["flags"] || 0
+            name_id = av[:name_id] || av["name_id"] || 0
+            value = f2dot14(av[:value] || av["value"] || 0)
+            value_tables << [format, axis_idx, flags, name_id, value].pack("nnnnn")
+          end
+
+          [value_tables, value_offsets]
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+        private_class_method :serialize_header, :serialize_design_axes,
+                             :serialize_axis_values, :f2dot14
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/ttf_compiler.rb

@@ -12,7 +12,8 @@ module Fontisan
       class TtfCompiler < BaseCompiler
         SFNT_VERSION = SFNT_VERSION_TRUE_TYPE
 
-        def compile(output_path:)
+        # @return [Hash<String, #to_binary_s>] all TTF tables, not yet written
+        def build_tables
           glyphs = font.glyphs.values
 
           # Deep-clone glyphs so filters don't mutate the source UFO.
@@ -22,7 +23,7 @@ module Fontisan
           glyf_loca = GlyfLoca.build(font, glyphs: filtered)
           loca_format = glyf_loca.delete(:loca_format)
 
-          tables = {
+          {
             "head" => Head.build(font, glyphs: filtered,
                                        loca_format: loca_format || Head::LOCA_FORMAT_LONG),
             "hhea" => Hhea.build(font, glyphs: filtered),
@@ -36,8 +37,10 @@ module Fontisan
             "glyf" => glyf_loca["glyf"],
             "loca" => glyf_loca["loca"],
           }
+        end
 
-          write(tables, output_path)
+        def compile(output_path:)
+          write(build_tables, output_path)
           output_path
         end
 

data/lib/fontisan/ufo/compile/variable_ttf.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Orchestrates compilation of a UFO source plus its variation
+      # masters into a single variable TrueType font.
+      #
+      # Pipeline:
+      #
+      #   default UFO font
+      #     │
+      #     ├─ TtfCompiler tables (head, hhea, maxp, OS/2, name,
+      #     │                     post, hmtx, cmap, glyf, loca)
+      #     │
+      #     ├─ fvar  (axes + named instances)
+      #     ├─ gvar  (per-glyph point deltas across masters)
+      #     ├─ HVAR  (advance-width deltas across masters)
+      #     ├─ MVAR  (font-wide metric deltas across masters)
+      #     ├─ avar  (per-axis non-linear maps; defaults to identity)
+      #     └─ STAT  (style attributes for OS matching)
+      #
+      # Masters are supplied as an Array of Hashes, each with:
+      #   - :font   — the master UFO::Font
+      #   - :axes   — Hash<String, Float> mapping axis tag → region peak
+      #
+      class VariableTtf
+        SFNT_VERSION = BaseCompiler::SFNT_VERSION_TRUE_TYPE
+
+        # @param font [Fontisan::Ufo::Font] default master
+        # @param axes [Array<Hash>] axis definitions (tag, min/default/max,
+        #   optional name_id, ordering, maps)
+        # @param masters [Array<Hash>] each master: { font:, axes: }
+        # @param instances [Array<Hash>] named instances for fvar
+        # @param stat_axis_values [Array<Hash>, nil] STAT axis value records
+        # @param stat_elided_name_id [Integer, nil] STAT elided fallback name
+        # @param default_metrics [Hash<Symbol, Integer>, nil] MVAR defaults
+        # @param master_metrics [Array<Hash<Symbol, Integer>>, nil] MVAR per-master
+        def initialize(font:, axes:, masters:, instances: nil,
+                       stat_axis_values: nil, stat_elided_name_id: nil,
+                       default_metrics: nil, master_metrics: nil)
+          @font = font
+          @axes = axes
+          @masters = masters
+          @instances = instances
+          @stat_axis_values = stat_axis_values
+          @stat_elided_name_id = stat_elided_name_id
+          @default_metrics = default_metrics
+          @master_metrics = master_metrics
+        end
+
+        # @param output_path [String]
+        # @return [String] the output path
+        def compile(output_path:)
+          tables = base_tables.merge(variation_tables)
+          write(tables, output_path)
+          output_path
+        end
+
+        private
+
+        def base_tables
+          @base_tables ||= TtfCompiler.new(@font).build_tables
+        end
+
+        def variation_tables
+          axis_count = @axes.size
+          tables = {}
+
+          fvar_bytes = Fvar.build(@font, axes: @axes, instances: @instances)
+          tables["fvar"] = fvar_bytes if fvar_bytes
+
+          avar_bytes = Avar.build(axes: @axes)
+          tables["avar"] = avar_bytes if avar_bytes
+
+          stat_bytes = Stat.build(
+            axes: stat_axes,
+            axis_values: @stat_axis_values,
+            elided_name_id: @stat_elided_name_id,
+          )
+          tables["STAT"] = stat_bytes if stat_bytes
+
+          default_glyphs = @font.glyphs.values
+          glyph_order = default_glyphs.map(&:name)
+
+          gvar_masters = @masters.map do |m|
+            {
+              axes: m[:axes],
+              glyphs: glyphs_for_master(m[:font], glyph_order),
+            }
+          end
+          tables["gvar"] = Gvar.build(
+            default_glyphs: default_glyphs,
+            masters: gvar_masters,
+            axis_count: axis_count,
+          )
+
+          default_widths = default_glyphs.map { |g| g.width.to_i }
+          master_widths = @masters.map do |m|
+            glyphs_for_master(m[:font], glyph_order).map { |g| g.width.to_i }
+          end
+          tables["HVAR"] = Hvar.build(
+            default_widths: default_widths,
+            master_widths: master_widths,
+            axis_count: axis_count,
+          )
+
+          if @default_metrics && @master_metrics
+            mvar = Mvar.build(
+              default_metrics: @default_metrics,
+              master_metrics: @master_metrics,
+              axis_count: axis_count,
+            )
+            tables["MVAR"] = mvar if mvar
+          end
+
+          tables
+        end
+
+        # Project a master's glyphs onto the default master's glyph order
+        # so deltas align by index. Missing glyphs default to the master's
+        # .notdef (index 0).
+        def glyphs_for_master(master_font, glyph_order)
+          by_name = master_font.glyphs
+          notdef = by_name.values.first
+          glyph_order.map { |name| by_name[name] || notdef }
+        end
+
+        # STAT design-axis records derived from @axes. Each axis may
+        # supply :name_id and :ordering; missing values default sensibly.
+        def stat_axes
+          @axes.each_with_index.map do |axis, i|
+            {
+              tag: axis[:tag] || axis["tag"],
+              name_id: axis[:name_id] || axis["name_id"] || 0,
+              ordering: axis[:ordering] || axis["ordering"] || i,
+            }
+          end
+        end
+
+        def write(tables_hash, output_path)
+          dir = File.dirname(output_path)
+          FileUtils.mkpath(dir) unless dir == "."
+          Fontisan::FontWriter.write_to_file(
+            tables_hash.transform_values { |t| serialize_table(t) },
+            output_path,
+            sfnt_version: SFNT_VERSION,
+          )
+        end
+
+        # BinData records respond to to_binary_s; raw String values pass through.
+        def serialize_table(table)
+          case table
+          when String then table
+          else table.to_binary_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile.rb

@@ -46,6 +46,13 @@ module Fontisan
       autoload :Cmap,         "fontisan/ufo/compile/cmap"
       autoload :GlyfLoca,     "fontisan/ufo/compile/glyf_loca"
       autoload :Cff,          "fontisan/ufo/compile/cff"
+      autoload :Avar,         "fontisan/ufo/compile/avar"
+      autoload :Hvar,         "fontisan/ufo/compile/hvar"
+      autoload :Mvar,         "fontisan/ufo/compile/mvar"
+      autoload :Stat,         "fontisan/ufo/compile/stat"
+      autoload :VariableTtf,  "fontisan/ufo/compile/variable_ttf"
+      autoload :ItemVariationStore,
+               "fontisan/ufo/compile/item_variation_store"
     end
   end
 end

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.5"
+  VERSION = "0.4.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -555,6 +555,7 @@ files:
 - lib/fontisan/ufo/anchor.rb
 - lib/fontisan/ufo/cli.rb
 - lib/fontisan/ufo/compile.rb
+- lib/fontisan/ufo/compile/avar.rb
 - lib/fontisan/ufo/compile/base_compiler.rb
 - lib/fontisan/ufo/compile/cff.rb
 - lib/fontisan/ufo/compile/cmap.rb
@@ -570,12 +571,17 @@ files:
 - lib/fontisan/ufo/compile/head.rb
 - lib/fontisan/ufo/compile/hhea.rb
 - lib/fontisan/ufo/compile/hmtx.rb
+- lib/fontisan/ufo/compile/hvar.rb
+- lib/fontisan/ufo/compile/item_variation_store.rb
 - lib/fontisan/ufo/compile/maxp.rb
+- lib/fontisan/ufo/compile/mvar.rb
 - lib/fontisan/ufo/compile/name.rb
 - lib/fontisan/ufo/compile/os2.rb
 - lib/fontisan/ufo/compile/otf_compiler.rb
 - lib/fontisan/ufo/compile/post.rb
+- lib/fontisan/ufo/compile/stat.rb
 - lib/fontisan/ufo/compile/ttf_compiler.rb
+- lib/fontisan/ufo/compile/variable_ttf.rb
 - lib/fontisan/ufo/component.rb
 - lib/fontisan/ufo/contour.rb
 - lib/fontisan/ufo/convert.rb