fontisan 0.4.13 → 0.4.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f871e8b123fcb90294e234b49a73ee6ad5541a5064c11e34b47cf8a0c26646a
-  data.tar.gz: 90fb63c4e71aaf2bb91f4884f3b6cdca26b5b9bbb9dac3f0a812d96bca5d69f8
+  metadata.gz: 47e074b8c2bbdcfa377c95733f56fdd978dfa4d824dbae3e29f3bd75935dddd6
+  data.tar.gz: a1a348db0bd6dde039c0a43f62ac3ab43792cc7414e995a72c47798663a1cd59
 SHA512:
-  metadata.gz: 57fc98bbeb302426ef4fcf5453c0c37102ee6cf41c126d4cd724a727ffaee24313b6faf9a0ae1301642eefa85b93bca4371853a7891df304ac5c191c88a77aac
-  data.tar.gz: 4cbc0c95aa3eff13ed3dd479450d3615cf1a01f5e6a5e866c9f98b216491b14d92885178f4e03f23879a0eedcdffa03b8bb74653d5df39ab8d1a776f51d3cbcf
+  metadata.gz: e8917cc8c995f0ca2cbdc9e94ad5d5d629ab95d8809b7eb728d360f0743a2b26e5cfd059254497c5a1df10ddb3b53258ee703c441a106d4febd42b26ea3b6e08
+  data.tar.gz: d35a8138d7cdbc5389b619ed757863cc0d61e1d8d025655d0fb6736a21815f04d24802f24236fdffdc8d430192db79798f77f7b9343193e0c16035d2be8fc5eb

data/README.adoc

@@ -120,7 +120,7 @@ Font format support::
 * TTF, OTF (CFF1), OTF2 (CFF2), TTC, OTC font formats (production ready)
 * CFF2 with variable-font blend/vsindex operators, FDSelect, subroutines
 * Adobe Type 1 fonts (PFB/PFA) with bidirectional conversion (see link:docs/TYPE1_FONTS.adoc[Type 1 Fonts Guide])
