fontisan 0.4.36 → 0.4.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3957074ba3c679c22715fa1f1aabf4dbd3cc7334891f729d64988ec231237f3b
-  data.tar.gz: 18129617714b672947d8f39a88e7c06a7644e4ff12875c383321635a6e051377
+  metadata.gz: aebdd37610f8ce36210375f348bd5a0f1aea12d0a12c951005d018e64cac290c
+  data.tar.gz: 33e81566249885ae646e91e727abedff605619e6deb30f742fcf1dff570cd641
 SHA512:
-  metadata.gz: 3315d7c7f3cd824dadcf4ecddc63319a5661ac13ebf8383dfab8f2eda3fffd2713a1a039df922d58073cc0b99615d0d608de5641f67528e48f2aa70678e5b8f1
-  data.tar.gz: 1bd98a99dc9902aeae6e5ceb3c40f16d01c7a61c16ae2c94f1c97f212602de2675602ab736545869640500dc49ac5f4bef6302bf3b43c34593071e94b513c448
+  metadata.gz: 8e43a54dc2421202b7d780e10e37fb4b363c835d261257677728dd99602f6df0190414c1ed59c0d5c331e8b977d75326961f05b5cea2f7c32431c9cee39c094b
+  data.tar.gz: cce7fd930ab3d5da138c0f4756468b0494f21b7dcf0b515df5e38498770493a399fa10d862c5e2948efc35dfcae84c8a937ad5d8209ed1eddd4a033491934c37

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, 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] ~~[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; Phase 3 axis 14 (full OT conformance): cross-table conformance + per-table checks for head, hhea, maxp, OS/2, name, post, kern, CFF/CFF2, glyf, GSUB/GPOS layout; CLI `fontisan audit --validate` with 20 checks across 9 profiles; CI exit codes via `--fail-on-error`; profile discovery via `--list-profiles`; audit summary model with error/warning/info counts)
 - [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

@@ -16,17 +16,25 @@ module Fontisan
     # @example Run a specific profile
     #   CheckRegistry.for(:ots)      # => [OtsCompatibilityCheck]
     class CheckRegistry
+      # Per-table OT conformance checks (axis 14 — full OT spec coverage).
+      OT_TABLE_CHECKS = %i[ot_head ot_hhea ot_maxp ot_os2 ot_name ot_post
+                           ot_kern ot_cff ot_glyf ot_layout].freeze
+
       PROFILES = {
         default: %i[table_directory glyph_names cmap ots_compatibility
                     collection_integrity variable_font hinting woff2_validation
-                    format_round_trip opentype_conformance],
+                    format_round_trip opentype_conformance
+                    ot_head ot_hhea ot_maxp ot_os2 ot_name ot_post ot_kern
+                    ot_cff ot_glyf ot_layout],
         structural: %i[table_directory collection_integrity opentype_conformance],
         ots: %i[ots_compatibility],
-        layout: %i[glyph_names cmap],
+        layout: %i[glyph_names cmap ot_layout],
         variable: %i[variable_font],
         hinting: %i[hinting],
         web: %i[ots_compatibility woff2_validation],
-        spec: %i[opentype_conformance],
+        spec: %i[opentype_conformance ot_head ot_hhea ot_maxp ot_os2
+                 ot_name ot_post ot_kern ot_cff ot_glyf ot_layout],
+        per_table: OT_TABLE_CHECKS,
       }.freeze
 
       # @param profile [Symbol]
@@ -50,6 +58,16 @@ module Fontisan
         when :woff2_validation then Checks::Woff2ValidationCheck
         when :format_round_trip then Checks::FormatRoundTripCheck
         when :opentype_conformance then Checks::OpenTypeConformanceCheck
+        when :ot_head then Checks::HeadCheck
+        when :ot_hhea then Checks::HheaCheck
+        when :ot_maxp then Checks::MaxpCheck
+        when :ot_os2 then Checks::Os2Check
+        when :ot_name then Checks::NameTableCheck
+        when :ot_post then Checks::PostCheck
+        when :ot_kern then Checks::KernCheck
+        when :ot_cff then Checks::CffTableCheck
+        when :ot_glyf then Checks::GlyfTableCheck
+        when :ot_layout then Checks::LayoutTableCheck
         end
       end
     end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates CFF/CFF2 table structure: header version, Name INDEX
