fontisan 0.4.35 → 0.4.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c534e6da296ea563119e164f40835bf5e794d0c7d37d4fdcd2c0e31008925410
-  data.tar.gz: be05402a2e893896e744432950d1f1e8951a59004f76ca9aacd2a9353f8d54cd
+  metadata.gz: 3957074ba3c679c22715fa1f1aabf4dbd3cc7334891f729d64988ec231237f3b
+  data.tar.gz: 18129617714b672947d8f39a88e7c06a7644e4ff12875c383321635a6e051377
 SHA512:
-  metadata.gz: 2e77ac651176f1d4b42d24ac60d41d3b371ac548438bc373b9d5f1ce44b36f187050ce9e5e5b5385cfc83732e2e40d946cfb9d3ae2ac83ad9c82a20a8cc7fc5b
-  data.tar.gz: 903c46cd5ab5631f3ae6723bdee6f6df007c0351291e1a60856da0328ddcadbedc9a21ba68717d5db5d77031bd3b5bf69a003d08e33a8654302ae72eb122c7a4
+  metadata.gz: 3315d7c7f3cd824dadcf4ecddc63319a5661ac13ebf8383dfab8f2eda3fffd2713a1a039df922d58073cc0b99615d0d608de5641f67528e48f2aa70678e5b8f1
+  data.tar.gz: 1bd98a99dc9902aeae6e5ceb3c40f16d01c7a61c16ae2c94f1c97f212602de2675602ab736545869640500dc49ac5f4bef6302bf3b43c34593071e94b513c448

data/.rubocop.yml

@@ -116,7 +116,19 @@ Style/BitwisePredicate:
   Enabled: false
 
 # Allow short math-conventional parameter names in font geometry code.
-# Point#x / Point#y are domain-standard coordinate names; renaming to
-# x_coord/y_coord adds noise without aiding readers.
+# Font geometry / binary parsing uses single-letter variables by domain
+# convention: affine matrix (a,b,c,d,e,f), loop indices (i,j,k,m,n),
+# coordinates (x,y,z), deltas (dx,dy). Renaming to 3+ chars adds noise
+# without aiding readers familiar with the math.
 Naming/MethodParameterName:
-  AllowedNames: ["x", "y", "cp", "gid", "n"]
+  AllowedNames: ["a", "b", "c", "d", "e", "f", "i", "j", "k", "m", "n",
+                 "p", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+                 "cp", "gid", "dx", "dy", "fd", "io", "id"]
+
+# Allow spec-format identifiers that match OpenType spec terminology:
+# cmap format4, format6, format12, format14 are the official names.
+# Renaming to format_4 diverges from the spec and makes docs harder
+# to cross-reference.
+Naming/VariableNumber:
+  AllowedIdentifiers: ["format0", "format4", "format6", "format12", "format14",
+                        "version1", "version2", "table1", "table2"]

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-07-11 07:11:58 UTC using RuboCop version 1.86.1.
+# on 2026-07-11 08:52:22 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
@@ -32,7 +32,7 @@ Layout/IndentationWidth:
     - 'lib/fontisan/commands/audit_command.rb'
     - 'lib/fontisan/ufo/compile/glyf_loca.rb'
 
-# Offense count: 2030
+# Offense count: 2053
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -111,7 +111,7 @@ Lint/UselessConstantScoping:
     - 'lib/fontisan/conversion_options.rb'
     - 'lib/fontisan/type1/charstrings.rb'
 
-# Offense count: 762
+# Offense count: 766
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -134,12 +134,12 @@ Metrics/CollectionLiteralLength:
     - 'lib/fontisan/type1/agl.rb'
     - 'lib/fontisan/type1/encodings.rb'
 
-# Offense count: 379
+# Offense count: 383
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
 
-# Offense count: 1034
+# Offense count: 1045
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 135
@@ -150,16 +150,28 @@ Metrics/ParameterLists:
   Max: 39
   MaxOptionalParameters: 4
 
-# Offense count: 291
+# Offense count: 294
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Enabled: false
 
-# Offense count: 209
+# Offense count: 34
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
 # AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
 Naming/MethodParameterName:
-  Enabled: false
+  Exclude:
+    - 'lib/fontisan.rb'
+    - 'lib/fontisan/conversion_options.rb'
+    - 'lib/fontisan/optimizers/subroutine_optimizer.rb'
+    - 'lib/fontisan/svg_to_glyf/geometry/affine_transform.rb'
+    - 'lib/fontisan/svg_to_glyf/geometry/transform_parser.rb'
+    - 'lib/fontisan/type1/ttf_to_type1_converter.rb'
+    - 'lib/fontisan/ufo/compile/filters/cubic_to_quadratic.rb'
+    - 'lib/fontisan/ufo/convert.rb'
+    - 'lib/fontisan/variation/optimizer.rb'
+    - 'lib/fontisan/woff2/glyf_loca_reconstruct.rb'
+    - 'lib/fontisan/woff2/glyf_loca_transform.rb'
+    - 'spec/fontisan/subset/table_strategy/cff2_spec.rb'
 
 # Offense count: 13
 # Configuration parameters: Mode, AllowedMethods, AllowedPatterns, AllowBangMethods, WaywardPredicates.
@@ -221,7 +233,7 @@ RSpec/AnyInstance:
 RSpec/ContextWording:
   Enabled: false
 
-# Offense count: 41
+# Offense count: 42
 # Configuration parameters: IgnoredMetadata.
 RSpec/DescribeClass:
   Enabled: false
@@ -237,7 +249,7 @@ RSpec/DescribeMethod:
     - 'spec/fontisan/type1/seac_expander_spec.rb'
     - 'spec/fontisan/type1_real_fonts_spec.rb'
 
-# Offense count: 1727
+# Offense count: 1729
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -315,7 +327,7 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 2151
+# Offense count: 2153
 RSpec/MultipleExpectations:
   Max: 19
 

data/TODO.improvements/README.md

@@ -11,7 +11,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 - [x] ~~[15 — CFF/CFF2 subsetter strategy](15-cff-cff2-subsetter-strategy.md)~~ ✓ Done — CFF via UFO round-trip, CFF2 via standalone INDEX filter with VStore preservation
 
 ### P1 — High-value features
-- [x] ~~[03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)~~ ✓ Done (Phase 1: identity, style, coverage, layout, provenance; Phase 2 axes: table directory validation, glyph name validation, cmap validation, OTS compatibility predictor, collection integrity; CLI `fontisan audit --validate` with profiles: default, structural, ots, layout)
+- [x] ~~[03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)~~ ✓ Done (Phase 1: identity, style, coverage, layout, provenance; Phase 2 axes: table directory, glyph names, cmap, OTS, collection integrity; Phase 3 axes: variable-font, hinting, WOFF2, format-round-trip, OpenType conformance foundation; CLI `fontisan audit --validate` with profiles: default, structural, ots, layout, variable, hinting, web, spec)
 - [x] ~~[04 — UFO composite glyph encoding](04-ufo-composite-glyph-encoding.md)~~ ✓ Done
 - [x] ~~[05 — OTF compiler real CFF charstrings](05-otf-compiler-real-cff.md)~~ ✓ Already working (discovered in PR #117 — Cff.build produces real Type 2 charstrings; stale TODO marker removed)
 

data/lib/fontisan/audit/check_registry.rb

@@ -18,10 +18,15 @@ module Fontisan
     class CheckRegistry
       PROFILES = {
         default: %i[table_directory glyph_names cmap ots_compatibility
-                    collection_integrity],
-        structural: %i[table_directory collection_integrity],
+                    collection_integrity variable_font hinting woff2_validation
+                    format_round_trip opentype_conformance],
+        structural: %i[table_directory collection_integrity opentype_conformance],
         ots: %i[ots_compatibility],
         layout: %i[glyph_names cmap],
+        variable: %i[variable_font],
+        hinting: %i[hinting],
+        web: %i[ots_compatibility woff2_validation],
+        spec: %i[opentype_conformance],
       }.freeze
 
       # @param profile [Symbol]
@@ -40,6 +45,11 @@ module Fontisan
         when :cmap then Checks::CmapCheck
         when :ots_compatibility then Checks::OtsCompatibilityCheck
         when :collection_integrity then Checks::CollectionIntegrityCheck
+        when :variable_font then Checks::VariableFontCheck
+        when :hinting then Checks::HintingCheck
+        when :woff2_validation then Checks::Woff2ValidationCheck
+        when :format_round_trip then Checks::FormatRoundTripCheck
+        when :opentype_conformance then Checks::OpenTypeConformanceCheck
         end
       end
     end