-* WOFF/WOFF2 format support with reading, writing, and conversion (see link:docs/WOFF_WOFF2_FORMATS.adoc[WOFF/WOFF2 Guide])
+* WOFF/WOFF2 format support with reading, writing, and conversion — fully compliant with W3C WOFF 1.0 (https://www.w3.org/TR/WOFF/[Recommendation 13 December 2012]) and WOFF 2.0 (https://www.w3.org/TR/WOFF2/[Recommendation 08 August 2024]) specifications. See link:docs/WOFF_WOFF2_FORMATS.adoc[WOFF/WOFF2 Guide].
 * Apple legacy font support: 'true' signature TrueType fonts and dfont format (see link:docs/APPLE_LEGACY_FONTS.adoc[Apple Legacy Fonts Guide])
 * SVG font generation and SVG-to-glyph conversion (complete)
 

data/docs/WOFF_WOFF2_FORMATS.adoc

@@ -8,6 +8,79 @@ including reading, writing, and conversion between these and other font formats.
 WOFF is a wrapper around SFNT fonts (TTF/OTF) using zlib compression, while WOFF2
 uses Brotli compression for better compression ratios and table transformations.
 
+== W3C specification compliance
+
+Fontisan's WOFF and WOFF2 implementations are fully compliant with the
+W3C Recommendations:
+
+* **WOFF 1.0** (W3C Recommendation, 13 December 2012):
+  https://www.w3.org/TR/WOFF/[spec] — reading and writing
+* **WOFF 2.0** (W3C Recommendation, 08 August 2024):
+  https://www.w3.org/TR/WOFF2/[spec] — reading and writing
+
+=== WOFF 2.0 (spec section references below)
+
+Compliance covers every normative requirement of the WOFF2 spec:
+
+* *Section 3.2 (WOFF2 Header)*: 48-byte header with correct signature
+  (`wOF2`), flavor, file length, reserved=0, totalSfntSize,
+  totalCompressedSize, version, and meta/private offset/length fields.
+* *Section 4.1 (Table directory)*: flags byte structure (bits 0-5 tag
+  index, bits 6-7 transform version); optional 4-byte custom tag when
+  index=63; `transformLength` field present IFF table is transformed.
+* *Section 4.2 (Collection directory)*: full support for flavor=`ttcf`
+  font collections — CollectionHeader + CollectionFontEntry per font,
+  with deduplicated tables shared across fonts via directory indices.
+* *Section 5 (Compressed data)*: single Brotli stream of all tables in
+  directory order; `DSIG` table removed per encoder rule; `head.flags`
+  bit 11 set to indicate lossless modifying transform.
+* *Section 5.1 (Transformed glyf table)*: 36-byte header (uint16
+  version + uint16 optionFlags + uint16 numGlyphs + uint16 indexFormat
+  + 7 × uint32 stream sizes); 7 streams in spec order (nContour,
+  nPoints, flags, glyph, composite, bbox with bboxBitmap prefix,
+  instructions); optional overlapSimpleBitmap when optionFlags bit 0
+  is set; bboxBitmap semantics per spec (composite glyphs always have
+  explicit bbox, simple glyphs omit when calculated bbox matches,
+  empty glyphs MUST have all-zero bbox).
+* *Section 5.2 (Triplet coordinate encoding)*: variable-length
+  coordinate codec with all 128 flag index variants (1-4 byte
+  payloads based on coordinate magnitude); bit 7 = off-curve flag.
+* *Section 5.3 (Transformed loca table)*: `transformLength` MUST be 0;
+  loca data omitted from compressed stream (reconstructed by decoder
+  from glyf).
+* *Section 5.4 (Transformed hmtx table)*: optional version 1 transform
+  exploiting `lsb == xMin` redundancy.
+* *Section 5.5 (Table order constraints)*: loca MUST immediately
+  follow glyf in table directory; for collections, loca MUST
+  immediately follow its corresponding glyf with no other tables in
+  between.
+
+Validation: fontisan's WOFF2 output is verified byte-identical to
+fontTools' output for transformed glyf tables, and round-trips
+correctly through the W3C `woff2_decompress` reference tool.
+
+=== WOFF 1.0
+
+* *Section 4 (WOFF Header)*: 44-byte header with correct signature
+  (`wOFF`), flavor, length, numTables, reserved=0, totalSfntSize,
+  version, and meta/private offset/length fields.
+* *Section 5 (Table directory)*: 20-byte entries with tag, offset,
+  compLength, origLength, origChecksum. Tables sorted in input font
+  order per spec ("MUST be stored in the same order as the
+  well-formed input font").
+* *Section 6 (Font data tables)*: tables compressed individually with
+  zlib (compress2-compatible); each table 4-byte aligned and
+  zero-padded to next boundary ("MUST begin on 4-byte boundaries and
+  be zero-padded to the next 4-byte boundary").
+* *Section 7 (Extended metadata)*: optional block of XML data,
+  always zlib-compressed ("it is never stored in uncompressed form").
+* *Section 8 (Private data)*: optional block of arbitrary bytes,
+  always 4-byte aligned.
+
+Validation: fontisan's WOFF 1 output round-trips through fontTools
+without errors; all 4-byte alignment, padding, and compression
+requirements verified by spec-conformance specs.
+
 === Display WOFF/WOFF2 font information
 
 Show metadata specific to WOFF/WOFF2 fonts including version, compression details,

data/lib/fontisan/converters/woff_writer.rb

@@ -12,7 +12,8 @@ module Fontisan
     #
     # - `zlib_level` (0–9) — zlib compression level
     # - `uncompressed` (bool) — store tables uncompressed (legal per WOFF 1.0
-    #   §5.1; `compLength == origLength`)
+    #   §5.1; `compLength == origLength`). Metadata is still compressed per
+    #   spec §7 ("it is never stored in uncompressed form").
     # - `compression_threshold` (bytes) — skip compression for tables smaller
     #   than N bytes (rarely needed; keeps tiny tables uncompressed)
     # - `metadata_xml` (string) — optional metadata block
@@ -119,24 +120,35 @@ module Fontisan
 
       # Write font to WOFF binary.
       #
+      # Layout per WOFF 1.0 spec:
+      #   [header (44)] [table directory (20 × N)] [font tables, 4-byte aligned]
+      #   [optional metadata, 4-byte aligned] [optional private data, 4-byte aligned]
+      #
+      # Each font table is padded with 0-3 null bytes to a 4-byte boundary
+      # (spec §5/§6: "Font data tables in the WOFF file have the same
+      # requirement: they MUST begin on 4-byte boundaries and be zero-padded
+      # to the next 4-byte boundary"). Padding aligns the next block.
+      #
       # @param font [TrueTypeFont, OpenTypeFont] Source font
       # @param zlib_level [Integer] 0–9
-      # @param uncompressed [Boolean] skip zlib; store as-is
+      # @param uncompressed [Boolean] skip zlib; store tables as-is
       # @param compression_threshold [Integer] skip compression below N bytes
-      # @param metadata [String, nil] optional metadata XML
+      # @param metadata [String, nil] optional metadata XML (always compressed
+      #   per spec §7 — "it is never stored in uncompressed form")
       # @param private_data [String, nil] optional private data
       # @return [Hash{Symbol => String}] `{ woff_binary: <bytes> }`
       def write_font(font, zlib_level:, uncompressed:, compression_threshold:,
                      metadata: nil, private_data: nil)
-        tables_data = collect_tables_data(font)
+        tables = collect_tables_data(font)
         compressed_tables = compress_tables(
-          tables_data,
+          tables,
           zlib_level: uncompressed ? 0 : zlib_level,
           skip_compression: uncompressed,
           compression_threshold: compression_threshold,
         )
-        compressed_metadata = compress_metadata(metadata, zlib_level: zlib_level,
-                                                          skip_compression: uncompressed)
+        # Per spec §7, metadata MUST always be zlib-compressed regardless of
+        # the per-table `uncompressed` flag.
+        compressed_metadata = compress_metadata(metadata, zlib_level:)
         binary = build_woff_file(compressed_tables, font, compressed_metadata,
                                  private_data)
         { woff_binary: binary }
@@ -152,14 +164,16 @@ module Fontisan
         options.select { |k, _| names.include?(k.to_sym) }
       end
 
-      # Collect all table data from font.
+      # Collect all table data from font in input-font order (spec §6: tables
+      # MUST be stored in the same order as the well-formed input font).
       #
       # @param font [TrueTypeFont, OpenTypeFont]
       # @return [Hash<String, String>]
       def collect_tables_data(font)
-        font.table_names.to_h do |tag|
-          [tag, font.table_data[tag]]
-        end.compact
+        font.table_names.each_with_object({}) do |tag, h|
+          data = font.table_data[tag]
+          h[tag] = data if data
+        end
       end
 
       # Compress tables with zlib (or skip compression entirely).
@@ -197,71 +211,92 @@ module Fontisan
         end
       end
 
-      # Compress metadata with zlib.
+      # Compress metadata with zlib. Per spec §7, metadata MUST always be
+      # zlib-compressed — `skip_compression` is intentionally not exposed
+      # here. The zlib output is used even when it is larger than the input
+      # (e.g. tiny XML payloads where zlib header+checksum overhead exceeds
+      # any compression gain); the spec mandates compression, not optimality.
+      # Returns nil if no metadata was supplied.
       #
       # @param metadata [String, nil]
       # @param zlib_level [Integer]
-      # @param skip_compression [Boolean]
       # @return [Hash, nil]
-      def compress_metadata(metadata, zlib_level:, skip_compression:)
+      def compress_metadata(metadata, zlib_level:)
         return nil unless metadata
 
         original_length = metadata.bytesize
-        if skip_compression
-          return {
-            original_data: metadata,
-            compressed_data: metadata,
-            original_length: original_length,
-            compressed_length: original_length,
-          }
-        end
-
         compressed = Zlib::Deflate.deflate(metadata, zlib_level)
-        use_compressed = compressed.bytesize < original_length
         {
           original_data: metadata,
-          compressed_data: use_compressed ? compressed : metadata,
+          compressed_data: compressed,
           original_length: original_length,
-          compressed_length: use_compressed ? compressed.bytesize : original_length,
+          compressed_length: compressed.bytesize,
         }
       end
 
+      # Padding bytes needed to bring `length` up to a 4-byte boundary.
+      def padding_to_4(length)
+        (4 - (length % 4)) % 4
+      end
+
       # Assemble complete WOFF binary.
       #
-      # @param compressed_tables [Hash]
+      # Computes the full layout (offsets + padding) up front so the header
+      # fields (metaOffset, privOffset) point to the correct locations, then
+      # emits header → directory → tables → optional metadata → optional
+      # private data.
+      #
+      # @param compressed_tables [Hash<String, Hash>] in input-font order
       # @param font [TrueTypeFont, OpenTypeFont]
       # @param compressed_metadata [Hash, nil]
       # @param private_data [String, nil]
       # @return [String]
       def build_woff_file(compressed_tables, font, compressed_metadata,
                           private_data)
-        io = StringIO.new
-        io.set_encoding(Encoding::BINARY)
-
         header_size = 44
         num_tables = compressed_tables.length
-        table_dir_size = num_tables * 20
-        data_offset = header_size + table_dir_size
-        metadata_offset = data_offset
-        metadata_size = compressed_metadata ? compressed_metadata[:compressed_length] : 0
-        total_compressed_size = compressed_tables.values.sum do |t|
-          t[:compressed_length]
+        data_start = header_size + (num_tables * 20)
+
+        # Lay out tables in input-font order with 4-byte alignment padding.
+        # Each entry: { tag:, info:, offset:, pad_bytes: }
+        entries = []
+        cursor = data_start
+        compressed_tables.each do |tag, info|
+          pad = padding_to_4(info[:compressed_length])
+          entries << { tag:, info:, offset: cursor, pad_bytes: "\x00" * pad }
+          cursor += info[:compressed_length] + pad
         end
-        private_offset = data_offset + total_compressed_size + metadata_size
+        tables_end = cursor
+
+        metadata_size = compressed_metadata ? compressed_metadata[:compressed_length] : 0
+        # metaOffset/privOffset are 0 when their block is absent (spec §4:
+        # offsets to optional blocks; convention is 0 for "not present").
+        metadata_offset = compressed_metadata ? tables_end : 0
+        metadata_end = tables_end + metadata_size
+
         private_size = private_data ? private_data.bytesize : 0
-        total_size = private_offset + private_size
-        total_sfnt_size = compressed_tables.values.sum do |t|
-          t[:original_length]
-        end +
-          header_size + table_dir_size
+        private_offset = private_data ? metadata_end : 0
+        total_size = metadata_end + private_size
+
+        # totalSfntSize: reconstructed SFNT size with per-table 4-byte padding.
+        # spec §4: "Total size needed for the uncompressed font data, including
+        # the sfnt header, directory, and font tables (including padding)."
+        sfnt_header_size = 12
+        sfnt_dir_size = num_tables * 16
+        sfnt_tables_size = compressed_tables.values.sum do |t|
+          t[:original_length] + padding_to_4(t[:original_length])
+        end
+        total_sfnt_size = sfnt_header_size + sfnt_dir_size + sfnt_tables_size
 
+        io = StringIO.new
+        io.set_encoding(Encoding::BINARY)
         write_woff_header(
           io, font, total_size, total_sfnt_size, num_tables,
           compressed_metadata, metadata_offset, metadata_size,
           private_offset, private_size
         )
-        write_table_directory(io, compressed_tables, data_offset)
-        write_compressed_table_data(io, compressed_tables)
+        write_table_directory(io, entries)
+        write_compressed_table_data(io, entries)
         write_metadata(io, compressed_metadata) if compressed_metadata
         write_private_data(io, private_data) if private_data
 
@@ -293,25 +328,25 @@ module Fontisan
         io.write([private_size].pack("N"))             # privLength
       end
 
-      # Write table directory entries (20 bytes each).
-      def write_table_directory(io, compressed_tables, data_offset)
-        current_offset = data_offset
-        compressed_tables.sort_by { |tag, _| tag }.each do |tag, info|
+      # Write table directory entries (20 bytes each), one per laid-out entry.
+      def write_table_directory(io, entries)
+        entries.each do |e|
           checksum = Utilities::ChecksumCalculator
-            .calculate_table_checksum(info[:original_data])
-          io.write(tag)                                  # tag
-          io.write([current_offset].pack("N"))           # offset
-          io.write([info[:compressed_length]].pack("N")) # compLength
-          io.write([info[:original_length]].pack("N"))   # origLength
-          io.write([checksum].pack("N"))                 # origChecksum
-          current_offset += info[:compressed_length]
+            .calculate_table_checksum(e[:info][:original_data])
+          io.write(e[:tag])                                    # tag
+          io.write([e[:offset]].pack("N"))                     # offset
+          io.write([e[:info][:compressed_length]].pack("N"))   # compLength
+          io.write([e[:info][:original_length]].pack("N"))     # origLength
+          io.write([checksum].pack("N"))                       # origChecksum
         end
       end
 
-      # Write compressed table data, sorted by tag (matches directory order).
-      def write_compressed_table_data(io, compressed_tables)
-        compressed_tables.sort_by { |tag, _| tag }.each do |_, info|
-          io.write(info[:compressed_data])
+      # Write each table's compressed data followed by 4-byte alignment
+      # padding (spec §5/§6: tables MUST be zero-padded to next boundary).
+      def write_compressed_table_data(io, entries)
+        entries.each do |e|
+          io.write(e[:info][:compressed_data])
+          io.write(e[:pad_bytes])
         end
       end
 

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/collection_encoder.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "digest/sha2"
+
+module Fontisan
+  module Woff2
+    # Encodes a TTC/OTC font collection into WOFF2 collection format per
+    # spec section 4.2.
+    #
+    # Output layout:
+    #   [WOFF2Header (48 bytes, flavor = 'ttcf')]
+    #   [TableDirectory]              # one entry per unique table
+    #   [CollectionDirectory]         # CollectionHeader + N CollectionFontEntry
+    #   [CompressedFontData]          # single brotli stream of all tables
+    #
+    # Each font references tables via indices in its CollectionFontEntry.
+    # Identical tables across fonts share a single directory entry.
+    #
+    # Per spec section 5.5, glyf/loca pairs from the same font MUST be
+    # adjacent (loca immediately follows glyf) in the directory.
+    class CollectionEncoder
+      TTC_FLAVOR = 0x74746366 # 'ttcf'
+
+      # @param brotli_quality [Integer] 0-11
+      def initialize(brotli_quality: 11)
+        @brotli_quality = brotli_quality
+      end
+
+      # Encode an array of fonts as a WOFF2 collection.
+      #
+      # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Source fonts
+      # @return [String] WOFF2 collection binary
+      def encode_fonts(fonts)
+        raise ArgumentError, "fonts cannot be empty" if fonts.nil? || fonts.empty?
+
+        prepared = fonts.map.with_index { |font, i| prepare_font(font, i) }
+        _, font_to_ckeys = deduplicate(prepared)
+        layout = build_layout(prepared, font_to_ckeys)
+        compressed = compress_stream(layout)
+        assemble(fonts:, layout:, font_to_ckeys:, compressed:)
+      end
+
+      private
+
+      # Prepare a single font: collect tables, apply encoder rules, run
+      # glyf/loca transform. Returns a Hash:
+      #   {index:, tables: {tag ⇒ bytes}, loca_orig_length: (or nil)}
+      def prepare_font(font, index)
+        tables = {}
+        font.table_names.each do |tag|
+          data = font.table_data[tag]
+          next unless data && !data.empty?
+
+          tables[tag] = data
+        end
+
+        EncoderRules.apply!(tables)
+        loca_orig_length = apply_glyf_loca_transform!(tables, font)
+
+        { index:, tables:, loca_orig_length: }
+      end
+
+      # Apply the glyf/loca transform in place. Removes "loca" from
+      # `tables`. Returns the original loca length, or nil if not applied.
+      def apply_glyf_loca_transform!(tables, font)
+        return nil unless tables.key?("glyf") && tables.key?("loca")
+
+        maxp = font.table("maxp")
+        head = font.table("head")
+        return nil unless maxp && head
+
+        loca_orig_length = tables["loca"].bytesize
+        tables["glyf"] = GlyfLocaTransform.new(
+          glyf_data: tables["glyf"],
+          loca_data: tables["loca"],
+          num_glyphs: maxp.num_glyphs,
+          index_format: head.index_to_loc_format,
+        ).transform
+        tables.delete("loca")
+        loca_orig_length
+      end
+
+      # Deduplicate identical tables across fonts. Returns:
+      #   canonical: ckey → {tag, data}
+      #   font_to_ckeys: Array (per font) of {tag ⇒ ckey}
+      def deduplicate(prepared)
+        canonical = {}
+        font_to_ckeys = Array.new(prepared.size) { {} }
+        seen = {} # "tag:sha256" → ckey
+
+        prepared.each do |pf|
+          pf[:tables].each do |tag, data|
+            cache_key = "#{tag}:#{Digest::SHA256.digest(data)}"
+            if (existing = seen[cache_key])
+              font_to_ckeys[pf[:index]][tag] = existing
+            else
+              ckey = "#{tag}@#{pf[:index]}"
+              canonical[ckey] = { tag:, data: }
+              seen[cache_key] = ckey
+              font_to_ckeys[pf[:index]][tag] = ckey
+            end
+          end
+        end
+
+        [canonical, font_to_ckeys]
+      end
+
+      # Walk fonts in order; for each font, walk tags in spec-mandated
+      # order (glyf → loca placeholder → rest alphabetical). Each unique
+      # ckey appears once in the layout.
+      #
+      # Loca placeholders are keyed by the glyf ckey they pair with, so
+      # fonts that share a transformed glyf (via deduplication) also
+      # share the loca placeholder. Per spec section 5.5, loca MUST
+      # immediately follow glyf in the directory.
+      def build_layout(prepared, font_to_ckeys)
+        seen = {}
+        entries = []
+
+        prepared.each do |pf|
+          tags = pf[:tables].keys
+          ordered = order_tags_for_font(tags, has_loca: pf[:loca_orig_length])
+
+          ordered.each do |tag|
+            if tag == "loca_placeholder"
+              # Handled below as part of the glyf branch.
+              next
+            end
+
+            ckey = font_to_ckeys[pf[:index]][tag]
+            unless seen[ckey]
+              data = pf[:tables][tag]
+              seen[ckey] = entries.size
+              entries << {
+                ckey:, tag:,
+                data:,
+                orig_length: data.bytesize,
+                transform_length: (tag == "glyf" ? data.bytesize : nil)
+              }
+            end
+
+            # loca placeholder immediately after glyf. Tied to glyf's ckey
+            # so fonts that share a glyf also share its loca placeholder.
+            if tag == "glyf" && pf[:loca_orig_length]
+              placeholder_key = "loca_placeholder_for:#{ckey}"
+              unless seen[placeholder_key]
+                seen[placeholder_key] = entries.size
+                entries << {
+                  ckey: placeholder_key,
+                  tag: "loca",
+                  data: nil,
+                  orig_length: pf[:loca_orig_length],
+                  transform_length: 0,
+                }
+              end
+            end
+          end
+        end
+
+        entries
+      end
+
+      # Per-font tag order: glyf first, loca placeholder immediately after,
+      # rest alphabetical. Spec section 5.5.
+      def order_tags_for_font(tags, has_loca:)
+        return tags.sort unless has_loca
+
+        %w[glyf loca_placeholder] + (tags - ["glyf"]).sort
+      end
+
+      # Concatenate unique table data in directory order. Placeholder
+      # entries (loca after transform) contribute 0 bytes per spec 5.3.
+      def compress_stream(layout)
+        combined = String.new(encoding: Encoding::BINARY)
+        layout.each do |e|
+          combined << e[:data] if e[:data]
+        end
+        Utilities::BrotliWrapper.compress(combined, quality: @brotli_quality)
+      end
+
+      def assemble(fonts:, layout:, font_to_ckeys:, compressed:)
+        io = StringIO.new
+        io.set_encoding(Encoding::BINARY)
+
+        io.write("\x00" * 48) # reserve header
+        layout.each { |e| write_table_directory_entry(io, e) }
+
+        ckey_to_index = layout.each_with_index.to_h { |e, i| [e[:ckey], i] }
+        write_collection_directory(io, fonts, font_to_ckeys, ckey_to_index)
+
+        io.write(compressed)
+
+        # Pad to a 4-byte boundary. The W3C reference decoder validates that
+        # the file's `length` field matches the actual byte count, and many
+        # decoders expect a 4-byte-aligned file length for collections.
+        pad = (4 - (io.pos % 4)) % 4
+        io.write("\x00" * pad) if pad.positive?
+        total_size = io.size
+
+        io.pos = 0
+        write_header(io, num_tables: layout.size,
+                         total_compressed_size: compressed.bytesize, total_size:)
+        io.string
+      end
+
+      def write_header(io, num_tables:, total_compressed_size:, total_size:)
+        io.write([Woff2::Woff2Header::SIGNATURE].pack("N"))
+        io.write([TTC_FLAVOR].pack("N"))
+        io.write([total_size].pack("N"))
+        io.write([num_tables].pack("n"))
+        io.write([0].pack("n"))
+        io.write([0].pack("N"))                       # totalSfntSize (ref only)
+        io.write([total_compressed_size].pack("N"))
+        io.write([1].pack("n"))                       # majorVersion
+        io.write([0].pack("n"))                       # minorVersion
+        io.write([0].pack("N"))                       # metaOffset
+        io.write([0].pack("N"))                       # metaLength
+        io.write([0].pack("N"))                       # metaOrigLength
+        io.write([0].pack("N"))                       # privOffset
+        io.write([0].pack("N"))                       # privLength
+      end
+
+      def write_table_directory_entry(io, entry)
+        dir_entry = Directory::Entry.new
+        dir_entry.tag = entry[:tag]
+        dir_entry.orig_length = entry[:orig_length]
+        dir_entry.transform_length = entry[:transform_length]
+        flags = dir_entry.calculate_flags
+        io.write([flags].pack("C"))
+        io.write(entry[:tag].ljust(4, "\x00")) unless dir_entry.known_tag?
+        io.write(Directory.encode_uint_base128(entry[:orig_length]))
+        return unless dir_entry.transformed?
+
+        io.write(Directory.encode_uint_base128(entry[:transform_length] || 0))
+      end
+
+      def write_collection_directory(io, fonts, font_to_ckeys, ckey_to_index)
+        # CollectionHeader
+        io.write([0x00010000].pack("N")) # version 1.0
+        io.write(encode_255_uint16(fonts.size))
+
+        # One CollectionFontEntry per font
+        fonts.each_with_index do |font, fi|
+          font_keys = font_to_ckeys[fi]
+          glyf_ckey = font_keys["glyf"]
+          placeholder_key = glyf_ckey && "loca_placeholder_for:#{glyf_ckey}"
+          has_placeholder = ckey_to_index.key?(placeholder_key)
+          # CollectionFontEntry index list is in font's natural alphabetical
+          # order (including "loca" if a placeholder exists). The glyf/loca
+          # adjacency constraint applies to the table directory, not the
+          # entry index list per spec section 5.5.
+          ordered = font_keys.keys
+          ordered << "loca" if has_placeholder
+          ordered = ordered.sort
+
+          io.write(encode_255_uint16(ordered.size))
+          io.write([font_flavor(font)].pack("N"))
+          ordered.each do |tag|
+            ckey = font_keys[tag] || placeholder_key
+            index = ckey_to_index.fetch(ckey)
+            io.write(encode_255_uint16(index))
+          end
+        end
+      end
+
+      def font_flavor(font)
+        if font.has_table?("CFF ") || font.has_table?("CFF2")
+          Constants::SFNT_VERSION_OTTO
+        else
+          Constants::SFNT_VERSION_TRUETYPE
+        end
+      end
+
+      def encode_255_uint16(value)
+        if value < 253
+          [value].pack("C")
+        elsif value < 506
+          [253, value - 253].pack("CC")
+        elsif value < 65_536
+          [254].pack("C") + [value].pack("n")
+        else
+          [255].pack("C") + [value - 506].pack("n")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/woff2/encoder_rules.rb

@@ -52,13 +52,20 @@ module Fontisan
       # the 'flags' field of the head table ... to indicate that a recreated
       # font file was subjected to lossless modifying transform."
       #
-      # Uses the model-driven Head BinData record so the bit is set via a
+      # Also forces head.indexToLocFormat=0 when the glyf/loca tables are
+      # transformed, because Chrome's OTS only accepts WOFF2 glyf
+      # indexFormat=0 (see GlyfLocaTransform). For the reconstructed font
+      # to be self-consistent, head.indexToLocFormat must match the loca
+      # format that the decoder will produce (always short, format=0).
+      #
+      # Uses the model-driven Head BinData record so the bits are set via a
       # named attribute on a typed object, not via raw byte slicing.
       def self.mark_lossless_modifying!(table_data)
         return unless table_data.key?("head")
 
         head = Tables::Head.read(table_data["head"])
         head.flags |= Tables::Head::FLAG_LOSSLESS_MODIFYING
+        head.index_to_loc_format = 0
         table_data["head"] = head.to_binary_s
       end
     end