fontisan 0.4.17 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b874b7ec1a441c955ee5e1a75d0477ddac875cfbb109cd4111919a94210f5ee3
-  data.tar.gz: ef33acdcc6c296877c745852032a315588da42cfa1017e885bcf41e9fd66f474
+  metadata.gz: ec589024241926918e56eb58fbe63cd2b14cc0d82fd92908337f7f2f7ef5c076
+  data.tar.gz: f3ef0a193655de4790717559c7bce5722f5d9e7b5548bc5b313cf400a3b2121d
 SHA512:
-  metadata.gz: c3ce64b5b2cdf9a2c2604a638b8aaf0c1b681f2dab67377acf61f187960c68891920026fe9474ddc334ac8c4fdc491dcbe635f99e5e4f4cc31342def2d55f3b4
-  data.tar.gz: fa84952690ed773f7b38a40059bacf1efadc591c5cd2077a56e07854682c03c28228efc5e623b248302237fa2352336834feea77fe817ab655293cd3ebda0242
+  metadata.gz: b83304cf80e5f7a55ee98717b0f3bec987ad81cef329d0f1d2ab9ab91ecd66db58f6e2ed5eada8c3b4049665e3a37240a26477dbd25405a586d1f9ca7fc7dd61
+  data.tar.gz: ebc0f3e2c752e7752452280d83e4220aabb12c23a4766e431dbc3e13b480b85b0259a929656919da42e9993a8bd2354a9283fbef21a95ba49b666c54c8d0812b

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-06-29 07:08:46 UTC using RuboCop version 1.86.1.
+# on 2026-07-07 11:03:20 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -12,84 +12,20 @@ Gemspec/RequiredRubyVersion:
     - 'docs/node_modules/speakingurl/speakingurl-rails.gemspec'
     - 'fontisan.gemspec'
 
-# Offense count: 21
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: with_first_argument, with_fixed_indentation
-Layout/ArgumentAlignment:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'lib/fontisan/hints.rb'
-    - 'lib/fontisan/models.rb'
-    - 'lib/fontisan/pipeline.rb'
-    - 'lib/fontisan/pipeline/strategies.rb'
-    - 'lib/fontisan/tables.rb'
-    - 'lib/fontisan/tables/cff.rb'
-    - 'spec/fontisan/cldr/config_spec.rb'
-    - 'spec/fontisan/cldr/unicode_set_parser_spec.rb'
-    - 'spec/fontisan/cli/cldr_cli_spec.rb'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyleAlignWith.
-# SupportedStylesAlignWith: either, start_of_block, start_of_line
-Layout/BlockAlignment:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'spec/fontisan/cldr/index_spec.rb'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-Layout/BlockEndNewline:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'spec/fontisan/cldr/index_spec.rb'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-Layout/EmptyLines:
-  Exclude:
-    - 'lib/fontisan/cli.rb'
-
-# Offense count: 4
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: Width, EnforcedStyleAlignWith, AllowedPatterns.
-# SupportedStylesAlignWith: start_of_line, relative_to_receiver
-Layout/IndentationWidth:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'spec/fontisan/cldr/index_spec.rb'
-
-# Offense count: 1641
+# Offense count: 2090
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 21
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: AllowInHeredoc.
-Layout/TrailingWhitespace:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'lib/fontisan/hints.rb'
-    - 'lib/fontisan/models.rb'
-    - 'lib/fontisan/pipeline.rb'
-    - 'lib/fontisan/pipeline/strategies.rb'
-    - 'lib/fontisan/tables.rb'
-    - 'lib/fontisan/tables/cff.rb'
-    - 'spec/fontisan/cldr/config_spec.rb'
-    - 'spec/fontisan/cldr/unicode_set_parser_spec.rb'
-    - 'spec/fontisan/cli/cldr_cli_spec.rb'
-
 # Offense count: 2
 Lint/CopDirectiveSyntax:
   Exclude:
     - 'lib/fontisan/woff2_font.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 49
+# Offense count: 52
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
 Lint/DuplicateBranch:
   Enabled: false