data/lib/fontisan/audit/checks/format_round_trip_check.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Audit
+    module Checks
+      # Reports fidelity discrepancies when converting between TTF and
+      # OTF outline formats. A high-fidelity conversion preserves:
+      #
+      #   - Glyph count (maxp.numGlyphs)
+      #   - Codepoint coverage (cmap Unicode mappings)
+      #   - Font identity (name table family + PostScript name)
+      #
+      # Any mismatch signals a bug in the outline converter or a data
+      # loss path. This check is the pure-Ruby replacement for `ttx`
+      # diff comparisons.
+      #
+      # Only converts in one direction (TTF→OTF for TrueType sources,
+      # OTF→TTF for CFF sources) — full round-trip would double the
+      # conversion surface without adding signal.
+      #
+      # @see Converters::OutlineConverter
+      class FormatRoundTripCheck < Check
+        # @param font [SfntFont]
+        # @return [Array<Models::ValidationReport::Issue>]
+        def self.call(font)
+          target = round_trip_target(font)
+          return [] unless target
+
+          converted_path = convert_to_temp(font, target)
+          return [] unless converted_path
+
+          converted = FontLoader.load(converted_path)
+          compare_fonts(font, converted, target)
+        rescue StandardError => e
+          [issue(severity: :warning,
+                 message: "Round-trip conversion to #{target.upcase} failed: " \
+                          "#{e.class}: #{e.message}",
+                 location: "round_trip.#{target}")]
+        ensure
+          cleanup_temp(converted_path) if converted_path
+        end
+
+        def self.code
+          :format_round_trip
+        end
+
+        # Decide the conversion target based on the source outline type.
+        # @return [Symbol, nil] :otf, :ttf, or nil if not convertible
+        def self.round_trip_target(font)
+          return :otf if font.has_table?("glyf")
+          return :ttf if font.has_table?("CFF ") || font.has_table?("CFF2")
+
+          nil
+        end
+        private_class_method :round_trip_target
+
+        def self.convert_to_temp(font, target)
+          converter = Converters::FormatConverter.new
+          tables = converter.convert(font, target)
+          return nil unless tables && !tables.empty?
+
+          dir = Dir.mktmpdir("fontisan-roundtrip-")
+          path = File.join(dir, "converted.#{target}")
+          sfnt = target == :otf ? 0x4F54544F : 0x00010000
+          FontWriter.write_to_file(
+            tables.transform_values { |t| t.is_a?(String) ? t : t.to_binary_s },
+            path,
+            sfnt_version: sfnt,
+          )
+          File.exist?(path) ? path : nil
+        rescue StandardError
+          nil
+        end
+        private_class_method :convert_to_temp
+
+        def self.compare_fonts(source, converted, target)
+          issues = []
+          issues.concat(compare_glyph_count(source, converted, target))
+          issues.concat(compare_codepoints(source, converted, target))
+          issues
+        end
+        private_class_method :compare_fonts
+
+        def self.compare_glyph_count(source, converted, target)
+          src_count = glyph_count(source)
+          dst_count = glyph_count(converted)
+          return [] if src_count == dst_count
+
+          [issue(severity: :warning,
+                 message: "Round-trip to #{target.upcase}: glyph count changed " \
+                          "from #{src_count} to #{dst_count}",
+                 location: "round_trip.#{target}.glyph_count")]
+        end
+        private_class_method :compare_glyph_count
+
+        def self.compare_codepoints(source, converted, target)
+          src_cps = codepoint_set(source)
+          dst_cps = codepoint_set(converted)
+          missing = src_cps - dst_cps
+          extra = dst_cps - src_cps
+          issues = []
+          unless missing.empty?
+            issues << issue(severity: :warning,
+                            message: "Round-trip to #{target.upcase}: #{missing.size} " \
+                                     "codepoints lost (first: " \
+                                     "#{missing.first(5).map { |c| format('U+%04X', c) }.join(', ')})",
+                            location: "round_trip.#{target}.codepoints.missing")
+          end
+          unless extra.empty?
+            issues << issue(severity: :info,
+                            message: "Round-trip to #{target.upcase}: #{extra.size} " \
+                                     "codepoints gained (first: " \
+                                     "#{extra.first(5).map { |c| format('U+%04X', c) }.join(', ')})",
+                            location: "round_trip.#{target}.codepoints.extra")
+          end
+          issues
+        end
+        private_class_method :compare_codepoints
+
+        def self.glyph_count(font)
+          return 0 unless font.has_table?("maxp")
+
+          font.table("maxp").num_glyphs.to_i
+        rescue StandardError
+          0
+        end
+        private_class_method :glyph_count
+
+        def self.codepoint_set(font)
+          return Set.new unless font.has_table?("cmap")
+
+          Set.new(font.table("cmap").unicode_mappings&.keys || [])
+        rescue StandardError
+          Set.new
+        end
+        private_class_method :codepoint_set
+
+        def self.cleanup_temp(path)
+          dir = File.dirname(path)
+          FileUtils.rm_rf(dir) if Dir.exist?(dir)
+        rescue StandardError
+          nil
+        end
+        private_class_method :cleanup_temp
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/hinting_check.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Audits font hinting configuration. Hinting quality directly
+      # affects small-size screen rendering (Windows, Android, embedded
+      # systems).
+      #
+      # TrueType (glyf outlines):
+      #   - fpgm (font program) presence recommended for hinted fonts
+      #   - prep (control value program) presence recommended
+      #   - cvt (control value table) presence recommended
+      #   - maxp.maxStackElements and maxp.maxZones must be positive
+      #     if any hinting instructions exist
+      #   - gasp table recommended for controlling grid-fitting per ppem
+      #
+      # CFF (PostScript outlines):
+      #   - Private DICT should have BlueValues or StdHW/StdVW for hinting
+      #   - Subroutine usage (Local/Global subrs) recommended for size
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/ttinst#hinting-instructions
+      class HintingCheck < Check
+        # @param font [SfntFont]
+        # @return [Array<Models::ValidationReport::Issue>]
+        def self.call(font)
+          if font.has_table?("glyf")
+            validate_truetype_hinting(font)
+          elsif font.has_table?("CFF ") || font.has_table?("CFF2")
+            validate_cff_hinting(font)
+          else
+            []
+          end
+        end
+
+        def self.code
+          :hinting
+        end
+
+        # ---------- TrueType hinting ----------
+
+        def self.validate_truetype_hinting(font)
+          issues = []
+          has_fpgm = font.has_table?("fpgm")
+          has_prep = font.has_table?("prep")
+          has_cvt = font.has_table?("cvt")
+          has_glyf_data = table_has_data?(font, "glyf")
+
+          if has_fpgm && has_glyf_data
+            issues.concat(validate_maxp_hint_capacity(font))
+          end
+
+          issues << no_program_warning("prep") if !has_prep && has_fpgm
+          issues << no_program_warning("cvt") if !has_cvt && has_fpgm
+
+          unless font.has_table?("gasp")
+            issues << issue(severity: :info,
+                            message: "TrueType font has no 'gasp' table — " \
+                                     "grid-fitting behavior per ppem is " \
+                                     "implementation-defined",
+                            location: "tables.gasp")
+          end
+
+          issues
+        end
+        private_class_method :validate_truetype_hinting
+
+        def self.validate_maxp_hint_capacity(font)
+          issues = []
+          maxp = font.table("maxp")
+          return issues unless maxp.version_1_0?
+
+          stack = maxp.max_stack_elements.to_i
+          zones = maxp.max_zones.to_i
+          if has_fpgm_instructions?(font) && stack.zero?
+            issues << issue(severity: :warning,
+                            message: "maxp.maxStackElements is 0 but the font " \
+                                     "has hinting instructions — rendering " \
+                                     "may fail",
+                            location: "maxp.max_stack_elements")
+          end
+          unless zones.between?(1, 2)
+            issues << issue(severity: :warning,
+                            message: "maxp.maxZones is #{zones} but must be 1 or 2 " \
+                                     "per the OpenType spec",
+                            location: "maxp.max_zones")
+          end
+          issues
+        end
+        private_class_method :validate_maxp_hint_capacity
+
+        def self.has_fpgm_instructions?(font)
+          table_has_data?(font, "fpgm")
+        end
+        private_class_method :has_fpgm_instructions?
+
+        def self.no_program_warning(table)
+          issue(severity: :info,
+                message: "Font has 'fpgm' but no '#{table}' table — " \
+                         "#{table == 'cvt' ? 'control values' : 'pre-program'} " \
+                         "are recommended for consistent hinting",
+                location: "tables.#{table}")
+        end
+        private_class_method :no_program_warning
+
+        # ---------- CFF hinting ----------
+
+        def self.validate_cff_hinting(font)
+          issues = []
+          tag = font.has_table?("CFF2") ? "CFF2" : "CFF "
+          cff = font.table(tag)
+          return issues unless cff
+
+          priv = begin
+            cff.private_dict(0)
+          rescue StandardError
+            nil
+          end
+          return issues unless priv
+
+          has_blues = priv_values?(priv, :blue_values) || priv_values?(priv, :other_blues)
+          has_stems = priv_value?(priv, :std_hw) || priv_value?(priv, :std_vw)
+
+          if !has_blues && !has_stems
+            issues << issue(severity: :info,
+                            message: "CFF Private DICT has no BlueValues or " \
+                                     "StdHW/StdVW — alignment zones and stem " \
+                                     "widths are the primary hinting mechanism " \
+                                     "for CFF outlines",
+                            location: "cff.private_dict")
+          end
+
+          issues
+        end
+        private_class_method :validate_cff_hinting
+
+        def self.priv_values?(priv, key)
+          val = priv[key] || priv[key.to_s]
+          val.is_a?(Array) ? val.any? : false
+        rescue StandardError
+          false
+        end
+        private_class_method :priv_values?
+
+        def self.priv_value?(priv, key)
+          val = priv[key] || priv[key.to_s]
+          val && !val.zero?
+        rescue StandardError
+          false
+        end
+        private_class_method :priv_value?
+
+        # ---------- helpers ----------
+
+        def self.table_has_data?(font, tag)
+          raw = font.table_data[tag]
+          raw && !raw.empty?
+        end
+        private_class_method :table_has_data?
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/opentype_conformance_check.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Foundational OpenType spec conformance checks. Covers the
+      # most commonly-violated "MUST" and "SHOULD" rules from the OT
+      # spec that other check domains don't already cover.
+      #
+      # This check is intentionally a growing foundation — new OT spec
+      # rules are added incrementally as real-world fonts surface them.
+      # Full OT conformance is a long-running effort that tracks the
+      # spec's evolution (axis 14 per TODO #03).
+      #
+      # Current checks:
+      #
+      #   - Required tables for each sfnt flavor (TTF vs CFF vs variable)
+      #   - head.indexToLocFormat consistency with loca table size
+      #   - name table must have at least family (1), subfamily (2),
+      #     full (4), PostScript (6) name IDs
+      #   - OS/2 fsSelection must not use reserved bits
+      #   - hhea.numberOfHMetrics must be ≤ maxp.numGlyphs
+      #   - post table version must be valid
+      #   - cmap must have at least one Unicode subtable (already
+      #     covered by CmapCheck — skipped here to avoid duplicate issues)
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/otff
+      class OpenTypeConformanceCheck < Check
+        REQUIRED_NAME_IDS = {
+          1 => "Family",
+          2 => "Subfamily",
+          4 => "Full",
+          6 => "PostScript",
+        }.freeze
+
+        # @param font [SfntFont]
+        # @return [Array<Models::ValidationReport::Issue>]
+        def self.call(font)
+          issues = []
+          issues.concat(validate_required_tables(font))
+          issues.concat(validate_loca_format(font))
+          issues.concat(validate_name_coverage(font))
+          issues.concat(validate_os2_fsselection(font))
+          issues.concat(validate_hhea_metrics(font))
+          issues
+        end
+
+        def self.code
+          :opentype_conformance
+        end
+
+        # ---------- required tables ----------
+
+        def self.validate_required_tables(font)
+          required = required_tables_for_flavor(font)
+          missing = required.reject { |tag| font.has_table?(tag) }
+          missing.map do |tag|
+            issue(severity: :error,
+                  message: "Required table '#{tag}' is missing for this " \
+                           "sfnt flavor",
+                  location: "tables.#{tag}")
+          end
+        end
+        private_class_method :validate_required_tables
+
+        def self.required_tables_for_flavor(font)
+          base = %w[head hhea maxp hmtx name post cmap OS/2]
+          if font.has_table?("glyf")
+            base + %w[glyf loca]
+          elsif font.has_table?("CFF2")
+            base + ["CFF2"]
+          elsif font.has_table?("CFF ")
+            base + ["CFF "]
+          else
+            base
+          end
+        end
+        private_class_method :required_tables_for_flavor
+
+        # ---------- loca format ----------
+
+        def self.validate_loca_format(font)
+          return [] unless font.has_table?("head") && font.has_table?("loca")
+
+          head = font.table("head")
+          loca = font.table("loca")
+          return [] unless head && loca
+
+          format = head.index_to_loc_format
+          maxp = font.table("maxp")
+          num_glyphs = maxp&.num_glyphs.to_i
+          return [] if num_glyphs.zero?
+
+          expected_size = format.zero? ? (num_glyphs + 1) * 2 : (num_glyphs + 1) * 4
+          actual_size = loca.to_binary_s.bytesize
+          return [] if actual_size == expected_size
+
+          [issue(severity: :warning,
+                 message: "loca table size (#{actual_size} bytes) doesn't match " \
+                          "head.indexToLocFormat=#{format} + numGlyphs=#{num_glyphs} " \
+                          "(expected #{expected_size} bytes)",
+                 location: "head.index_to_loc_format")]
+        end
+        private_class_method :validate_loca_format
+
+        # ---------- name table coverage ----------
+
+        def self.validate_name_coverage(font)
+          return [] unless font.has_table?("name")
+
+          name = font.table("name")
+          REQUIRED_NAME_IDS.each_with_object([]) do |(id, label), issues|
+            val = name.english_name(id).to_s
+            next unless val.empty?
+
+            issues << issue(severity: :error,
+                            message: "Required name ID #{id} (#{label}) is " \
+                                     "missing from the name table",
+                            location: "name.nameID.#{id}")
+          end
+        end
+        private_class_method :validate_name_coverage
+
+        # ---------- OS/2 fsSelection reserved bits ----------
+
+        def self.validate_os2_fsselection(font)
+          return [] unless font.has_table?("OS/2")
+
+          os2 = font.table("OS/2")
+          fs = os2.fs_selection.to_i
+          reserved_mask = 0xFC00 # bits 10-15 are reserved
+          return [] if (fs & reserved_mask).zero?
+
+          [issue(severity: :warning,
+                 message: "OS/2 fsSelection uses reserved bits " \
+                          "(value 0x#{fs.to_s(16)}, bits 10-15 must be 0)",
+                 location: "os2.fs_selection")]
+        end
+        private_class_method :validate_os2_fsselection
+
+        # ---------- hhea.numberOfHMetrics ----------
+
+        def self.validate_hhea_metrics(font)
+          return [] unless font.has_table?("hhea") && font.has_table?("maxp")
+
+          num_metrics = font.table("hhea").number_of_h_metrics.to_i
+          num_glyphs = font.table("maxp").num_glyphs.to_i
+          return [] if num_metrics.positive? && num_metrics <= num_glyphs
+
+          [issue(severity: :error,
+                 message: "hhea.numberOfHMetrics (#{num_metrics}) must be " \
+                          "between 1 and maxp.numGlyphs (#{num_glyphs})",
+                 location: "hhea.number_of_h_metrics")]
+        end
+        private_class_method :validate_hhea_metrics
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/variable_font_check.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates variable-font readiness: fvar axis invariants, named
+      # instances within ranges, companion-table presence (gvar for
+      # TrueType outlines, HVAR for horizontal metrics, STAT for OS
+      # style matching). Ports the most commonly-hit fontbakery GF-VF
+      # check subset.
+      #
+      # Only runs when the font HAS an fvar table — static fonts are
+      # skipped (returns empty issues array).
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/fvar
+      class VariableFontCheck < Check
+        # @param font [SfntFont]
+        # @return [Array<Models::ValidationReport::Issue>]
+        def self.call(font)
+          return [] unless font.has_table?("fvar")
+
+          issues = []
+          issues.concat(validate_axes(font))
+          issues.concat(validate_instances(font))
+          issues.concat(validate_companion_tables(font))
+          issues
+        end
+
+        def self.code
+          :variable_font
+        end
+
+        # ---------- fvar axes ----------
+
+        def self.validate_axes(font)
+          fvar = font.table("fvar")
+          axes = fvar.axes
+          issues = []
+
+          issues.concat(check_axis_uniqueness(axes))
+          axes.each_with_index { |axis, idx| issues.concat(check_one_axis(axis, idx)) }
+          issues
+        end
+        private_class_method :validate_axes
+
+        def self.check_axis_uniqueness(axes)
+          tags = axes.map(&:axis_tag)
+          duplicates = tags.tally.filter_map { |t, c| t if c > 1 }
+          duplicates.map do |tag|
+            issue(severity: :error,
+                  message: "Duplicate fvar axis tag '#{tag}' — axis tags " \
+                           "must be unique within a font",
+                  location: "fvar.axes.#{tag}")
+          end
+        end
+        private_class_method :check_axis_uniqueness
+
+        def self.check_one_axis(axis, idx)
+          issues = []
+          min_v = axis.min_value.to_f
+          default_v = axis.default_value.to_f
+          max_v = axis.max_value.to_f
+
+          unless min_v <= default_v && default_v <= max_v
+            issues << issue(severity: :error,
+                            message: "fvar axis '#{axis.axis_tag}' (#{idx}) has " \
+                                     "invalid range: min=#{min_v} " \
+                                     "default=#{default_v} max=#{max_v} " \
+                                     "(must be min ≤ default ≤ max)",
+                            location: "fvar.axes.#{idx}")
+          end
+
+          if axis.axis_name_id.to_i.zero?
+            issues << issue(severity: :warning,
+                            message: "fvar axis '#{axis.axis_tag}' (#{idx}) has " \
+                                     "no name ID — users cannot identify the axis",
+                            location: "fvar.axes.#{idx}.axis_name_id")
+          end
+
+          issues
+        end
+        private_class_method :check_one_axis
+
+        # ---------- fvar named instances ----------
+
+        def self.validate_instances(font)
+          fvar = font.table("fvar")
+          instances = fvar.instances || []
+          axes = fvar.axes
+
+          instances.each_with_index.with_object([]) do |(inst, idx), issues|
+            issues.concat(check_instance_ranges(inst, idx, axes))
+          end
+        end
+        private_class_method :validate_instances
+
+        def self.check_instance_ranges(inst, idx, axes)
+          issues = []
+          coords = inst[:coordinates] || inst["coordinates"] || []
+          coords.each_with_index do |coord, axis_idx|
+            next unless axes[axis_idx]
+
+            axis = axes[axis_idx]
+            min_v = axis.min_value.to_f
+            max_v = axis.max_value.to_f
+            next if coord.to_f.between?(min_v, max_v)
+
+            issues << issue(severity: :warning,
+                            message: "fvar instance #{idx} has coordinate " \
+                                     "#{coord} for axis '#{axis.axis_tag}' " \
+                                     "outside its range [#{min_v}, #{max_v}]",
+                            location: "fvar.instances.#{idx}.#{axis.axis_tag}")
+          end
+          issues
+        end
+        private_class_method :check_instance_ranges
+
+        # ---------- companion tables ----------
+
+        def self.validate_companion_tables(font)
+          issues = []
+          is_truetype = font.has_table?("glyf")
+          if is_truetype && !font.has_table?("gvar")
+            issues << issue(severity: :warning,
+                            message: "Variable TrueType font has no 'gvar' table — " \
+                                     "glyph outlines won't vary across the design space",
+                            location: "tables.gvar")
+          end
+
+          unless font.has_table?("HVAR")
+            issues << issue(severity: :warning,
+                            message: "Variable font has no 'HVAR' table — " \
+                                     "advance widths won't vary; renderers must " \
+                                     "fall back to per-glyph hmtx lookups",
+                            location: "tables.HVAR")
+          end
+
+          unless font.has_table?("STAT")
+            issues << issue(severity: :info,
+                            message: "Variable font has no 'STAT' table — " \
+                                     "OS style-matching won't work; Windows and " \
+                                     "modern font pickers rely on STAT",
+                            location: "tables.STAT")
+          end
+          issues
+        end
+        private_class_method :validate_companion_tables
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks/woff2_validation_check.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates WOFF2 (Web Open Font Format 2) wrapper structure per
+      # the W3C WOFF2 spec. Only runs when the font IS a Woff2Font —
+      # plain TTF/OTF inputs are skipped.
+      #
+      # Checks:
+      #
+      #   - Signature must be 0x774F4632 ('wOF2')
+      #   - Flavor must be a valid SFNT version
+      #   - reserved field must be 0
+      #   - major_version should be 1
+      #   - total_compressed_size must be positive
+      #   - If metadata block is present, lengths must be consistent
+      #   - num_tables must match the table directory count
+      #
+      # @see https://www.w3.org/TR/WOFF2/
+      class Woff2ValidationCheck < Check
+        WOFF2_SIGNATURE = 0x774F4632
+        VALID_FLAVORS = [
+          0x00010000, # TrueType
+          0x74727565, # 'true' (Apple TrueType)
+          0x4F54544F, # 'OTTO' (OpenType CFF)
+          0x74746366, # 'ttcf' (collection)
+        ].freeze
+
+        # @param font [Woff2Font, SfntFont]
+        # @return [Array<Models::ValidationReport::Issue>]
+        def self.call(font)
+          return [] unless woff2?(font)
+
+          header = font.header
+          issues = []
+          issues.concat(validate_signature(header))
+          issues.concat(validate_flavor(header))
+          issues.concat(validate_reserved(header))
+          issues.concat(validate_version(header))
+          issues.concat(validate_sizes(header))
+          issues.concat(validate_metadata(header))
+          issues
+        end
+
+        def self.code
+          :woff2_validation
+        end
+
+        def self.woff2?(font)
+          font.is_a?(Woff2Font)
+        end
+        private_class_method :woff2?
+
+        def self.validate_signature(header)
+          return [] if header.signature == WOFF2_SIGNATURE
+
+          [issue(severity: :error,
+                 message: "WOFF2 signature is 0x#{header.signature.to_s(16)} " \
+                          "but must be 0x#{WOFF2_SIGNATURE.to_s(16)} ('wOF2')",
+                 location: "woff2_header.signature")]
+        end
+        private_class_method :validate_signature
+
+        def self.validate_flavor(header)
+          return [] if VALID_FLAVORS.include?(header.flavor)
+
+          [issue(severity: :error,
+                 message: "WOFF2 flavor is 0x#{header.flavor.to_s(16)} " \
+                          "but must be a valid SFNT version " \
+                          "(0x00010000, 0x74727565, 0x4F54544F, or 0x74746366)",
+                 location: "woff2_header.flavor")]
+        end
+        private_class_method :validate_flavor
+
+        def self.validate_reserved(header)
+          return [] if header.reserved.zero?
+
+          [issue(severity: :warning,
+                 message: "WOFF2 reserved field is #{header.reserved} " \
+                          "but must be 0 per the spec",
+                 location: "woff2_header.reserved")]
+        end
+        private_class_method :validate_reserved
+
+        def self.validate_version(header)
+          issues = []
+          if header.major_version != 1
+            issues << issue(severity: :warning,
+                            message: "WOFF2 major version is #{header.major_version} " \
+                                     "but the spec recommends 1",
+                            location: "woff2_header.major_version")
+          end
+          issues
+        end
+        private_class_method :validate_version
+
+        def self.validate_sizes(header)
+          issues = []
+          if header.total_compressed_size.to_i <= 0
+            issues << issue(severity: :error,
+                            message: "WOFF2 total_compressed_size is " \
+                                     "#{header.total_compressed_size} but must be positive",
+                            location: "woff2_header.total_compressed_size")
+          end
+          if header.total_sfnt_size.to_i <= 0
+            issues << issue(severity: :error,
+                            message: "WOFF2 total_sfnt_size is " \
+                                     "#{header.total_sfnt_size} but must be positive",
+                            location: "woff2_header.total_sfnt_size")
+          end
+          issues
+        end
+        private_class_method :validate_sizes
+
+        def self.validate_metadata(header)
+          return [] unless header.meta_offset.to_i.positive?
+
+          issues = []
+          if header.meta_length.to_i <= 0
+            issues << issue(severity: :error,
+                            message: "WOFF2 metadata offset is set but " \
+                                     "meta_length is #{header.meta_length} " \
+                                     "(must be positive)",
+                            location: "woff2_header.meta_length")
+          end
+          if header.meta_orig_length.to_i <= 0
+            issues << issue(severity: :error,
+                            message: "WOFF2 metadata offset is set but " \
+                                     "meta_orig_length is #{header.meta_orig_length} " \
+                                     "(must be positive)",
+                            location: "woff2_header.meta_orig_length")
+          end
+          issues
+        end
+        private_class_method :validate_metadata
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks.rb