+      # presence (CFF1), Top DICT CharStrings offset, CharStrings count
+      # vs maxp.numGlyphs.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
+      class CffTableCheck < Check
+        def self.call(font)
+          if font.has_table?("CFF2")
+            validate_cff2(font)
+          elsif font.has_table?("CFF ")
+            validate_cff1(font)
+          else
+            []
+          end
+        end
+
+        def self.code
+          :ot_cff
+        end
+
+        # ---------- CFF1 ----------
+
+        def self.validate_cff1(font)
+          cff = font.table("CFF ")
+          return [] unless cff
+
+          issues = []
+          issues.concat(validate_cff1_name_index(cff))
+          issues.concat(validate_charstrings_count(cff, font, "CFF "))
+          issues
+        end
+        private_class_method :validate_cff1
+
+        def self.validate_cff1_name_index(cff)
+          count = cff.font_count.to_i
+          return [] if count.positive?
+
+          [issue(severity: :error,
+                 message: "CFF Name INDEX is empty — must contain at least " \
+                          "one font name",
+                 location: "cff.name_index")]
+        end
+        private_class_method :validate_cff1_name_index
+
+        # ---------- CFF2 ----------
+
+        def self.validate_cff2(font)
+          cff2 = font.table("CFF2")
+          return [] unless cff2
+
+          validate_charstrings_count(cff2, font, "CFF2")
+        end
+        private_class_method :validate_cff2
+
+        # ---------- shared ----------
+
+        def self.validate_charstrings_count(cff, font, table_tag)
+          return [] unless font.has_table?("maxp")
+
+          cs_count = glyph_count_from_cff(cff)
+          maxp_count = font.table("maxp").num_glyphs.to_i
+          return [] if cs_count == maxp_count
+
+          [issue(severity: :error,
+                 message: "#{table_tag} CharStrings count (#{cs_count}) does " \
+                          "not match maxp.numGlyphs (#{maxp_count})",
+                 location: "#{table_tag.downcase}.charstrings")]
+        end
+        private_class_method :validate_charstrings_count
+
+        def self.glyph_count_from_cff(cff)
+          cs_index = cff.charstrings_index(0)
+          cs_index&.count.to_i
+        rescue StandardError
+          0
+        end
+        private_class_method :glyph_count_from_cff
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'glyf' table: simple glyph contour integrity and
+      # compound glyph reference bounds. Only runs on TrueType fonts.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/glyf
+      class GlyfTableCheck < Check
+        MAX_COMPOUND_DEPTH = 16
+
+        def self.call(font)
+          return [] unless font.has_table?("glyf") && font.has_table?("loca")
+
+          issues = []
+          issues.concat(validate_glyph_counts(font))
+          issues
+        end
+
+        def self.code
+          :ot_glyf
+        end
+
+        # Verify loca offsets are monotonically non-decreasing and
+        # within the glyf table bounds. Discontinuities signal
+        # corruption that renderers may reject.
+        def self.validate_glyph_counts(font)
+          glyf = font.table("glyf")
+          return [] unless glyf
+
+          raw = font.table_data["glyf"]
+          return [] unless raw
+
+          issues = []
+          maxp = font.table("maxp")
+          num_glyphs = maxp&.num_glyphs.to_i
+          return [] if num_glyphs.zero?
+
+          num_glyphs.times do |gid|
+            issues.concat(validate_one_glyph(font, gid))
+          rescue StandardError
+            issues << issue(severity: :warning,
+                            message: "glyf: failed to validate glyph at GID " \
+                                     "#{gid}",
+                            location: "glyf.glyph.#{gid}")
+          end
+          issues
+        end
+        private_class_method :validate_glyph_counts
+
+        def self.validate_one_glyph(font, gid)
+          head = font.table("head")
+          loca = font.table("loca")
+          glyf = font.table("glyf")
+
+          raw = begin
+            glyf.glyph_for(gid, loca, head)
+          rescue StandardError
+            nil
+          end
+          return [] unless raw
+
+          if raw.simple?
+            validate_simple_glyph(raw, gid)
+          elsif raw.compound?
+            validate_compound_glyph(raw, gid, font)
+          else
+            []
+          end
+        end
+        private_class_method :validate_one_glyph
+
+        def self.validate_simple_glyph(raw, gid)
+          issues = []
+          end_pts = raw.end_pts_of_contours
+          return [] unless end_pts&.any?
+
+          # endPtsOfContours must be monotonically increasing
+          end_pts.each_cons(2) do |prev, curr|
+            next unless curr <= prev
+
+            issues << issue(severity: :error,
+                            message: "glyf glyph #{gid}: contour endPoints " \
+                                     "are not monotonically increasing " \
+                                     "(#{prev} → #{curr})",
+                            location: "glyf.glyph.#{gid}.contours")
+            break
+          end
+          issues
+        end
+        private_class_method :validate_simple_glyph
+
+        def self.validate_compound_glyph(raw, gid, font)
+          issues = []
+          maxp = font.table("maxp")
+          max_gid = maxp&.num_glyphs.to_i - 1
+
+          raw.components.each do |comp|
+            ref_gid = comp.glyph_index.to_i
+            next if ref_gid.between?(0, max_gid)
+
+            issues << issue(severity: :error,
+                            message: "glyf compound glyph #{gid} references " \
+                                     "out-of-bounds GID #{ref_gid} " \
+                                     "(max: #{max_gid})",
+                            location: "glyf.glyph.#{gid}.component.#{ref_gid}")
+          end
+          issues
+        end
+        private_class_method :validate_compound_glyph
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'head' table per the OpenType spec.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/head
+      class HeadCheck < Check
+        HEAD_MAGIC = 0x5F0F3CF5
+        MIN_UPM = 16
+        MAX_UPM = 16_384
+        MAC_STYLE_DEFINED_BITS = 0x00FF
+        MAC_STYLE_RESERVED_BITS = 0xFF00
+
+        def self.call(font)
+          return [] unless font.has_table?("head")
+
+          head = font.table("head")
+          issues = []
+          issues.concat(validate_magic(head))
+          issues.concat(validate_upm(head))
+          issues.concat(validate_loc_format(head))
+          issues.concat(validate_dates(head))
+          issues.concat(validate_mac_style(head))
+          issues
+        end
+
+        def self.code
+          :ot_head
+        end
+
+        def self.validate_magic(head)
+          return [] if head.magic_number == HEAD_MAGIC
+
+          [issue(severity: :error,
+                 message: "head.magicNumber is 0x#{head.magic_number.to_i.to_s(16)} " \
+                          "but must be 0x#{HEAD_MAGIC.to_s(16)}",
+                 location: "head.magic_number")]
+        end
+        private_class_method :validate_magic
+
+        def self.validate_upm(head)
+          upm = head.units_per_em.to_i
+          return [] if upm.between?(MIN_UPM, MAX_UPM)
+
+          [issue(severity: :error,
+                 message: "head.unitsPerEm is #{upm} but must be between " \
+                          "#{MIN_UPM} and #{MAX_UPM}",
+                 location: "head.units_per_em")]
+        end
+        private_class_method :validate_upm
+
+        def self.validate_loc_format(head)
+          fmt = head.index_to_loc_format.to_i
+          return [] if [0, 1].include?(fmt)
+
+          [issue(severity: :error,
+                 message: "head.indexToLocFormat is #{fmt} but must be 0 " \
+                          "(short) or 1 (long)",
+                 location: "head.index_to_loc_format")]
+        end
+        private_class_method :validate_loc_format
+
+        def self.validate_dates(head)
+          issues = []
+          if head.created_raw.to_i.zero?
+            issues << issue(severity: :info,
+                            message: "head.created is 0 — creation date not set",
+                            location: "head.created")
+          end
+          if head.modified_raw.to_i.zero?
+            issues << issue(severity: :info,
+                            message: "head.modified is 0 — modification date not set",
+                            location: "head.modified")
+          end
+          issues
+        end
+        private_class_method :validate_dates
+
+        def self.validate_mac_style(head)
+          style = head.mac_style.to_i
+          issues = []
+          unless (style & MAC_STYLE_RESERVED_BITS).zero?
+            issues << issue(severity: :warning,
+                            message: "head.macStyle uses reserved bits " \
+                                     "(0x#{style.to_s(16)}, bits 8-15 must be 0)",
+                            location: "head.mac_style")
+          end
+          issues
+        end
+        private_class_method :validate_mac_style
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'hhea' table per the OpenType spec.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hhea
+      class HheaCheck < Check
+        def self.call(font)
+          return [] unless font.has_table?("hhea")
+
+          hhea = font.table("hhea")
+          issues = []
+          issues.concat(validate_ascent(hhea))
+          issues.concat(validate_descent(hhea))
+          issues.concat(validate_line_gap(hhea))
+          issues.concat(validate_advance_width_max(hhea))
+          issues
+        end
+
+        def self.code
+          :ot_hhea
+        end
+
+        def self.validate_ascent(hhea)
+          return [] if hhea.ascent.to_i.positive?
+
+          [issue(severity: :warning,
+                 message: "hhea.ascent is #{hhea.ascent} but should be positive " \
+                          "(ascender typically rises above the baseline)",
+                 location: "hhea.ascent")]
+        end
+        private_class_method :validate_ascent
+
+        def self.validate_descent(hhea)
+          return [] if hhea.descent.to_i <= 0
+
+          [issue(severity: :warning,
+                 message: "hhea.descent is #{hhea.descent} but should be ≤ 0 " \
+                          "(descender typically falls below the baseline)",
+                 location: "hhea.descent")]
+        end
+        private_class_method :validate_descent
+
+        def self.validate_line_gap(hhea)
+          return [] if hhea.line_gap.to_i >= 0
+
+          [issue(severity: :info,
+                 message: "hhea.lineGap is #{hhea.line_gap} — negative line " \
+                          "gap is unusual but not spec-prohibited",
+                 location: "hhea.line_gap")]
+        end
+        private_class_method :validate_line_gap
+
+        def self.validate_advance_width_max(hhea)
+          return [] unless hhea.advance_width_max.to_i <= 0
+
+          [issue(severity: :warning,
+                 message: "hhea.advanceWidthMax is #{hhea.advance_width_max} " \
+                          "but should be positive (the widest glyph advance)",
+                 location: "hhea.advance_width_max")]
+        end
+        private_class_method :validate_advance_width_max
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'kern' table if present. The kern table is
+      # deprecated by the OpenType spec — GPOS is the replacement.
+      # Many legacy fonts still ship kern; this check warns about
+      # deprecation and validates basic structure.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/kern
+      class KernCheck < Check
+        def self.call(font)
+          return [] unless font.has_table?("kern")
+
+          issues = [deprecation_warning]
+          issues.concat(validate_gpos_presence(font))
+          issues
+        end
+
+        def self.code
+          :ot_kern
+        end
+
+        def self.deprecation_warning
+          issue(severity: :warning,
+                message: "kern table is present but deprecated by the " \
+                         "OpenType spec — use GPOS instead. Some modern " \
+                         "renderers (HarfBuzz, Core Text) ignore kern",
+                location: "tables.kern")
+        end
+        private_class_method :deprecation_warning
+
+        def self.validate_gpos_presence(font)
+          return [] if font.has_table?("GPOS")
+
+          [issue(severity: :warning,
+                 message: "kern table present but no GPOS table — " \
+                          "kerning data should be migrated to a GPOS " \
+                          "'kern' feature for full renderer support",
+                 location: "tables.GPOS")]
+        end
+        private_class_method :validate_gpos_presence
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates GSUB/GPOS layout table structure: header version,
+      # ScriptList/FeatureList/LookupList offsets, and DFLT script
+      # recommendation. Only runs when layout tables are present.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/chapter2
+      class LayoutTableCheck < Check
+        def self.call(font)
+          issues = []
+          issues.concat(validate_layout_table(font, "GSUB"))
+          issues.concat(validate_layout_table(font, "GPOS"))
+          issues
+        end
+
+        def self.code
+          :ot_layout
+        end
+
+        def self.validate_layout_table(font, tag)
+          return [] unless font.has_table?(tag)
+
+          table = font.table(tag)
+          return [] unless table
+
+          issues = []
+          issues.concat(validate_scripts(table, tag))
+          issues.concat(validate_dflt_script(table, tag))
+          issues
+        end
+        private_class_method :validate_layout_table
+
+        def self.validate_scripts(table, tag)
+          scripts = begin
+            table.scripts
+          rescue StandardError
+            []
+          end
+          return [] if scripts.any?
+
+          [issue(severity: :warning,
+                 message: "#{tag} table has no script records — layout " \
+                          "rules won't apply without at least one script " \
+                          "(DFLT recommended)",
+                 location: "#{tag.downcase}.script_list")]
+        end
+        private_class_method :validate_scripts
+
+        def self.validate_dflt_script(table, tag)
+          scripts = begin
+            table.scripts
+          rescue StandardError
+            []
+          end
+          return [] if scripts.include?("DFLT")
+
+          [issue(severity: :info,
+                 message: "#{tag} table has no 'DFLT' script — fonts " \
+                          "without DFLT may not apply features to scripts " \
+                          "not explicitly listed",
+                 location: "#{tag.downcase}.script_list.DFLT")]
+        end
+        private_class_method :validate_dflt_script
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'maxp' table per the OpenType spec.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/maxp
+      class MaxpCheck < Check
+        MAX_GLYPHS = 0xFFFF
+        MAX_STACK_ELEMENTS = 1000
+
+        def self.call(font)
+          return [] unless font.has_table?("maxp")
+
+          maxp = font.table("maxp")
+          issues = []
+          issues.concat(validate_version(maxp, font))
+          issues.concat(validate_num_glyphs(maxp))
+          issues.concat(validate_hint_capacity(maxp))
+          issues
+        end
+
+        def self.code
+          :ot_maxp
+        end
+
+        def self.validate_version(maxp, font)
+          version_raw = maxp.version_raw
+          is_truetype = font.has_table?("glyf")
+          tt_version = 0x00010000 # 1.0 as Fixed 16.16
+          cff_version = 0x00005000 # 0.5 as Fixed 16.16
+          if is_truetype && version_raw != tt_version
+            [issue(severity: :error,
+                   message: "maxp.version is 0x#{version_raw.to_s(16)} but must " \
+                            "be 1.0 (0x#{tt_version.to_s(16)}) for TrueType fonts",
+                   location: "maxp.version")]
+          elsif !is_truetype && version_raw != cff_version
+            [issue(severity: :warning,
+                   message: "maxp.version is 0x#{version_raw.to_s(16)} but " \
+                            "should be 0.5 (0x#{cff_version.to_s(16)}) for " \
+                            "CFF-based fonts",
+                   location: "maxp.version")]
+          else
+            []
+          end
+        end
+        private_class_method :validate_version
+
+        def self.validate_num_glyphs(maxp)
+          n = maxp.num_glyphs.to_i
+          return [] if n.between?(1, MAX_GLYPHS)
+
+          [issue(severity: :error,
+                 message: "maxp.numGlyphs is #{n} but must be between 1 and " \
+                          "#{MAX_GLYPHS}",
+                 location: "maxp.num_glyphs")]
+        end
+        private_class_method :validate_num_glyphs
+
+        def self.validate_hint_capacity(maxp)
+          return [] unless maxp.version_1_0?
+
+          issues = []
+          zones = maxp.max_zones.to_i
+          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
+          stack = maxp.max_stack_elements.to_i
+          if stack > MAX_STACK_ELEMENTS
+            issues << issue(severity: :warning,
+                            message: "maxp.maxStackElements is #{stack} — " \
+                                     "excessively large values waste interpreter memory",
+                            location: "maxp.max_stack_elements")
+          end
+          issues
+        end
+        private_class_method :validate_hint_capacity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'name' table per the OpenType spec.
+      #
+      # Covers: required nameIDs, PostScript name character validity,
+      # version string format. Glyph-name rules are in GlyphNameCheck.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/name
+      class NameTableCheck < Check
+        REQUIRED_NAME_IDS = {
+          1 => "Family",
+          2 => "Subfamily",
+          4 => "Full",
+          6 => "PostScript",
+        }.freeze
+        PS_NAME_PATTERN = /\A[A-Za-z][A-Za-z0-9._-]*\z/
+
+        def self.call(font)
+          return [] unless font.has_table?("name")
+
+          name = font.table("name")
+          issues = []
+          issues.concat(validate_required_ids(name))
+          issues.concat(validate_ps_name(name))
+          issues.concat(validate_version_string(name))
+          issues
+        end
+
+        def self.code
+          :ot_name
+        end
+
+        def self.validate_required_ids(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_required_ids
+
+        def self.validate_ps_name(name)
+          ps = name.english_name(6).to_s
+          return [] if ps.empty? || ps.match?(PS_NAME_PATTERN)
+
+          [issue(severity: :warning,
+                 message: "PostScript name '#{ps}' contains characters outside " \
+                          "the OT spec grammar (must start with a letter, then " \
+                          "A–Z a–z 0–9 . - _)",
+                 location: "name.nameID.6")]
+        end
+        private_class_method :validate_ps_name
+
+        def self.validate_version_string(name)
+          ver = name.english_name(5).to_s
+          return [] if ver.empty?
+
+          unless ver.match?(/\AVersion\s/i)
+            return [issue(severity: :info,
+                          message: "name ID 5 (version) is '#{ver}' but should " \
+                                   "start with 'Version ' per OT spec convention",
+                          location: "name.nameID.5")]
+          end
+
+          []
+        end
+        private_class_method :validate_version_string
+      end
+    end
+  end
+end

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

@@ -3,44 +3,25 @@
 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.
+      # Foundational cross-table OpenType spec conformance checks.
+      # Per-table rules live in their own check modules
+      # ({HeadCheck}, {HheaCheck}, {Os2Check}, {NameTableCheck},
+      # {PostCheck}, {KernCheck}) to keep each concern MECE.
       #
-      # 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:
+      # This check owns the rules that span multiple tables:
       #
       #   - 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
+      #   - head.indexToLocFormat consistency with loca table byte size
       #   - 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
@@ -103,41 +84,6 @@ module Fontisan
         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)

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'OS/2' table per the OpenType spec.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/os2
+      class Os2Check < Check
+        FS_SELECTION_RESERVED = 0xFC00
+
+        def self.call(font)
+          return [] unless font.has_table?("OS/2")
+
+          os2 = font.table("OS/2")
+          issues = []
+          issues.concat(validate_weight_class(os2))
+          issues.concat(validate_width_class(os2))
+          issues.concat(validate_fs_selection(os2))
+          issues.concat(validate_typo_metrics(os2))
+          issues.concat(validate_win_metrics(os2))
+          issues.concat(validate_panose(os2))
+          issues
+        end
+
+        def self.code
+          :ot_os2
+        end
+
+        def self.validate_weight_class(os2)
+          w = os2.us_weight_class.to_i
+          return [] if w.between?(1, 1000)
+
+          [issue(severity: :error,
+                 message: "OS/2.usWeightClass is #{w} but must be between " \
+                          "1 and 1000",
+                 location: "os2.us_weight_class")]
+        end
+        private_class_method :validate_weight_class
+
+        def self.validate_width_class(os2)
+          w = os2.us_width_class.to_i
+          return [] if w.between?(1, 9)
+
+          [issue(severity: :error,
+                 message: "OS/2.usWidthClass is #{w} but must be between 1 " \
+                          "and 9",
+                 location: "os2.us_width_class")]
+        end
+        private_class_method :validate_width_class
+
+        def self.validate_fs_selection(os2)
+          fs = os2.fs_selection.to_i
+          return [] if (fs & FS_SELECTION_RESERVED).zero?
+
+          [issue(severity: :warning,
+                 message: "OS/2.fsSelection uses reserved bits " \
+                          "(0x#{fs.to_s(16)}, bits 10-15 must be 0)",
+                 location: "os2.fs_selection")]
+        end
+        private_class_method :validate_fs_selection
+
+        def self.validate_typo_metrics(os2)
+          issues = []
+          asc = os2.s_typo_ascender.to_i
+          desc = os2.s_typo_descender.to_i
+          if asc <= 0
+            issues << issue(severity: :warning,
+                            message: "OS/2.sTypoAscender is #{asc} but should " \
+                                     "be positive",
+                            location: "os2.s_typo_ascender")
+          end
+          if desc.positive?
+            issues << issue(severity: :warning,
+                            message: "OS/2.sTypoDescender is #{desc} but should " \
+                                     "be ≤ 0",
+                            location: "os2.s_typo_descender")
+          end
+          issues
+        end
+        private_class_method :validate_typo_metrics
+
+        def self.validate_win_metrics(os2)
+          issues = []
+          if os2.us_win_ascent.to_i <= 0
+            issues << issue(severity: :warning,
+                            message: "OS/2.usWinAscent is #{os2.us_win_ascent} " \
+                                     "but should be positive",
+                            location: "os2.us_win_ascent")
+          end
+          if os2.us_win_descent.to_i <= 0
+            issues << issue(severity: :warning,
+                            message: "OS/2.usWinDescent is #{os2.us_win_descent} " \
+                                     "but should be positive",
+                            location: "os2.us_win_descent")
+          end
+          issues
+        end
+        private_class_method :validate_win_metrics
+
+        def self.validate_panose(os2)
+          panose = os2.panose
+          return [] unless panose
+
+          all_zero = panose.to_a.all?(&:zero?)
+          return [] unless all_zero
+
+          [issue(severity: :info,
+                 message: "OS/2.panose is all zeros — PANOSE classification " \
+                          "helps font matching in some applications",
+                 location: "os2.panose")]
+        end
+        private_class_method :validate_panose
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Audit
+    module Checks
+      # Validates the 'post' table per the OpenType spec.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/post
+      class PostCheck < Check
+        VALID_VERSIONS = [1.0, 2.0, 2.5, 3.0, 4.0].freeze
+
+        def self.call(font)
+          return [] unless font.has_table?("post")
+
+          post = font.table("post")
+          head = font.has_table?("head") ? font.table("head") : nil
+          issues = []
+          issues.concat(validate_version(post))
+          issues.concat(validate_italic_angle(post, head))
+          issues.concat(validate_is_fixed_pitch(post))
+          issues
+        end
+
+        def self.code
+          :ot_post
+        end
+
+        def self.validate_version(post)
+          version = post.version.to_f
+          return [] if VALID_VERSIONS.include?(version)
+
+          [issue(severity: :error,
+                 message: "post.version is #{version} but must be one of " \
+                          "#{VALID_VERSIONS.join(', ')}",
+                 location: "post.version")]
+        end
+        private_class_method :validate_version
+
+        def self.validate_italic_angle(post, head)
+          angle = post.italic_angle.to_f
+          issues = []
+          if head&.mac_style
+            is_italic = (head.mac_style.to_i & 0x02).positive?
+            if is_italic && angle >= 0
+              issues << issue(severity: :warning,
+                              message: "post.italicAngle is #{angle} but " \
+                                       "head.macStyle indicates italic " \
+                                       "(angle should be negative)",
+                              location: "post.italic_angle")
+            elsif !is_italic && angle != 0
+              issues << issue(severity: :info,
+                              message: "post.italicAngle is #{angle} but " \
+                                       "head.macStyle does not indicate italic " \
+                                       "(angle should be 0)",
+                              location: "post.italic_angle")
+            end
+          end
+          issues
+        end
+        private_class_method :validate_italic_angle
+
+        def self.validate_is_fixed_pitch(post)
+          val = post.is_fixed_pitch.to_i
+          return [] if [0, 1].include?(val)
+
+          [issue(severity: :warning,
+                 message: "post.isFixedPitch is #{val} but must be 0 " \
+                          "(proportional) or 1 (monospace)",
+                 location: "post.is_fixed_pitch")]
+        end
+        private_class_method :validate_is_fixed_pitch
+      end
+    end
+  end
+end