@@ -142,7 +78,7 @@ Lint/StructNewOverride:
   Exclude:
     - 'lib/fontisan/optimizers/pattern_analyzer.rb'
 
-# Offense count: 7
+# Offense count: 5
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: AllowUnusedKeywordArguments, IgnoreEmptyMethods, IgnoreNotImplementedMethods, NotImplementedExceptions.
 # NotImplementedExceptions: NotImplementedError
@@ -150,9 +86,7 @@ Lint/UnusedMethodArgument:
   Exclude:
     - 'lib/fontisan.rb'
     - 'lib/fontisan/tables/cff2/private_dict_blend_handler.rb'
-    - 'lib/fontisan/utilities/brotli_wrapper.rb'
     - 'lib/fontisan/variation/table_accessor.rb'
-    - 'lib/fontisan/woff2/glyf_transformer.rb'
     - 'lib/fontisan/woff_font.rb'
 
 # Offense count: 5
@@ -161,21 +95,21 @@ Lint/UselessConstantScoping:
     - 'lib/fontisan/conversion_options.rb'
     - 'lib/fontisan/type1/charstrings.rb'
 
-# Offense count: 557
+# Offense count: 703
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
 
-# Offense count: 31
+# Offense count: 36
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
   Max: 104
 
-# Offense count: 8
+# Offense count: 4
 # Configuration parameters: CountBlocks, CountModifierForms.
 Metrics/BlockNesting:
-  Max: 5
+  Max: 4
 
 # Offense count: 2
 # Configuration parameters: LengthThreshold.
@@ -184,28 +118,28 @@ Metrics/CollectionLiteralLength:
     - 'lib/fontisan/type1/agl.rb'
     - 'lib/fontisan/type1/encodings.rb'
 
-# Offense count: 308
+# Offense count: 366
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 849
+# Offense count: 977
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 135
 
-# Offense count: 24
+# Offense count: 27
 # Configuration parameters: CountKeywordArgs.
 Metrics/ParameterLists:
   Max: 39
   MaxOptionalParameters: 4
 
-# Offense count: 231
+# Offense count: 278
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
 
-# Offense count: 166
+# Offense count: 208
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
 # AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
 Naming/MethodParameterName:
@@ -248,7 +182,7 @@ Naming/VariableName:
     - 'lib/fontisan/type1/pfm_generator.rb'
     - 'lib/fontisan/type1/pfm_parser.rb'
 
-# Offense count: 111
+# Offense count: 120
 # Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers, AllowedPatterns.
 # SupportedStyles: snake_case, normalcase, non_integer
 # AllowedIdentifiers: TLS1_1, TLS1_2, capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339, x86_64
@@ -265,13 +199,13 @@ RSpec/AnyInstance:
     - 'spec/fontisan/variation/parallel_generator_spec.rb'
     - 'spec/integration/format_conversion_spec.rb'
 
-# Offense count: 128
+# Offense count: 127
 # Configuration parameters: Prefixes, AllowedPatterns.
 # Prefixes: when, with, without
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 28
+# Offense count: 38
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -287,7 +221,7 @@ RSpec/DescribeMethod:
     - 'spec/fontisan/type1/seac_expander_spec.rb'
     - 'spec/fontisan/type1_real_fonts_spec.rb'
 
-# Offense count: 1458
+# Offense count: 1660
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -364,11 +298,11 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 1902
+# Offense count: 2097
 RSpec/MultipleExpectations:
   Max: 19
 
-# Offense count: 154
+# Offense count: 157
 # Configuration parameters: AllowSubject.
 RSpec/MultipleMemoizedHelpers:
   Max: 13
@@ -396,7 +330,7 @@ RSpec/RepeatedExample:
     - 'spec/fontisan/metrics_calculator_spec.rb'
     - 'spec/fontisan/tables/os2_spec.rb'
 
-# Offense count: 23
+# Offense count: 47
 # Configuration parameters: CustomTransform, IgnoreMethods, IgnoreMetadata, InflectorPath, EnforcedInflector.
 # SupportedInflectors: default, active_support
 RSpec/SpecFilePathFormat:
@@ -417,7 +351,7 @@ RSpec/SubjectStub:
   Exclude:
     - 'spec/fontisan/variation/delta_applier_spec.rb'
 
-# Offense count: 427
+# Offense count: 422
 # Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
 RSpec/VerifiedDoubles:
   Enabled: false
@@ -427,23 +361,6 @@ Rake/MethodDefinitionInTask:
   Exclude:
     - 'Rakefile'
 
-# Offense count: 2
-Security/Open:
-  Exclude:
-    - 'Rakefile'
-
-# Offense count: 2
-# This cop supports safe autocorrection (--autocorrect).
-# Configuration parameters: EnforcedStyle, ProceduralMethods, FunctionalMethods, AllowedMethods, AllowedPatterns, AllowBracesOnProceduralOneLiners, BracesRequiredMethods.
-# SupportedStyles: line_count_based, semantic, braces_for_chaining, always_braces
-# ProceduralMethods: benchmark, bm, bmbm, create, each_with_object, measure, new, realtime, tap, with_object
-# FunctionalMethods: let, let!, subject, watch
-# AllowedMethods: lambda, proc, it
-Style/BlockDelimiters:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-    - 'spec/fontisan/cldr/index_spec.rb'
-
 # Offense count: 6
 # This cop supports safe autocorrection (--autocorrect).
 Style/ComparableClamp:
@@ -478,12 +395,6 @@ Style/HashLikeCase:
     - 'lib/fontisan/commands/unpack_command.rb'
     - 'lib/fontisan/models/validation_report.rb'
 
-# Offense count: 9
-# This cop supports safe autocorrection (--autocorrect).
-Style/MultilineIfModifier:
-  Exclude:
-    - 'lib/fontisan/cldr/unicode_set_parser.rb'
-
 # Offense count: 1
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: respond_to_missing?

data/lib/fontisan/collection/writer.rb

@@ -212,7 +212,7 @@ module Fontisan
           binary << table_info[:data]
 
           # Pad to 4-byte boundary
-          padding = calculate_padding(table_info[:data].bytesize)
+          padding = Utilities::Padding.boundary(table_info[:data])
           binary << ("\x00" * padding) if padding.positive?
         end
       end
@@ -244,26 +244,12 @@ module Fontisan
         binary << ("\x00" * padding_needed)
       end
 
-      # Calculate padding needed for 4-byte alignment
-      #
-      # @param size [Integer] Current size
-      # @return [Integer] Padding bytes needed
-      def calculate_padding(size)
-        remainder = size % 4
-        return 0 if remainder.zero?
-
-        4 - remainder
-      end
-
       # Calculate table checksum
       #
       # @param data [String] Table data
       # @return [Integer] Checksum
       def calculate_table_checksum(data)
-        # Pad to 4-byte boundary
-        padded_data = data.dup
-        padding_length = calculate_padding(data.bytesize)
-        padded_data << ("\x00" * padding_length) if padding_length.positive?
+        padded_data = Utilities::Padding.pad(data)
 
         # Sum all uint32 values
         sum = 0

data/lib/fontisan/converters/glyf_table_builder.rb

@@ -34,7 +34,7 @@ module Fontisan
           glyf_data << glyph_data
 
           # Add padding to 4-byte boundary
-          padding = (4 - (glyf_data.bytesize % 4)) % 4
+          padding = Utilities::Padding.boundary(glyf_data)
           glyf_data << ("\x00" * padding) if padding.positive?
         end
 

data/lib/fontisan/converters/type1_converter.rb

@@ -571,12 +571,10 @@ module Fontisan
         data << [1000].pack("n")
 
         # Created (LONGDATETIME) - use current time
-        created_seconds = Time.now.to_i + 2_082_844_800
-        data << [created_seconds].pack("Q>")
+        data << [Tables::Head.now_longdatetime].pack("Q>")
 
         # Modified (LONGDATETIME) - use current time
