fontisan 0.4.17 → 0.4.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b874b7ec1a441c955ee5e1a75d0477ddac875cfbb109cd4111919a94210f5ee3
-  data.tar.gz: ef33acdcc6c296877c745852032a315588da42cfa1017e885bcf41e9fd66f474
+  metadata.gz: 2991840074aedcf587e7bbc673cd6b26b3c887f5e6b481b83c47d6a43151d287
+  data.tar.gz: 8cd0901c7e2fe8953e7ea24349c11c63b651ca989abbdfc4243e0ed3dba280f8
 SHA512:
-  metadata.gz: c3ce64b5b2cdf9a2c2604a638b8aaf0c1b681f2dab67377acf61f187960c68891920026fe9474ddc334ac8c4fdc491dcbe635f99e5e4f4cc31342def2d55f3b4
-  data.tar.gz: fa84952690ed773f7b38a40059bacf1efadc591c5cd2077a56e07854682c03c28228efc5e623b248302237fa2352336834feea77fe817ab655293cd3ebda0242
+  metadata.gz: 37053820640d91782777be8982ac22cf0bc09cdcaff60b484161ce711785ebb9462d3c333fe4564699e381db4557656d049f77394b64ecb2935d54e1f80d93be
+  data.tar.gz: 92d7207a5babbbfb155b4aec2cd9f4adfff4efcbe84886f58480a14596fcfa9941f6e406e4c7e4b3f9a822e7169277767cfd69ed8841ab4de3acfb8bdd64cb9e

data/lib/fontisan/converters/woff2_encoder.rb

@@ -28,6 +28,11 @@ module Fontisan
     class Woff2Encoder
       include ConversionStrategy
 
+      # Highest glyf offset addressable by short loca (uint16 max × 2).
+      # Above this, loca MUST use the long format. Public so specs can
+      # reference the same threshold the encoder uses.
+      SHORT_LOCA_GLYF_MAX = 0x1FFFE
+
       # @return [Hash] Configuration settings
       attr_reader :config
 
@@ -83,6 +88,13 @@ module Fontisan
                                                         transform_enabled,
                                                         glyf_transform:)
 
+        # Recompute head.checksumAdjustment for the SFNT the decoder
+        # reconstructs. Chrome's OTS validates this strictly; a stale
+        # source value fails once glyf/loca/head have been modified.
+        # Must run AFTER touch_head_modified! so the modified timestamp
+        # change is included in the checksum.
+        update_checksum_adjustment!(table_data, flavor:, glyf_transform:)
+
         compressed_data = compress_tables(entries, table_data,
                                           transformed_data, quality)
 
@@ -221,17 +233,17 @@ module Fontisan
 
       # Apply the WOFF2 glyf/loca paired transform per spec section 5.1/5.3.
       #
-      # Returns a hash with the transformed glyf bytes and the original
-      # loca length needed to emit its synthetic directory entry, or nil
-      # for CFF fonts or fonts missing glyf/loca. The original glyf bytes
-      # are kept in `table_data` so its `origLength` is preserved; the
-      # transformed bytes are passed to the entries builder separately.
+      # Returns a hash with the transformed glyf bytes and reconstructed
+      # glyf/loca bytes the directory/checksum must reference, or nil for
+      # CFF fonts or fonts missing glyf/loca.
       #
-      # glyf.origLength is computed by round-tripping the transformed glyf
-      # through the decoder — this guarantees the directory matches what
-      # any compliant decoder will produce, including padding and minor
-      # re-encoding differences (OFF section 5.3.3 allows multiple valid
-      # reconstructions of the same glyph data).
+      # The source glyf is first canonicalized to 4-byte-per-glyph
+      # alignment via `Woff2::GlyfCanonicalizer`, matching fontTools'
+      # `_normaliseGlyfAndLoca(padding=4)`. Chrome's OTS fails to
+      # reconstruct "unpadded" glyf tables — see fontTools'
+      # WOFF2Writer.close() comment. The canonical glyf is the input to
+      # the WOFF2 transform, the value of `glyf.origLength` in the
+      # directory, and the bytes the SFNT checksum is computed over.
       #
       # @return [Hash{Symbol => Object}, nil]
       def apply_glyf_loca_transform!(table_data, font)
@@ -246,32 +258,55 @@ module Fontisan
         head = font.table("head")
         return nil unless maxp && head
 