data/lib/fontisan/audit/checks.rb

@@ -25,6 +25,16 @@ module Fontisan
                "fontisan/audit/checks/format_round_trip_check"
       autoload :OpenTypeConformanceCheck,
                "fontisan/audit/checks/opentype_conformance_check"
+      autoload :HeadCheck, "fontisan/audit/checks/head_check"
+      autoload :HheaCheck, "fontisan/audit/checks/hhea_check"
+      autoload :MaxpCheck, "fontisan/audit/checks/maxp_check"
+      autoload :Os2Check, "fontisan/audit/checks/os2_check"
+      autoload :NameTableCheck, "fontisan/audit/checks/name_table_check"
+      autoload :PostCheck, "fontisan/audit/checks/post_check"
+      autoload :KernCheck, "fontisan/audit/checks/kern_check"
+      autoload :CffTableCheck, "fontisan/audit/checks/cff_table_check"
+      autoload :GlyfTableCheck, "fontisan/audit/checks/glyf_table_check"
+      autoload :LayoutTableCheck, "fontisan/audit/checks/layout_table_check"
     end
   end
 end

data/lib/fontisan/cli.rb

@@ -40,15 +40,26 @@ module Fontisan
                         desc: "Audit only the given face of a collection"
     option :validate, type: :string, default: nil,
                       desc: "Run validation checks. Use 'true' for all, or a " \
