fontisan 0.4.13 → 0.4.15

data/lib/fontisan/woff2/glyf_loca_reconstruct.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Woff2
+    # Reconstructs glyf and loca tables from the WOFF2 transformed glyf
+    # stream per spec section 5.1. This is the decoder counterpart of
+    # {Woff2::GlyfLocaTransform}.
+    #
+    # The transformed glyf table is split into 7 streams preceded by a
+    # 36-byte header (uint16 version + uint16 optionFlags + uint16 numGlyphs
+    # + uint16 indexFormat + 7 × uint32 stream sizes). An optional
+    # overlapSimpleBitmap follows when optionFlags bit 0 is set.
+    #
+    # Reference: W3C WOFF2 spec, section 5.1.
+    class GlyfLocaReconstruct
+      # TrueType simple-glyph flag bits per OpenType spec.
+      FLAG_ON_CURVE = 0x01
+      FLAG_X_SHORT = 0x02
+      FLAG_Y_SHORT = 0x04
+      FLAG_REPEAT = 0x08
+      FLAG_X_SAME_OR_POS = 0x10
+      FLAG_Y_SAME_OR_POS = 0x20
+      FLAG_OVERLAP_SIMPLE = 0x40
+
+      # TrueType composite-glyph flag bits.
+      ARG_1_AND_2_ARE_WORDS = 0x0001
+      WE_HAVE_A_SCALE = 0x0008
+      MORE_COMPONENTS = 0x0020
+      WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
+      WE_HAVE_A_TWO_BY_TWO = 0x0080
+      WE_HAVE_INSTRUCTIONS = 0x0100
+
+      # 8-byte header + 7 × 4-byte stream sizes.
+      HEADER_SIZE = 36
+
+      attr_reader :num_glyphs, :index_format
+
+      # @param transformed_glyf [String] bytes of the transformed glyf table
+      # @param num_glyphs [Integer] from maxp
+      # @param index_format [Integer] 0 (short) or 1 (long), from head
+      def initialize(transformed_glyf:, num_glyphs:, index_format:)
+        @data = transformed_glyf
+        @num_glyphs = num_glyphs
+        @index_format = index_format
+      end
+
+      # Reconstruct glyf and loca tables.
+      #
+      # @return [Hash{Symbol => String}] `{ glyf:, loca: }`
+      def reconstruct
+        header = parse_header
+        streams = read_streams(header)
+
+        glyf = String.new(encoding: Encoding::BINARY)
+        offsets = [0]
+
+        num_glyphs.times do |glyph_id|
+          glyph = decode_glyph(glyph_id, streams)
+          glyf << glyph
+          offsets << glyf.bytesize
+        end
+
+        { glyf:, loca: build_loca(offsets) }
+      end
+
+      private
+
+      # Parsed header. Holds the 4 uint16 fields plus the 7 uint32 stream
+      # sizes. Stored as a Hash so the keys document themselves.
+      def parse_header
+        version, option_flags, ng, idx_fmt = @data[0, 8].unpack("S>S>S>S>")
+        sizes = @data[8, 28].unpack("L>7")
+
+        if ng != @num_glyphs
+          raise InvalidFontError,
+                "WOFF2 glyf numGlyphs mismatch: header says #{ng}, expected #{@num_glyphs}"
+        end
+        if idx_fmt != @index_format
+          raise InvalidFontError,
+                "WOFF2 glyf indexFormat mismatch: header says #{idx_fmt}, expected #{@index_format}"
+        end
+
+        {
+          version:,
+          option_flags:,
+          has_overlap_bitmap: (option_flags & 0x01).nonzero?,
+          stream_sizes: sizes,
+        }
+      end
+
+      # Slice the 7 streams out of the data block and set up per-stream
+      # StringIO cursors. The bboxStream is split into bboxBitmap (fixed
+      # size per numGlyphs) and bboxStream (variable, conditionally read
+      # per glyph). The optional overlapSimpleBitmap is read at the end.
+      def read_streams(header)
+        pos = HEADER_SIZE
+        bitmap_size = ((@num_glyphs + 31) >> 5) << 2
+        overlap_size = header[:has_overlap_bitmap] ? ((@num_glyphs + 7) >> 3) : 0
+
+        names = %i[n_contour n_points flags glyph composite bbox instructions]
+        streams = {}
+        names.each_with_index do |name, i|
+          size = header[:stream_sizes][i]
+          streams[name] = StringIO.new(@data[pos, size])
+          pos += size
+        end
+
+        # bboxStream begins with bboxBitmap (4 × floor((numGlyphs+31)/32)).
+        bbox_blob = streams[:bbox].string
+        streams[:bbox_bitmap] = bbox_blob[0, bitmap_size] || ""
+        streams[:bbox_entries] = StringIO.new(bbox_blob[bitmap_size..] || "")
+
+        # overlapSimpleBitmap follows all streams when optionFlags bit 0 set.
+        streams[:overlap_bitmap] = header[:has_overlap_bitmap] ? @data[pos, overlap_size] : ""
+
+        # nContour is read positionally (int16 per glyph).
+        nc_data = streams[:n_contour].string
+        streams[:n_contour_values] = nc_data.unpack("s>*")
+
+        streams
+      end
+
+      def decode_glyph(glyph_id, streams)
+        num_contours = streams[:n_contour_values][glyph_id]
+
+        case num_contours
+        when 0
+          # Empty glyph: just an entry in loca (loca[n] == loca[n-1]).
+          ""
+        when -1
+          decode_composite(glyph_id, streams)
+        else
+          decode_simple(glyph_id, num_contours, streams)
+        end
+      end
+
+      # Decode a simple glyph per spec section 5.1 "Decoding of Simple Glyphs".
+      def decode_simple(glyph_id, num_contours, streams)
+        # Step 1: read num_contours 255UInt16 values from nPointsStream to
+        # build endPtsOfContours[].
+        end_pts = []
+        cumulative = -1
+        num_contours.times do
+          pts_of_contour = read_255_uint16(streams[:n_points])
+          cumulative += pts_of_contour
+          end_pts << cumulative
+        end
+        total_points = end_pts.last + 1
+
+        # Step 2: read total_points flag bytes from flagStream (triplet flags).
+        triplet_flags = streams[:flags].read(total_points).bytes
+
+        # Step 3: read coordinate triplets from glyphStream (1-4 bytes per
+        # point depending on flag). Decode to (dx, dy) deltas.
+        xs = []
+        ys = []
+        on_curve_flags = []
+        x = 0
+        y = 0
+        triplet_flags.each do |flag|
+          dx, dy, oc = TripletCodec.decode(flag, read_triplet_payload(flag, streams[:glyph]))
+          x += dx
+          y += dy
+          xs << x
+          ys << y
+          on_curve_flags << (oc ? FLAG_ON_CURVE : 0)
+        end
+
+        # Step 4-5: read instructionLength from glyphStream, bytes from instructionStream.
+        inst_len = read_255_uint16(streams[:glyph])
+        instructions = streams[:instructions].read(inst_len)
+
+        # Bbox: emit explicit bbox if bboxBitmap bit is set for this glyph,
+        # otherwise recalculate from coordinates.
+        bbox = if bbox_bit_set?(streams[:bbox_bitmap], glyph_id)
+                 read_bbox(streams[:bbox_entries])
+               else
+                 calc_bounds(xs, ys) || [0, 0, 0, 0]
+               end
+
+        # Re-encode in standard TrueType format.
+        build_simple_glyph_bytes(num_contours:, bbox:, end_pts:,
+                                 on_curve_flags:, xs:, ys:, instructions:,
+                                 overlap: overlap_bit_set?(streams[:overlap_bitmap], glyph_id))
+      end
+
+      def decode_composite(_glyph_id, streams)
+        # Composite components are stored verbatim in compositeStream. Walk
+        # the component records to find their total byte length, then copy.
+        # Per spec section 5.1 "Decoding of Composite Glyphs": each component
+        # has a uint16 flags word, then 4-14 argument bytes.
+        composite_io = streams[:composite]
+        component_start = composite_io.pos
+        have_instructions = false
+        loop do
+          break if composite_io.eof?
+
+          flags = read_uint16_io(composite_io)
+          composite_io.read(2) # glyphIndex
+          composite_io.read((flags & ARG_1_AND_2_ARE_WORDS).nonzero? ? 4 : 2)
+          composite_io.read(composite_transform_size(flags))
+          have_instructions = (flags & WE_HAVE_INSTRUCTIONS).nonzero?
+          break if (flags & MORE_COMPONENTS).zero?
+        end
+        component_end = composite_io.pos
+        component_bytes = composite_io.string[component_start...component_end]
+
+        instructions = String.new(encoding: Encoding::BINARY)
+        if have_instructions
+          inst_len = read_255_uint16(streams[:glyph])
+          instructions = streams[:instructions].read(inst_len)
+        end
+
+        # Composite glyphs always have explicit bbox in bboxStream.
+        bbox = read_bbox(streams[:bbox_entries])
+
+        # num_contours = -1 (int16), bbox 4 × int16, components, optional instructions
+        out = String.new(encoding: Encoding::BINARY)
+        out << [-1].pack("s>")
+        out << bbox.pack("s>*")
+        out << component_bytes
+        # If the last component had WE_HAVE_INSTRUCTIONS, the standard
+        # TrueType composite format expects a uint16 instructionLength
+        # followed by the instruction bytes.
+        if have_instructions
+          out << [instructions.bytesize].pack("n")
+          out << instructions
+        end
+        out
+      end
+
+      def composite_transform_size(flags)
+        if (flags & WE_HAVE_A_SCALE).nonzero? then 2
+        elsif (flags & WE_HAVE_AN_X_AND_Y_SCALE).nonzero? then 4
+        elsif (flags & WE_HAVE_A_TWO_BY_TWO).nonzero? then 8
+        else
+          0
+        end
+      end
+
+      # Read 1-4 payload bytes for a triplet based on the flag's index bits.
+      def read_triplet_payload(flag, io)
+        idx = flag & 0x7F
+        n_bytes = if idx < 84 then 1
+                  elsif idx < 120 then 2
+                  elsif idx < 124 then 3
+                  else 4
+                  end
+        bytes = io.read(n_bytes)
+        bytes ? bytes.bytes : Array.new(n_bytes, 0)
+      end
+
+      def read_255_uint16(io)
+        return 0 if io.eof?
+
+        code = io.read(1)&.unpack1("C")
+        return 0 unless code
+
+        case code
+        when 0..252 then code
+        when 253
+          b = io.read(1)&.unpack1("C") || 0
+          253 + b
+        when 254
+          io.read(2)&.unpack1("n") || 0
+
+        when 255
+          v = io.read(2)&.unpack1("n") || 0
+          v + 506
+        end
+      end
+
+      def read_uint16_io(io)
+        io.read(2)&.unpack1("n") || 0
+      end
+
+      def bbox_bit_set?(bbox_bitmap, glyph_id)
+        return false if bbox_bitmap.nil? || bbox_bitmap.empty?
+
+        byte_idx = glyph_id >> 3
+        bit_idx = glyph_id & 7
+        (bbox_bitmap.getbyte(byte_idx) & (0x80 >> bit_idx)).nonzero?
+      end
+
+      def overlap_bit_set?(overlap_bitmap, glyph_id)
+        return false unless overlap_bitmap && !overlap_bitmap.empty?
+
+        byte_idx = glyph_id >> 3
+        bit_idx = glyph_id & 7
+        (overlap_bitmap.getbyte(byte_idx) & (0x80 >> bit_idx)).nonzero?
+      end
+
+      def read_bbox(io)
+        bytes = io.read(8)
+        return [0, 0, 0, 0] unless bytes&.bytesize == 8
+
+        bytes.unpack("s>*")
+      end
+
+      def calc_bounds(xs, ys)
+        return nil if xs.empty?
+
+        [xs.min, ys.min, xs.max, ys.max]
+      end
+
+      # Build a standard TrueType simple-glyph record from per-point arrays.
+      # Re-encodes coordinates using the standard TrueType flag scheme based
+      # on per-point delta magnitudes (per OFF section 5.3.3 spec rules).
+      def build_simple_glyph_bytes(num_contours:, bbox:, end_pts:, on_curve_flags:,
+                                   xs:, ys:, instructions:, overlap:)
+        out = String.new(encoding: Encoding::BINARY)
+        out << [num_contours].pack("s>")
+        out << bbox.pack("s>*")
+        out << end_pts.pack("n*")
+        out << [instructions.bytesize].pack("n")
+        out << instructions
+
+        prev_x = prev_y = 0
+        tt_flags = []
+        x_bytes = String.new(encoding: Encoding::BINARY)
+        y_bytes = String.new(encoding: Encoding::BINARY)
+
+        xs.each_with_index do |x, i|
+          y = ys[i]
+          dx = x - prev_x
+          dy = y - prev_y
+          prev_x = x
+          prev_y = y
+
+          base = on_curve_flags[i]
+          base |= FLAG_OVERLAP_SIMPLE if overlap && i.zero?
+
+          flag = encode_axis_bits(base, x_bytes, short_bit: FLAG_X_SHORT,
+                                                 same_bit: FLAG_X_SAME_OR_POS,
+                                                 value: dx)
+          flag = encode_axis_bits(flag, y_bytes, short_bit: FLAG_Y_SHORT,
+                                                 same_bit: FLAG_Y_SAME_OR_POS,
+                                                 value: dy)
+          tt_flags << flag
+        end
+
+        out << encode_flags_rle(tt_flags)
+        out << x_bytes
+        out << y_bytes
+        out
+      end
+
+      # Encode one axis delta into standard TrueType byte layout. Returns
+      # the updated flag value (X bits if short_bit is FLAG_X_SHORT, Y bits
+      # if short_bit is FLAG_Y_SHORT).
+      def encode_axis_bits(base, out, short_bit:, same_bit:, value:)
+        if value.zero?
+          base | same_bit
+        elsif value.abs <= 255
+          flag = base | short_bit
+          flag |= same_bit if value.positive?
+          out << (value.abs & 0xFF)
+          flag
+        else
+          out << [value & 0xFFFF].pack("n")
+          base
+        end
+      end
+
+      # Run-length encode the flags array per OFF spec: when two or more
+      # consecutive flags are identical, emit REPEAT_FLAG followed by count.
+      def encode_flags_rle(flags)
+        out = String.new(encoding: Encoding::BINARY)
+        i = 0
+        while i < flags.size
+          flag = flags[i]
+          count = 1
+          while i + count < flags.size && flags[i + count] == flag && count < 255
+            count += 1
+          end
+          if count > 1
+            out << (flag | FLAG_REPEAT).chr(Encoding::BINARY)
+            out << count.chr(Encoding::BINARY)
+            i += count
+          else
+            out << flag.chr(Encoding::BINARY)
+            i += 1
+          end
+        end
+        out
+      end
+
+      # Build loca table from accumulated glyph offsets per spec section 5.3.
+      def build_loca(offsets)
+        if @index_format.zero?
+          offsets.map { |o| o / 2 }.pack("n*")
+        else
+          offsets.pack("N*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/woff2/glyf_loca_transform.rb

@@ -41,17 +41,21 @@ module Fontisan
       # Simple glyph records start with int16 numberOfContours + 4 int16 bbox.
       SIMPLE_HEADER_SIZE = 10
 
-      attr_reader :num_glyphs, :index_format
+      attr_reader :num_glyphs, :source_index_format
 
       # @param glyf_data [String] raw glyf table bytes
       # @param loca_data [String] raw loca table bytes
       # @param num_glyphs [Integer] from maxp
-      # @param index_format [Integer] 0 (short) or 1 (long), from head
+      # @param index_format [Integer] 0 (short) or 1 (long), from head.
+      #   Used to parse the source loca; the WOFF2 transformed glyf
+      #   always emits indexFormat=0 (Chrome OTS silently rejects any
+      #   other value, even though WOFF2 spec section 5.1 allows the
+      #   source's indexToLocFormat).
       def initialize(glyf_data:, loca_data:, num_glyphs:, index_format:)
         @glyf_data = glyf_data
         @loca_data = loca_data
         @num_glyphs = num_glyphs
-        @index_format = index_format
+        @source_index_format = index_format
       end
 
       # Encode the glyf/loca transform, returning the transformed glyf bytes.
@@ -251,7 +255,10 @@ module Fontisan
         out << [0].pack("S>")                                  # version
         out << [(s.has_overlap? ? 1 : 0)].pack("S>")           # optionFlags
         out << [@num_glyphs].pack("S>")
-        out << [@index_format].pack("S>")
+        # Always emit indexFormat=0 per Chrome OTS requirement. WOFF2 spec
+        # section 5.1 allows the source's indexToLocFormat, but Chrome's
+        # OTS silently rejects any value other than 0.
+        out << [0].pack("S>")
         out << [s.n_contour.bytesize].pack("L>")
         out << [s.n_points.bytesize].pack("L>")
         out << [s.flags.bytesize].pack("L>")
@@ -271,7 +278,7 @@ module Fontisan
       end
 
       def parse_loca_offsets
-        if @index_format.zero?
+        if @source_index_format.zero?
           @loca_data.unpack("n*").map { |v| v * 2 }
         else
           @loca_data.unpack("N*")

data/lib/fontisan/woff2.rb

@@ -4,10 +4,12 @@
 
 module Fontisan
   module Woff2
+    autoload :CollectionDecoder, "fontisan/woff2/collection_decoder"
+    autoload :CollectionEncoder, "fontisan/woff2/collection_encoder"
     autoload :Directory, "fontisan/woff2/directory"
     autoload :EncoderRules, "fontisan/woff2/encoder_rules"
+    autoload :GlyfLocaReconstruct, "fontisan/woff2/glyf_loca_reconstruct"
     autoload :GlyfLocaTransform, "fontisan/woff2/glyf_loca_transform"
-    autoload :GlyfTransformer, "fontisan/woff2/glyf_transformer"
     autoload :HmtxTransformer, "fontisan/woff2/hmtx_transformer"
     autoload :TableTransformer, "fontisan/woff2/table_transformer"
     autoload :TripletCodec, "fontisan/woff2/triplet_codec"

data/lib/fontisan/woff2_collection.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  # WOFF2 font collection (spec section 4.2).
+  #
+  # Wraps a WOFF2 collection file (flavor='ttcf') and exposes the same
+  # interface as `TrueTypeCollection`/`OpenTypeCollection` so collection
+  # consumers don't need to know which container format they're holding.
+  #
+  # Unlike TTC/OTC (which subclass `BaseCollection` for BinData parsing),
+  # WOFF2 collections are decoded eagerly via `Woff2::CollectionDecoder`
+  # because the per-font tables require Brotli decompression +
+  # glyf/loca reconstruction before they can be returned.
+  class Woff2Collection
+    include Collection::SharedLogic
+
+    # @return [String] Source WOFF2 binary
+    attr_reader :data
+
+    # @param data [String] WOFF2 collection binary
+    def initialize(data)
+      @data = data.force_encoding(Encoding::BINARY)
+    end
+
+    # Load a WOFF2 collection from a file path.
+    #
+    # @param path [String]
+    # @return [Woff2Collection]
+    def self.from_file(path)
+      new(File.binread(path))
+    end
+
+    # Number of fonts in the collection.
+    #
+    # @return [Integer]
+    def num_fonts
+      decoded.length
+    end
+    alias font_count num_fonts
+
+    # Per-font synthetic offsets. WOFF2 collections don't have byte offsets
+    # like TTC (each font is reconstructed in memory); the index is the
+    # only identifier. Returned for compatibility with `BaseCollection`'s
+    # interface.
+    #
+    # @return [Array<Integer>] 0..num_fonts-1
+    def font_offsets
+      (0...num_fonts).to_a
+    end
+
+    # Extract every font in the collection.
+    #
+    # @param _io [IO, nil] Ignored — WOFF2 collections decode in memory.
+    # @return [Array<TrueTypeFont, OpenTypeFont>]
+    def extract_fonts(_io = nil)
+      decoded.map { |entry| build_font(entry) }
+    end
+
+    # Get a single font by index.
+    #
+    # @param index [Integer] 0-based font index
+    # @param _io [IO, nil] Ignored.
+    # @param _mode [Symbol] Ignored — full mode only (WOFF2 collections are
+    #   decoded eagerly).
+    # @return [TrueTypeFont, OpenTypeFont, nil] nil if index out of range
+    def font(index, _io = nil, _mode: LoadingModes::FULL)
+      return nil if index >= num_fonts
+
+      build_font(decoded[index])
+    end
+
+    # Whether this object represents a font collection. WOFF2 collections
+    # are always collections.
+    #
+    # @return [Boolean]
+    def collection? = true
+
+    # Collections have no single SFNT table directory.
+    #
+    # @return [Array<String>] empty
+    def table_names = []
+
+    # Validate format correctness.
+    #
+    # @return [Boolean]
+    def valid?
+      flavor = @data[4, 4].unpack1("N")
+      flavor == Woff2::CollectionDecoder::TTC_FLAVOR
+    rescue StandardError
+      false
+    end
+
+    # High-level pipeline format identifier. Owned by the collection class
+    # so the conversion pipeline can dispatch without case statements.
+    #
+    # @return [Symbol] :woff2_collection
+    def format = :woff2_collection
+
+    private
+
+    # Lazily decoded collection entries (one Hash per font).
+    def decoded
+      @decoded ||= Woff2::CollectionDecoder.new(@data).decode
+    end
+
+    # Build a TrueTypeFont or OpenTypeFont from a decoded font entry.
+    # Constructs an in-memory SFNT binary from the per-table data and
+    # loads it through the normal font reader path.
+    def build_font(entry)
+      sfnt = SfntBuilder.build(flavor: entry[:flavor], tables: entry[:tables])
+      sfnt_io = StringIO.new(sfnt)
+      font_class = truetype_flavor?(entry[:flavor]) ? TrueTypeFont : OpenTypeFont
+      font = font_class.read(sfnt_io)
+      font.initialize_storage
+      font.read_table_data(StringIO.new(sfnt))
+      font
+    end
+
+    def truetype_flavor?(flavor)
+      [Constants::SFNT_VERSION_TRUETYPE, 0x00010000].include?(flavor)
+    end
+  end
+end

data/lib/fontisan/woff2_font.rb

@@ -538,59 +538,42 @@ module Fontisan
     # @param decompressed_tables [Hash<String, String>] Decompressed tables
     # @return [void] Modifies decompressed_tables in place
     def self.apply_transformations!(table_entries, decompressed_tables)
-      # Find entries that need transformation
       glyf_entry = table_entries.find { |e| e.tag == "glyf" }
       hmtx_entry = table_entries.find { |e| e.tag == "hmtx" }
 
-      # Get required metadata for transformations
       maxp_data = decompressed_tables["maxp"]
       hhea_data = decompressed_tables["hhea"]
+      head_data = decompressed_tables["head"]
 
-      return unless maxp_data && hhea_data
+      return unless maxp_data && hhea_data && head_data
 
-      # Parse num_glyphs from maxp table
       # maxp format: version(4) + numGlyphs(2) + ...
       num_glyphs = maxp_data[4, 2].unpack1("n")
-
-      # Parse numberOfHMetrics from hhea table
       # hhea format: ... + numberOfHMetrics(2) at offset 34
       number_of_h_metrics = hhea_data[34, 2].unpack1("n")
-
-      # Check if this is a variable font by checking for fvar table
-      variable_font = table_entries.any? { |e| e.tag == "fvar" }
-
-      # Transform glyf/loca if needed
-      # transform_length is only set when table is actually transformed
-      # Check that transform_length exists and is greater than 0
-      if glyf_entry&.instance_variable_defined?(:@transform_length) &&
-          glyf_entry.transform_length&.positive?
-        transformed_glyf = decompressed_tables["glyf"]
-
-        if transformed_glyf
-          result = Woff2::GlyfTransformer.reconstruct(
-            transformed_glyf,
-            num_glyphs,
-            variable_font: variable_font,
-          )
-          decompressed_tables["glyf"] = result[:glyf]
-          decompressed_tables["loca"] = result[:loca]
-        end
+      # head format: ... + indexToLocFormat(2) at offset 50
+      index_format = head_data[50, 2].unpack1("n")
+
+      # Reconstruct glyf/loca per spec section 5.1/5.3 when glyf is
+      # transformed. Per spec section 4.1, transformLength is present IFF
+      # the table is transformed, so a non-nil value indicates transform.
+      if glyf_entry&.transform_length && decompressed_tables["glyf"]
+        result = Woff2::GlyfLocaReconstruct.new(
+          transformed_glyf: decompressed_tables["glyf"],
+          num_glyphs:,
+          index_format:,
+        ).reconstruct
+        decompressed_tables["glyf"] = result[:glyf]
+        decompressed_tables["loca"] = result[:loca]
       end
 
-      # Transform hmtx if needed
-      # transform_length is only set when table is actually transformed
-      # Check that transform_length exists and is greater than 0
-      if hmtx_entry&.instance_variable_defined?(:@transform_length) &&
-          hmtx_entry.transform_length&.positive?
-        transformed_hmtx = decompressed_tables["hmtx"]
-
-        if transformed_hmtx
-          decompressed_tables["hmtx"] = Woff2::HmtxTransformer.reconstruct(
-            transformed_hmtx,
-            num_glyphs,
-            number_of_h_metrics,
-          )
-        end
+      # Reconstruct hmtx per spec section 5.4 when hmtx is transformed.
+      if hmtx_entry&.transform_length && decompressed_tables["hmtx"]
+        decompressed_tables["hmtx"] = Woff2::HmtxTransformer.reconstruct(
+          decompressed_tables["hmtx"],
+          num_glyphs,
+          number_of_h_metrics,
+        )
       end
     end
 

data/lib/fontisan.rb

@@ -116,6 +116,7 @@ module Fontisan
   autoload :OutlineExtractor, "fontisan/outline_extractor"
   autoload :SfntFont, "fontisan/sfnt_font"
   autoload :SfntTable, "fontisan/sfnt_table"
+  autoload :SfntBuilder, "fontisan/sfnt_builder"
   autoload :Stitcher, "fontisan/stitcher"
   autoload :StitcherCli, "fontisan/stitcher_cli"
   autoload :Tasks, "fontisan/tasks"
@@ -123,6 +124,7 @@ module Fontisan
   autoload :TrueTypeFont, "fontisan/true_type_font"
   autoload :TrueTypeFontExtensions, "fontisan/true_type_font_extensions"
   autoload :Type1Font, "fontisan/type1_font"
+  autoload :Woff2Collection, "fontisan/woff2_collection"
   autoload :Woff2Font, "fontisan/woff2_font"
   autoload :WoffFont, "fontisan/woff_font"