-        modified_seconds = Time.now.to_i + 2_082_844_800
-        data << [modified_seconds].pack("Q>")
+        data << [Tables::Head.now_longdatetime].pack("Q>")
 
         # Bounding box (int16 each)
         data << [font_bbox[0]].pack("s>") # x_min

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)
@@ -383,19 +418,56 @@ module Fontisan
         size += 16 if glyf_transform # synthetic loca directory entry
 
         table_data.each_value do |data|
-          size += data.bytesize
-          size += (4 - (data.bytesize % 4)) % 4 # pad to 4-byte boundary
+          size += Utilities::Padding.aligned_size(data)
         end
 
         if glyf_transform
           loca_len = glyf_transform[:loca_orig_length]
-          size += loca_len
-          size += (4 - (loca_len % 4)) % 4
+          size += Utilities::Padding.aligned_size(loca_len)
         end
 
         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
@@ -430,6 +502,12 @@ module Fontisan
         end
 
         woff2_data << compressed_data
+        # Per WOFF2 spec section 5.3, the table directory + compressed
+        # font block MUST be padded with null bytes so the total file
+        # length is a multiple of 4. fontTools' WOFF2Writer does the
+        # same: `pad(directory + compressedFont, size=4)`.
+        pad = Utilities::Padding.boundary(woff2_data)
+        woff2_data << ("\x00" * pad) if pad.positive?
         update_woff2_length!(woff2_data)
         woff2_data
       end

data/lib/fontisan/converters/woff_writer.rb

@@ -234,11 +234,6 @@ module Fontisan
         }
       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.
       #
       # Computes the full layout (offsets + padding) up front so the header
@@ -262,7 +257,7 @@ module Fontisan
         entries = []
         cursor = data_start
         compressed_tables.each do |tag, info|
-          pad = padding_to_4(info[:compressed_length])
+          pad = Utilities::Padding.boundary(info[:compressed_length])
           entries << { tag:, info:, offset: cursor, pad_bytes: "\x00" * pad }
           cursor += info[:compressed_length] + pad
         end
@@ -284,7 +279,7 @@ module Fontisan
         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])
+          Utilities::Padding.aligned_size(t[:original_length])
         end
         total_sfnt_size = sfnt_header_size + sfnt_dir_size + sfnt_tables_size
 

data/lib/fontisan/font_writer.rb

@@ -165,7 +165,7 @@ module Fontisan
         checksum = calculate_table_checksum(data)
 
         # Calculate padding to 4-byte boundary