-                            "profile name: default, structural, ots, layout"
+                            "profile name: default, structural, ots, layout, " \
+                            "variable, hinting, web, spec, per_table"
+    option :list_profiles, type: :boolean, default: false,
+                           desc: "List available validation profiles and exit"
+    option :fail_on_error, type: :boolean, default: true,
+                           desc: "Exit with code 1 if validation finds errors " \
+                                 "(only applies with --validate)"
     # Produce a structured font audit report (YAML or JSON).
-    def audit(font_file)
+    def audit(font_file = nil)
+      return list_audit_profiles if options[:list_profiles]
+
+      raise Thor::Error, "FONT_FILE is required" if font_file.nil?
+
       cmd_options = options.dup
       cmd_options[:include_codepoints] = !options[:no_codepoints]
       cmd_options[:validate] = parse_validate_option(options[:validate])
       command = Commands::AuditCommand.new(font_file, cmd_options)
       result = command.run
       write_audit_result(result, options[:output])
+      exit_on_validation_errors(result) if options[:validate] && options[:fail_on_error]
     rescue Errno::ENOENT
       warn "File not found: #{font_file}" unless options[:quiet]
       exit 1
@@ -810,6 +821,34 @@ module Fontisan
       raw.to_sym
     end
 
+    # Print available validation profiles with their check counts.
+    def list_audit_profiles
+      puts "Available validation profiles for --validate:"
+      puts ""
+      Audit::CheckRegistry::PROFILES.each do |name, codes|
+        puts "  #{name.to_s.ljust(15)} #{codes.size} checks"
+      end
+      puts ""
+      puts "Usage: fontisan audit font.ttf --validate <profile>"
+      puts "       fontisan audit font.ttf --validate true  (all checks)"
+    end
+
+    # Exit with code 1 if the audit found error-level issues.
+    # For collections, aggregates across all faces.
+    def exit_on_validation_errors(result)
+      issues = if result.is_a?(Array)
+                 result.flat_map(&:validation_issues)
+               else
+                 result.validation_issues || []
+               end
+      has_errors = issues.any? { |i| %w[error fatal].include?(i.severity) }
+      return unless has_errors
+
+      error_count = issues.count { |i| %w[error fatal].include?(i.severity) }
+      warn "Audit found #{error_count} error(s) — exiting with code 1"
+      exit 1
+    end
+
     def serialize_report(report, format)
       format == :json ? report.to_json : report.to_yaml
     end