-        index_format = head.index_to_loc_format
-
-        transformed = Woff2::GlyfLocaTransform.new(
+        source_format = head.index_to_loc_format
+
+        # Pick the most compact loca format the canonical glyf fits in.
+        # The canonical glyf adds ≤ 3 padding bytes per glyph; estimate
+        # the upper bound so the format choice is safe. fontTools'
+        # encoder does the same — short loca halves the loca table size
+        # and Chrome's OTS accepts both formats.
+        max_canonical_glyf_size = glyf_data.bytesize + 3 * maxp.num_glyphs
+        target_format = if max_canonical_glyf_size <= SHORT_LOCA_GLYF_MAX
+                          0
+                        else
+                          source_format
+                        end
+
+        canonical = Woff2::GlyfCanonicalizer.new(
           glyf_data:,
           loca_data:,
           num_glyphs: maxp.num_glyphs,
-          index_format:,
-        ).transform
+          source_format:,
+          target_format:,
+        ).canonical
+        canonical_glyf = canonical[:glyf]
+        canonical_loca = canonical[:loca]
 
-        # Round-trip through the decoder to get the exact reconstructed
-        # sizes the directory must advertise. fontTools re-compiles glyf
-        # during encoding, producing sizes that differ from the source by
-        # small amounts (encoding variations per OFF section 5.3.3). Using
-        # the source bytesize causes fontTools' decoder to reject the
-        # WOFF2 with "not enough 'glyf' table data".
-        reconstructed = Woff2::GlyfLocaReconstruct.new(
-          transformed_glyf: transformed,
+        transformed = Woff2::GlyfLocaTransform.new(
+          glyf_data: canonical_glyf,
+          loca_data: canonical_loca,
           num_glyphs: maxp.num_glyphs,
-          index_format:,
-        ).reconstruct
+          index_format: target_format,
+        ).transform
 
-        glyf_orig_length = reconstructed[:glyf].bytesize
-        loca_orig_length = reconstructed[:loca].bytesize
+        if target_format != source_format
+          Woff2::EncoderRules.set_head_index_to_loc_format!(
+            table_data, target_format
+          )
+        end
+
+        glyf_orig_length = canonical_glyf.bytesize
+        loca_orig_length = canonical_loca.bytesize
+        table_data["glyf"] = canonical_glyf
         table_data.delete("loca")
 
-        { transformed_glyf: transformed, glyf_orig_length:, loca_orig_length: }
+        {
+          transformed_glyf: transformed,
+          reconstructed_glyf: canonical_glyf,
+          reconstructed_loca: canonical_loca,
+          glyf_orig_length:,
+          loca_orig_length:,
+        }
       end
 
       def get_table_data(font, tag)
@@ -396,6 +431,45 @@ module Fontisan
         size
       end
 
+      # Recompute head.checksumAdjustment for the SFNT the WOFF2 decoder
+      # will reconstruct. The decoder assembles glyf/loca from the
+      # transformed stream and uses the source bytes for every other
+      # table; the resulting SFNT's whole-file uint32 sum must equal
+      # 0xB1B0AFBA once checksumAdjustment is applied. Source's value is
+      # stale after head.flags/glyf/indexToLocFormat edits and Chrome's
+      # OTS rejects files that fail the checksum check.
+      #
+      # Mutates `table_data["head"]` in place via the Head BinData model.
+      def update_checksum_adjustment!(table_data, flavor:, glyf_transform:)
+        return unless table_data.key?("head")
+
+        # The synthetic loca entry was removed from table_data by
+        # apply_glyf_loca_transform!, but it's still part of the
+        # reconstructed SFNT, so it must be included in the checksum.
+        tags = table_data.keys.sort
+        if glyf_transform && !tags.include?("loca")
+          loca_idx = tags.index { |t| t > "loca" } || tags.length
+          tags.insert(loca_idx, "loca")
+        end
+
+        tables = tags.map do |tag|
+          bytes = if tag == "glyf" && glyf_transform
+                    glyf_transform[:reconstructed_glyf]
+                  elsif tag == "loca" && glyf_transform
+                    glyf_transform[:reconstructed_loca]
+                  else
+                    table_data[tag]
+                  end
+          Woff2::SfntChecksum::Table.new(tag:, bytes:)
+        end
+
+        adjustment = Woff2::SfntChecksum.new(flavor:, tables:).adjustment
+
+        head = Tables::Head.read(table_data["head"])
+        head.checksum_adjustment = adjustment
+        table_data["head"] = head.to_binary_s
+      end
+
       def build_header(flavor:, num_tables:, total_sfnt_size:,
                        total_compressed_size:)
         header = Woff2::Woff2Header.new