-        padding_length = (4 - (data.bytesize % 4)) % 4
+        padding_length = Utilities::Padding.boundary(data)
         padding = "\0" * padding_length
 
         entries << {
@@ -235,10 +235,7 @@ module Fontisan
     # @param data [String] Table binary data
     # @return [Integer] Table checksum
     def calculate_table_checksum(data)
-      # Pad to 4-byte boundary
-      padded_data = data.dup
-      padding_length = (4 - (data.bytesize % 4)) % 4
-      padded_data << ("\0" * padding_length) if padding_length.positive?
+      padded_data = Utilities::Padding.pad(data)
 
       # Sum all uint32 values
       sum = 0
@@ -285,10 +282,7 @@ module Fontisan
     # @param data [String] Complete font binary
     # @return [Integer] Font checksum
     def calculate_font_checksum(data)
-      # Pad to 4-byte boundary
-      padded_data = data.dup
-      padding_length = (4 - (data.bytesize % 4)) % 4
-      padded_data << ("\0" * padding_length) if padding_length.positive?
+      padded_data = Utilities::Padding.pad(data)
 
       # Sum all uint32 values
       sum = 0

data/lib/fontisan/sfnt_builder.rb

@@ -34,7 +34,7 @@ module Fontisan
       records = tables.map do |tag, data|
         length = data.bytesize
         checksum = Utilities::ChecksumCalculator.calculate_table_checksum(data)
-        padding = (4 - (length % 4)) % 4
+        padding = Utilities::Padding.boundary(length)
         record = { tag:, checksum:, offset: cursor, length:, data:, padding: }
         cursor += length + padding
         record

data/lib/fontisan/sfnt_font.rb

@@ -714,7 +714,7 @@ module Fontisan
         io.write(data)
 
         # Add padding to align to 4-byte boundary
-        padding = (Constants::TABLE_ALIGNMENT - (io.pos % Constants::TABLE_ALIGNMENT)) % Constants::TABLE_ALIGNMENT
+        padding = Utilities::Padding.boundary(io.pos)
         io.write(PADDING_BYTES[0, padding]) if padding.positive?
 
         # Zero out checksumAdjustment field in head table

data/lib/fontisan/tables/head.rb

@@ -28,6 +28,12 @@ module Fontisan
       # rejects WOFF2 files where it is not set.
       FLAG_LOSSLESS_MODIFYING = 0x0800
 
+      # Difference between 1904-01-01 00:00:00 UTC (Mac epoch, used by
+      # LONGDATETIME fields) and 1970-01-01 00:00:00 UTC (Unix epoch).
+      # Single source of truth for converting between the two — head's
+      # created/modified fields are LONGDATETIME.
+      MAC_EPOCH_OFFSET = 2_082_844_800
+
       # Version as 16.16 fixed-point (stored as int32)
       int32 :version_raw
 
@@ -73,14 +79,14 @@ module Fontisan
       #
       # @return [Time] Creation time
       def created
-        longdatetime_to_time(created_raw)
+        self.class.longdatetime_to_time(created_raw)
       end
 
       # Convert modified timestamp to Time object
       #
       # @return [Time] Modification time
       def modified
-        longdatetime_to_time(modified_raw)
+        self.class.longdatetime_to_time(modified_raw)
       end
 
       # Validate that the magic number is correct
@@ -150,6 +156,26 @@ module Fontisan
         glyph_data_format.zero?
       end
 
+      # Current wall clock time as a LONGDATETIME integer (seconds since
+      # Mac epoch). Used wherever a `created`/`modified` timestamp needs
+      # to be set to a meaningful "now" value (WOFF2 encoder, Type 1
+      # converter, UFO compile fallback).
+      #
+      # @return [Integer] Seconds since 1904-01-01 00:00:00 UTC
+      def self.now_longdatetime
+        to_longdatetime(Time.now)
+      end
+
+      # Convert a Unix-epoch `Time` (or Integer seconds) to a LONGDATETIME
+      # integer (Mac-epoch seconds). Symmetric with `#longdatetime_to_time`
+      # — pair them whenever you convert across the epoch boundary.
+      #
+      # @param time [Time, Integer] Unix-epoch time, default `Time.now`
+      # @return [Integer] Seconds since 1904-01-01 00:00:00 UTC
+      def self.to_longdatetime(time = Time.now)
+        time.to_i + MAC_EPOCH_OFFSET
+      end
+
       # Validate magic number and raise error if invalid
       #
       # @raise [Fontisan::CorruptedTableError] If magic number is invalid
@@ -167,15 +193,12 @@ module Fontisan
       # Alias for backward compatibility
       alias validate! validate_magic_number!
 
-      private
-
       # Convert LONGDATETIME to Ruby Time
       #
       # @param seconds [Integer] Seconds since 1904-01-01 00:00:00
       # @return [Time] Ruby Time object
-      def longdatetime_to_time(seconds)
-        # Difference between 1904 and 1970 (Unix epoch) is 2082844800 seconds
-        Time.at(seconds - 2_082_844_800)
+      def self.longdatetime_to_time(seconds)
+        Time.at(seconds - MAC_EPOCH_OFFSET)
       end
     end
   end

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

@@ -14,8 +14,6 @@ module Fontisan
         LOCA_FORMAT_SHORT = 0
         LOCA_FORMAT_LONG = 1
         MAC_STYLE_REGULAR = 0
-        # Seconds between 1904-01-01 (Mac epoch) and 1970-01-01 (Unix epoch)
-        MAC_EPOCH_OFFSET = 2_082_844_800
 
         # @param font [Fontisan::Ufo::Font]
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] (unused here;
@@ -76,7 +74,7 @@ module Fontisan
         # OpenType head.created/modified are LONGDATETIME seconds
         # since 1904-01-01. If the UFO field is absent, use now.
         def self.time_to_longdatetime(value)
-          return Time.now.to_i + MAC_EPOCH_OFFSET if value.nil?
+          return Tables::Head.now_longdatetime if value.nil?
 
           require "time"
           parsed = nil
@@ -89,7 +87,7 @@ module Fontisan
               parsed = Time.now
             end
           end
-          parsed.to_i + MAC_EPOCH_OFFSET
+          Tables::Head.to_longdatetime(parsed)
         end
         private_class_method :time_to_longdatetime
       end

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/utilities/padding.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Utilities
+    # Stateless helpers for SFNT byte-alignment padding.
+    #
+    # OpenType and WOFF/WOFF2 require table data and certain directory
+    # blocks to be aligned to 4-byte boundaries with trailing null
+    # bytes. The same `(N - (size % N)) % N` arithmetic was duplicated
+    # across nine call sites before extraction; this module is the
+    # single source of truth.
+    #
+    # @example Get padding length
+    #   Padding.boundary(13)              # => 3
+    #   Padding.boundary(13, boundary: 4) # => 3
+    #   Padding.boundary(16, boundary: 4) # => 0
+    #
+    # @example Get padded bytes
+    #   Padding.pad("abc")               # => "abc\x00"
+    #   Padding.pad("abcd")              # => "abcd"
+    module Padding
+      # Count of trailing pad bytes needed to align `size` to `boundary`.
+      #
+      # @param size [Integer, #bytesize] Either an Integer size, or any
+      #   object responding to `#bytesize` (e.g. a String).
+      # @param boundary [Integer] Alignment boundary in bytes (default
+      #   `Constants::TABLE_ALIGNMENT`).
+      # @return [Integer] Number of pad bytes in 0...boundary-1
+      def self.boundary(size, boundary: Constants::TABLE_ALIGNMENT)
+        length = size.respond_to?(:bytesize) ? size.bytesize : size
+        (boundary - (length % boundary)) % boundary
+      end
+
+      # Return `bytes` followed by null padding to the requested boundary.
+      #
+      # @param bytes [String] Binary string to pad.
+      # @param boundary [Integer] Alignment boundary in bytes.
+      # @return [String] The original string if already aligned, else a
+      #   new binary string with trailing nulls.
+      def self.pad(bytes, boundary: Constants::TABLE_ALIGNMENT)
+        pad_count = boundary(bytes, boundary:)
+        return bytes if pad_count.zero?
+
+        out = bytes.dup.force_encoding(Encoding::BINARY)
+        out << ("\x00" * pad_count)
+        out
+      end
+
+      # Aligned size of `size` after padding to `boundary`.
+      #
+      # @param size [Integer, #bytesize] Original size or bytes-like.
+      # @param boundary [Integer] Alignment boundary in bytes.
+      # @return [Integer] Size after alignment (multiple of `boundary`).
+      def self.aligned_size(size, boundary: Constants::TABLE_ALIGNMENT)
+        length = size.respond_to?(:bytesize) ? size.bytesize : size
+        length + boundary(length, boundary:)
+      end
+    end
+  end
+end

data/lib/fontisan/utilities.rb

@@ -6,5 +6,6 @@ module Fontisan
   module Utilities
     autoload :BrotliWrapper, "fontisan/utilities/brotli_wrapper"
     autoload :ChecksumCalculator, "fontisan/utilities/checksum_calculator"
+    autoload :Padding, "fontisan/utilities/padding"
   end
 end

data/lib/fontisan/variable/table_updater.rb

@@ -168,9 +168,7 @@ module Fontisan
         _old_modified = io.read(8) # Skip old modified timestamp
         rest = io.read # Remaining data
 
-        # Convert Time to LONGDATETIME (seconds since 1904-01-01)
-        # Difference between 1904 and 1970 (Unix epoch) is 2082844800 seconds
-        longdatetime = timestamp.to_i + 2_082_844_800
+        longdatetime = Tables::Head.to_longdatetime(timestamp)
 
         # Build updated head binary
         output = String.new(encoding: Encoding::BINARY)

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.17"
+  VERSION = "0.4.19"
 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,45 @@ 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
+
+      # Set head.modified to the current time.
+      #
+      # Chrome's OTS rejects WOFF2 fonts whose head.modified is not
+      # meaningfully later than head.created. Source fonts frequently
+      # carry modified == created (or modified within seconds of it),
+      # which Chrome rejects. Setting modified to the actual current
+      # wall-clock time matches fontTools' behaviour (it sets
+      # head.modified = timestampNow() on every save) and gives Chrome
+      # a delta large enough to accept.
+      #
+      # 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"])
+        head.modified_raw = Tables::Head.now_longdatetime
+        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,106 @@
+# frozen_string: true
+
+module Fontisan
+  module Woff2
+    # Computes `head.checksumAdjustment` for the SFNT the WOFF2 decoder
+    # reconstructs at runtime.
+    #
+    # Per OpenType spec ("Calculating Checksums"), checksumAdjustment
+    # must be set so 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.).
+    #
+    # Delegates the per-table uint32 sum to {Utilities::ChecksumCalculator}
+    # — that is the single source of truth for the OpenType checksum
+    # algorithm. This class orchestrates the per-table layout: building
+    # the offset table + table directory bytes, zeroing head's
+    # checksumAdjustment field for its own checksum per spec, then
+    # subtracting the total from the magic.
+    class SfntChecksum
+      # Per-table data the checksum is computed over.
+      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
+        Utilities::ChecksumCalculator.calculate_adjustment(total_checksum)
+      end
+
+      private
+
+      # Whole-SFNT checksum with head.checksumAdjustment treated as 0
+      # (per spec, head's own checksum field uses that placeholder).
+      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
+        Utilities::ChecksumCalculator.calculate_table_checksum(offset_table_bytes)
+      end
+
+      def offset_table_bytes
+        n = @tables.size
+        search_range = (2**Integer(Math.log2(n))) * 16
+        entry_selector = Integer(Math.log2(n))
+        range_shift = n * 16 - search_range
+        [@flavor, n, search_range, entry_selector, range_shift]
+          .pack("I>S>S>S>S>")
+          .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
+        Utilities::ChecksumCalculator.calculate_table_checksum(directory_bytes)
+      end
+
+      def directory_bytes
+        cursor = offset_table_bytes.bytesize + @tables.size * 16
+        offsets = {}
+        @tables.each do |t|
+          offsets[t.tag] = cursor
+          cursor += Utilities::Padding.aligned_size(t.bytes)
+        end
+
+        bytes = String.new(encoding: Encoding::BINARY)
+        @tables.each do |t|
+          bytes << t.tag.encode(Encoding::BINARY).ljust(4, " ")
+          bytes << [per_table_checksum(t)].pack("I>")
+          bytes << [offsets[t.tag]].pack("I>")
+          bytes << [t.bytes.bytesize].pack("I>")
+        end
+        bytes
+      end
+
+      # OpenType per-table checksum. The head table's checksumAdjustment
+      # field (offset 8-11) is treated as zero per spec.
+      def per_table_checksum(table)
+        data = table.bytes
+        if table.tag == "head"
+          data = "#{data.byteslice(0, 8)}#{['00000000'].pack('H8')}#{data.byteslice(12..)}"
+        end
+        Utilities::ChecksumCalculator.calculate_table_checksum(data)
+      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.19
 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
@@ -673,6 +673,7 @@ files:
 - lib/fontisan/utilities.rb
 - lib/fontisan/utilities/brotli_wrapper.rb
 - lib/fontisan/utilities/checksum_calculator.rb
+- lib/fontisan/utilities/padding.rb
 - lib/fontisan/utils.rb
 - lib/fontisan/utils/thread_pool.rb
 - lib/fontisan/validation.rb
@@ -723,10 +724,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