data/lib/fontisan/commands/audit_command.rb

@@ -257,7 +257,9 @@ module Fontisan
       # ------------------------------------------------------------------
 
       def populate_validation(report, face)
-        report.validation_issues = run_validation_checks(face)
+        issues = run_validation_checks(face)
+        report.validation_issues = issues
+        report.validation_summary = Models::AuditSummary.from_issues(issues)
       end
 
       def run_validation_checks(face)

data/lib/fontisan/models/audit_report.rb

@@ -4,6 +4,51 @@ require "lutaml/model"
 
 module Fontisan
   module Models
+    # Summary of validation issues by severity. Used by CI pipelines
+    # to decide pass/fail and by humans to gauge font health at a
+    # glance.
+    class AuditSummary < Lutaml::Model::Serializable
+      attribute :error_count, :integer, default: 0
+      attribute :warning_count, :integer, default: 0
+      attribute :info_count, :integer, default: 0
+      attribute :fatal_count, :integer, default: 0
+      attribute :total, :integer, default: 0
+      attribute :passed, Lutaml::Model::Type::Boolean, default: true
+
+      json do
+        map "error_count", to: :error_count
+        map "warning_count", to: :warning_count
+        map "info_count", to: :info_count
+        map "fatal_count", to: :fatal_count
+        map "total", to: :total
+        map "passed", to: :passed
+      end
+
+      yaml do
+        map "error_count", to: :error_count
+        map "warning_count", to: :warning_count
+        map "info_count", to: :info_count
+        map "fatal_count", to: :fatal_count
+        map "total", to: :total
+        map "passed", to: :passed
+      end
+
+      # Build a summary from an array of ValidationReport::Issue records.
+      # @param issues [Array<ValidationReport::Issue>]
+      # @return [AuditSummary]
+      def self.from_issues(issues)
+        counts = issues.group_by(&:severity).transform_values(&:size)
+        new(
+          error_count: counts["error"].to_i,
+          warning_count: counts["warning"].to_i,
+          info_count: counts["info"].to_i,
+          fatal_count: counts["fatal"].to_i,
+          total: issues.size,
+          passed: counts["error"].to_i.zero? && counts["fatal"].to_i.zero?,
+        )
+      end
+    end
+
     # Variable-font axis descriptor for the audit report.
     class AuditAxis < Lutaml::Model::Serializable
       attribute :tag, :string