data/lib/fontisan/utilities/brotli_wrapper.rb

@@ -48,9 +48,7 @@ module Fontisan
         validate_data!(data)
 
         begin
-          # Use Brotli gem with specified quality
-          # The brotli gem doesn't expose mode constants, only quality
-          Brotli.deflate(data, quality: quality)
+          Brotli.deflate(data, quality: quality, mode: mode)
         rescue StandardError => e
           raise Fontisan::Error,
                 "Brotli compression failed: #{e.message}"
@@ -140,19 +138,6 @@ module Fontisan
                   "Data must be a String-like object, got #{data.class}"
           end
         end
-
-        # Convert mode symbol to Brotli constant
-        #
-        # NOTE: The brotli gem doesn't expose mode constants
-        # This method is kept for API compatibility but unused
-        #
-        # @param mode [Symbol] Mode symbol
-        # @return [Integer] Mode value (unused)
-        def brotli_mode(_mode)
-          # The brotli gem only accepts quality parameter
-          # Mode is not configurable in current version
-          0
-        end
       end
     end
   end

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/encoder_rules.rb

@@ -33,6 +33,7 @@ module Fontisan
       def self.apply!(table_data)
         exclude_tables!(table_data)
         mark_lossless_modifying!(table_data)
+        touch_head_modified!(table_data)
         table_data
       end
 
@@ -61,6 +62,44 @@ module Fontisan
         head.flags |= Tables::Head::FLAG_LOSSLESS_MODIFYING
         table_data["head"] = head.to_binary_s
       end
+
+      # Set head.indexToLocFormat to match the chosen output loca format.
+      #
+      # fontTools' WOFF2 encoder re-picks the loca format (preferring short
+      # when glyf fits). The reconstructed SFNT must carry the matching
+      # indexToLocFormat in head, or Chrome's OTS rejects the file with
+      # "Failed to convert WOFF 2.0 font to SFNT".
+      #
+      # @param table_data [Hash{String => String}]
+      # @param format_code [Integer] 0 (short) or 1 (long)
+      def self.set_head_index_to_loc_format!(table_data, format_code)
+        return unless table_data.key?("head")
+
+        head = Tables::Head.read(table_data["head"])
+        head.index_to_loc_format = format_code
+        table_data["head"] = head.to_binary_s
+      end
+
+      # Bump head.modified past head.created.
+      #
+      # Chrome's OTS rejects fonts whose modified timestamp is not strictly
+      # greater than created (source fonts often have modified == created,
+      # which fails this check). Setting modified = created + 1 is the
+      # minimal change that satisfies the constraint.
+      #
+      # Must be called BEFORE checksum recompute so the modified bytes are
+      # included in the checksum.
+      #
+      # @param table_data [Hash{String => String}]
+      def self.touch_head_modified!(table_data)
+        return unless table_data.key?("head")
+
+        head = Tables::Head.read(table_data["head"])
+        return if head.modified_raw.to_i > head.created_raw.to_i
+
+        head.modified_raw = head.created_raw + 1
+        table_data["head"] = head.to_binary_s
+      end
     end
   end
 end