@@ -17,6 +17,14 @@ module Fontisan
                "fontisan/audit/checks/ots_compatibility_check"
       autoload :CollectionIntegrityCheck,
                "fontisan/audit/checks/collection_integrity_check"
+      autoload :VariableFontCheck, "fontisan/audit/checks/variable_font_check"
+      autoload :HintingCheck, "fontisan/audit/checks/hinting_check"
+      autoload :Woff2ValidationCheck,
+               "fontisan/audit/checks/woff2_validation_check"
+      autoload :FormatRoundTripCheck,
+               "fontisan/audit/checks/format_round_trip_check"
+      autoload :OpenTypeConformanceCheck,
+               "fontisan/audit/checks/opentype_conformance_check"
     end
   end
 end

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.35
+  version: 0.4.36
 platform: ruby
 authors:
 - Ribose Inc.
@@ -299,9 +299,14 @@ files:
 - lib/fontisan/audit/checks.rb
 - lib/fontisan/audit/checks/cmap_check.rb
 - lib/fontisan/audit/checks/collection_integrity_check.rb
+- lib/fontisan/audit/checks/format_round_trip_check.rb
 - lib/fontisan/audit/checks/glyph_name_check.rb
+- lib/fontisan/audit/checks/hinting_check.rb
+- lib/fontisan/audit/checks/opentype_conformance_check.rb
 - lib/fontisan/audit/checks/ots_compatibility_check.rb
 - lib/fontisan/audit/checks/table_directory_check.rb
+- lib/fontisan/audit/checks/variable_font_check.rb
+- lib/fontisan/audit/checks/woff2_validation_check.rb
 - lib/fontisan/base_collection.rb
 - lib/fontisan/binary.rb
 - lib/fontisan/binary/base_record.rb