@@ -75,6 +120,7 @@ module Fontisan
 
       # Validation (populated only with --validate)
       attribute :validation_issues, Models::ValidationReport::Issue, collection: true
+      attribute :validation_summary, AuditSummary
 
       json do
         map "generated_at", to: :generated_at
@@ -108,6 +154,7 @@ module Fontisan
         map "opentype_scripts", to: :opentype_scripts
         map "features", to: :features
         map "validation_issues", to: :validation_issues
+        map "validation_summary", to: :validation_summary
       end
 
       yaml do
@@ -142,6 +189,7 @@ module Fontisan
         map "opentype_scripts", to: :opentype_scripts
         map "features", to: :features
         map "validation_issues", to: :validation_issues
+        map "validation_summary", to: :validation_summary
       end
     end
   end

data/lib/fontisan/models.rb

@@ -8,6 +8,7 @@ module Fontisan
              "fontisan/models/all_scripts_features_info"
     autoload :AuditAxis, "fontisan/models/audit_report"
     autoload :AuditReport, "fontisan/models/audit_report"
+    autoload :AuditSummary, "fontisan/models/audit_report"
     autoload :AxisInfo, "fontisan/models/variable_font_info"
     autoload :BitmapGlyph, "fontisan/models/bitmap_glyph"
     autoload :BitmapStrike, "fontisan/models/bitmap_strike"

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.36
+  version: 0.4.38
 platform: ruby
 authors:
 - Ribose Inc.
@@ -297,13 +297,23 @@ files:
 - lib/fontisan/audit/check.rb
 - lib/fontisan/audit/check_registry.rb
 - lib/fontisan/audit/checks.rb
+- lib/fontisan/audit/checks/cff_table_check.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/glyf_table_check.rb
 - lib/fontisan/audit/checks/glyph_name_check.rb
+- lib/fontisan/audit/checks/head_check.rb
+- lib/fontisan/audit/checks/hhea_check.rb
 - lib/fontisan/audit/checks/hinting_check.rb
+- lib/fontisan/audit/checks/kern_check.rb
+- lib/fontisan/audit/checks/layout_table_check.rb
+- lib/fontisan/audit/checks/maxp_check.rb
+- lib/fontisan/audit/checks/name_table_check.rb
 - lib/fontisan/audit/checks/opentype_conformance_check.rb
+- lib/fontisan/audit/checks/os2_check.rb
 - lib/fontisan/audit/checks/ots_compatibility_check.rb
+- lib/fontisan/audit/checks/post_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