data/lib/fontisan/woff2/glyf_canonicalizer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Woff2
+    # Canonicalizes a source glyf table by padding each glyph to a 4-byte
+    # boundary, matching fontTools' WOFF2 encoder behavior.
+    #
+    # fontTools' WOFF2 writer calls `_normaliseGlyfAndLoca(padding=4)` before
+    # transforming the glyf table (see Lib/fontTools/ttLib/woff2.py). Each
+    # glyph is recompiled with `recalcBBoxes=False`, which makes
+    # `Glyph#compile` return the source glyph bytes verbatim, then the
+    # glyf-table-level compile pads each glyph to the configured alignment.
+    # The result is a glyf whose bytes match the source byte-for-byte
+    # except for added padding (≤ 3 bytes per glyph).
+    #
+    # Chrome's OpenType Sanitizer (OTS) fails to reconstruct "unpadded"
+    # glyf tables — see the long comment in WOFF2Writer.close():
+    # https://github.com/google/woff2/issues/15
+    # https://github.com/khaledhosny/ots/issues/60
+    #
+    # The canonical glyf is the bytes the WOFF2 transform encodes, the
+    # bytes the decoder reconstructs, the bytes `glyf.origLength` reports,
+    # and the bytes the SFNT checksum is computed over. All four must
+    # agree.
+    class GlyfCanonicalizer
+      # @param glyf_data [String] Source glyf table bytes
+      # @param loca_data [String] Source loca table bytes
+      # @param num_glyphs [Integer] Glyph count from maxp
+      # @param source_format [Integer] 0 (short loca) or 1 (long loca) —
+      #   how to interpret the source loca
+      # @param target_format [Integer] 0 (short loca) or 1 (long loca) —
+      #   how to emit the canonical loca. Defaults to `source_format`.
+      def initialize(glyf_data:, loca_data:, num_glyphs:, source_format:,
+                     target_format: nil)
+        @glyf_data = glyf_data
+        @loca_data = loca_data
+        @num_glyphs = num_glyphs
+        @source_format = source_format
+        @target_format = target_format || source_format
+      end
+
+      # @return [Hash{Symbol => String}] `{ glyf:, loca: }` where glyf is
+      #   padded to 4-byte alignment per glyph and loca is emitted in
+      #   `target_format`.
+      def canonical
+        glyf = String.new(encoding: Encoding::BINARY)
+        new_offsets = [0]
+
+        @num_glyphs.times do |i|
+          start_offset = source_offsets[i]
+          end_offset = source_offsets[i + 1]
+          if start_offset < end_offset
+            glyf << @glyf_data.byteslice(start_offset, end_offset - start_offset)
+          end
+          remainder = glyf.bytesize % 4
+          glyf << ("\x00" * (4 - remainder)) if remainder.positive?
+          new_offsets << glyf.bytesize
+        end
+
+        { glyf:, loca: build_loca(new_offsets) }
+      end
+
+      private
+
+      def source_offsets
+        @source_offsets ||= begin
+          offsets = if @source_format.zero?
+                      @loca_data.unpack("n*").map { |v| v * 2 }
+                    else
+                      @loca_data.unpack("N*")
+                    end
+          if offsets.length != @num_glyphs + 1
+            raise InvalidFontError,
+                  "loca has #{offsets.length} entries, expected #{@num_glyphs + 1}"
+          end
+          offsets
+        end
+      end
+
+      def build_loca(offsets)
+        if @target_format.zero?
+          offsets.map { |o| o / 2 }.pack("n*")
+        else
+          offsets.pack("N*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/woff2/sfnt_checksum.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Woff2
+    # Computes head.checksumAdjustment for the SFNT that the WOFF2 decoder
+    # reconstructs at runtime.
+    #
+    # Per OpenType spec, head.checksumAdjustment must be set so that the
+    # uint32-wise sum of the entire SFNT file (offset table + table
+    # directory + all tables) equals the magic 0xB1B0AFBA. Chrome's OTS
+    # validates this; a stale value from the source font causes rejection
+    # with "Failed to convert WOFF 2.0 font to SFNT" once any table has
+    # been modified (head.flags bit 11, glyf/loca transformation, etc.).
+    #
+    # Reference: OpenType spec, "Calculating Checksums".
+    class SfntChecksum
+      # Per-table data the checksum is computed over. tag is the 4-byte
+      # table tag, bytes is the (already reconstructed, post-transform)
+      # table data the decoder will see.
+      Table = Struct.new(:tag, :bytes, keyword_init: true)
+
+      # @param flavor [Integer] sfnt version (0x00010000 for TrueType,
+      #   0x4F54544F for CFF)
+      # @param tables [Array<Table>] reconstructed tables in alphabetical
+      #   tag order
+      def initialize(flavor:, tables:)
+        @flavor = flavor
+        @tables = tables
+      end
+
+      # Compute the head.checksumAdjustment value (uint32).
+      #
+      # @return [Integer]
+      def adjustment
+        (Constants::CHECKSUM_ADJUSTMENT_MAGIC - total_checksum) & 0xFFFFFFFF
+      end
+
+      private
+
+      # Whole-SFNT checksum with head.checksumAdjustment treated as 0.
+      def total_checksum
+        sum = offset_table_checksum
+        sum = (sum + directory_checksum) & 0xFFFFFFFF
+        @tables.each do |t|
+          sum = (sum + per_table_checksum(t)) & 0xFFFFFFFF
+        end
+        sum
+      end
+
+      # Checksum of the 12-byte offset table (sfnt version + numTables +
+      # searchRange + entrySelector + rangeShift).
+      def offset_table_checksum
+        n = @tables.size
+        search_range = (2**Integer(Math.log2(n))) * 16
+        entry_selector = Integer(Math.log2(n))
+        range_shift = n * 16 - search_range
+        bytes = [@flavor, n, search_range, entry_selector, range_shift]
+          .pack("I>S>S>S>S>")
+        uint32_sum(bytes.ljust(12, "\x00"))
+      end
+
+      # Checksum of the table directory (one 16-byte entry per table).
+      # Each entry is tag(4) + checksum(4) + offset(4) + length(4).
+      def directory_checksum
+        offsets = {}
+        cursor = 12 + @tables.size * 16
+        @tables.each do |t|
+          offsets[t.tag] = cursor
+          cursor += padded_size(t.bytes.bytesize)
+        end
+        bytes = String.new(encoding: Encoding::BINARY)
+        @tables.each do |t|
+          tag_bytes = t.tag.encode(Encoding::BINARY).ljust(4, " ")
+          bytes << tag_bytes
+          bytes << [per_table_checksum(t)].pack("I>")
+          bytes << [offsets[t.tag]].pack("I>")
+          bytes << [t.bytes.bytesize].pack("I>")
+        end
+        uint32_sum(bytes)
+      end
+
+      # OpenType per-table checksum. The head table's checksumAdjustment
+      # field (offset 8-11) is treated as zero per spec. Tables are
+      # zero-padded to a 4-byte boundary for checksum, even when their
+      # actual length is shorter.
+      def per_table_checksum(table)
+        bytes = table.bytes.dup.force_encoding(Encoding::BINARY)
+        if table.tag == "head"
+          bytes = "#{bytes.byteslice(0, 8)}\u0000\u0000\u0000\u0000#{bytes.byteslice(12..)}"
+        end
+        uint32_sum(pad_to_4(bytes))
+      end
+
+      def uint32_sum(bytes)
+        bytes.unpack("I>*").sum & 0xFFFFFFFF
+      end
+
+      def pad_to_4(bytes)
+        pad = (-bytes.bytesize) % 4
+        pad.zero? ? bytes : bytes + ("\x00" * pad)
+      end
+
+      def padded_size(size)
+        (size + 3) & ~3
+      end
+    end
+  end
+end

data/lib/fontisan/woff2.rb

@@ -8,9 +8,11 @@ module Fontisan
     autoload :CollectionEncoder, "fontisan/woff2/collection_encoder"
     autoload :Directory, "fontisan/woff2/directory"
     autoload :EncoderRules, "fontisan/woff2/encoder_rules"
+    autoload :GlyfCanonicalizer, "fontisan/woff2/glyf_canonicalizer"
     autoload :GlyfLocaReconstruct, "fontisan/woff2/glyf_loca_reconstruct"
     autoload :GlyfLocaTransform, "fontisan/woff2/glyf_loca_transform"
     autoload :HmtxTransformer, "fontisan/woff2/hmtx_transformer"
+    autoload :SfntChecksum, "fontisan/woff2/sfnt_checksum"
     autoload :TableTransformer, "fontisan/woff2/table_transformer"
     autoload :TripletCodec, "fontisan/woff2/triplet_codec"
     autoload :UInt255, "fontisan/woff2/uint255"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.17
+  version: 0.4.18
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-06 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -723,10 +723,12 @@ files:
 - lib/fontisan/woff2/collection_encoder.rb
 - lib/fontisan/woff2/directory.rb
 - lib/fontisan/woff2/encoder_rules.rb
+- lib/fontisan/woff2/glyf_canonicalizer.rb
 - lib/fontisan/woff2/glyf_loca_reconstruct.rb
 - lib/fontisan/woff2/glyf_loca_transform.rb
 - lib/fontisan/woff2/header.rb
 - lib/fontisan/woff2/hmtx_transformer.rb
+- lib/fontisan/woff2/sfnt_checksum.rb
 - lib/fontisan/woff2/table_transformer.rb
 - lib/fontisan/woff2/triplet_codec.rb
 - lib/fontisan/woff2/uint255.rb