fontisan 0.4.7 → 0.4.9

data/docs/cli/validate.md

@@ -46,3 +46,11 @@ fontisan validate font.ttf --profile opentype --format json
 ## Detailed Documentation
 
 For comprehensive documentation including profile details and validation helpers, see the [validate command guide](/guide/cli/validate).
+
+## See also
+
+For collection-level structural checks (face count, per-face glyph cap,
+cmap-union size) on a TTC/OTC/dfont, see
+[validate-collection](/cli/validate-collection). The two commands are
+complementary: `validate` runs profile-based per-face checks;
+`validate-collection` runs collection-level structural checks.

data/docs/index.md

@@ -18,8 +18,6 @@ hero:
       link: /guide/migrations/fonttools
 
 features:
-  - title: "🔍 Font Audit"
-    details: Comprehensive per-face audit (replaces otfinfo) — identity, style, metrics, coverage, licensing, hinting, color, variation, OpenType layout, UCD/CLDR aggregation, compare, and library-summary modes.
   - title: "🔄 Font Conversion"
     details: Convert between TTF, OTF, WOFF, WOFF2, Type 1 (PFB/PFA), and SVG formats with curve conversion and optimization.
   - title: "✅ Font Validation"

data/lib/fontisan/cli.rb

@@ -25,9 +25,6 @@ module Fontisan
                          desc: "Suppress non-error output",
                          aliases: "-q"
 
-    desc "cldr", "Manage local CLDR cache (subcommands)", hide: true
-    subcommand "cldr", CldrCli
-
     desc "ufo", "UFO source operations (build, convert, validate)"
     subcommand "ufo", Fontisan::Ufo::Cli
 
@@ -211,10 +208,12 @@ module Fontisan
     end
 
     desc "convert FONT_FILE", "Convert font to different format"
-    option :to, type: :string, required: true,
-                desc: "Target format: ttf, otf, type1, t1, ttc, otc, dfont, svg, " \
+    option :to, type: :array, required: true,
+                desc: "Target format(s): ttf, otf, type1, t1, ttc, otc, dfont, svg, " \
                       "woff (zlib — works on all browsers incl. legacy), " \
-                      "woff2 (Brotli — ~30% smaller, modern browsers only)",
+                      "woff2 (Brotli — ~30% smaller, modern browsers only). " \
+                      "Pass multiple times (--to woff --to woff2) or comma-separated " \
+                      "(--to woff,woff2) for multi-format output.",
                 aliases: "-t"
     option :output, type: :string,
                     desc: "Output file path (required unless --show-options)",
@@ -361,7 +360,7 @@ module Fontisan
 
       # Handle --show-options
       if options[:show_options]
-        show_recommended_options(source_format, options[:to])
+        show_recommended_options(source_format, options[:to].is_a?(Array) ? options[:to].first : options[:to])
         return
       end
 
@@ -371,7 +370,8 @@ module Fontisan
       end
 
       # Build ConversionOptions
-      conv_options = build_conversion_options(source_format, options[:to],
+      conv_options = build_conversion_options(source_format,
+                                              Array(options[:to]).first,
                                               options)
 
       # Build instance coordinates from axis options
@@ -573,6 +573,27 @@ module Fontisan
       exit command.run
     end
 
+    desc "validate-collection PATH",
+         "Validate a TTC/OTC/dfont (face count, glyph cap, cmap union)"
+    option :expected_faces, type: :numeric,
+                            desc: "Required face count"
+    option :max_glyphs, type: :numeric, default: Fontisan::Commands::ValidateCollectionCommand::DEFAULT_MAX_GLYPHS,
+                        desc: "Per-face glyph cap"
+    option :expected_cmap_union, type: :numeric,
+                                 desc: "Minimum cmap union size across all faces"
+    def validate_collection(path)
+      cmd = Commands::ValidateCollectionCommand.new(
+        input: path,
+        expected_faces: options[:expected_faces],
+        max_glyphs: options[:max_glyphs],
+        expected_cmap_union: options[:expected_cmap_union],
+      )
+      exit cmd.run
+    rescue ArgumentError => e
+      warn "ERROR: #{e.message}"
+      exit 1
+    end
+
     desc "version", "Display version information"
     # Display the Fontisan version.
     def version

data/lib/fontisan/collection/reader/stats.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Collection
+    class Reader
+      # Snapshot of one face's headline metrics. Pure value object —
+      # no methods beyond accessors. Separate file from {Reader} so
+      # the Stats struct can be referenced without pulling in the
+      # full Reader (and its FontLoader dependency).
+      #
+      # @!attribute [r] index
+      #   @return [Integer] 0-based face index inside the collection
+      # @!attribute [r] glyph_count
+      #   @return [Integer] face's maxp.numGlyphs
+      # @!attribute [r] codepoint_count
+      #   @return [Integer] count of keys in face's cmap unicode_mappings
+      # @!attribute [r] sfnt_version
+      #   @return [Integer] face sfnt version (0x00010000 for TTF, 0x4F54544F for OTF)
+      Stats = Struct.new(:index, :glyph_count, :codepoint_count, :sfnt_version,
+                         keyword_init: true)
+    end
+  end
+end

data/lib/fontisan/collection/reader.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Collection
+    # Read-only counterpart to {Builder}. Opens an existing TTC/OTC/dfont
+    # and exposes per-face metadata (glyph count, codepoint count, sfnt
+    # version) and the cmap union across all faces.
+    #
+    # Delegates header parsing to {FontLoader} — never hand-rolls the
+    # TTC header bytes (that would duplicate BaseCollection.from_file
+    # and only handle TTC/OTC, not dfont).
+    #
+    # @example Per-face glyph counts
+    #   reader = Collection::Reader.open("family.ttc")
+    #   reader.stats.map { |s| [s.index, s.glyph_count] }
+    #
+    # @example Cmap union
+    #   Collection::Reader.open("family.otc").cmap_union.size
+    class Reader
+      autoload :Stats, "fontisan/collection/reader/stats"
+
+      # @!attribute [r] path
+      #   @return [String] the file path this reader was opened with
+      attr_reader :path
+
+      # Collection formats this reader accepts. Single source of truth —
+      # matches {FontLoader::COLLECTION_CLASSES}.
+      FORMATS = %i[ttc otc dfont].freeze
+
+      # @param path [String] path to a TTC/OTC/dfont file
+      # @raise [ArgumentError] if the file is not a recognized collection
+      def initialize(path)
+        @path = path
+        detected = FontLoader.detect_format(path)
+        unless FORMATS.include?(detected)
+          raise ArgumentError,
+                "#{path} is not a TTC/OTC/dfont (detected: #{detected.inspect})"
+        end
+
+        @collection = FontLoader.load_collection(path)
+      end
+
+      # Convenience constructor.
+      # @param path [String]
+      # @return [Reader]
+      def self.open(path)
+        new(path)
+      end
+
+      # @return [Integer] number of faces in the collection
+      def face_count
+        @collection.num_fonts
+      end
+
+      # Yields each face as a loaded TTF/OTF font. Without a block,
+      # returns an Enumerator (so callers can chain +each_with_index+).
+      # The Enumerator's size is set to +face_count+ so size-based
+      # assertions work without consuming it.
+      #
+      # @yieldparam face [TrueTypeFont, OpenTypeFont]
+      # @return [Enumerator, void]
+      def each_face
+        return enum_for(:each_face) { face_count } unless block_given?
+
+        face_count.times { |i| yield FontLoader.load(@path, font_index: i) }
+      end
+
+      # @return [Array<Stats>] one Stats per face, in face-index order
+      def stats
+        each_face.map.with_index do |face, i|
+          Stats.new(
+            index: i,
+            glyph_count: face.table("maxp")&.num_glyphs || 0,
+            codepoint_count: (face.table("cmap")&.unicode_mappings || {}).size,
+            sfnt_version: face.header.sfnt_version,
+          )
+        end
+      end
+
+      # Union of every face's cmap keys.
+      #
+      # @return [Set<Integer>]
+      def cmap_union
+        each_face.with_object(Set.new) do |face, union|
+          union.merge((face.table("cmap")&.unicode_mappings || {}).keys)
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/collection.rb

@@ -7,6 +7,7 @@ module Fontisan
     autoload :Builder, "fontisan/collection/builder"
     autoload :DfontBuilder, "fontisan/collection/dfont_builder"
     autoload :OffsetCalculator, "fontisan/collection/offset_calculator"
+    autoload :Reader, "fontisan/collection/reader"
     autoload :SharedLogic, "fontisan/collection/shared_logic"
     autoload :TableAnalyzer, "fontisan/collection/table_analyzer"
     autoload :TableDeduplicator, "fontisan/collection/table_deduplicator"

data/lib/fontisan/commands/convert_command.rb

@@ -42,11 +42,20 @@ module Fontisan
     #   )
     #   command.run
     class ConvertCommand < BaseCommand
+      # Public readers for the parsed target formats and per-format output
+      # paths. Exposed (rather than relying on @ivar access from specs) so
+      # multi-format behaviour can be tested through the public surface.
+      attr_reader :target_formats, :output_paths
+
       # Initialize convert command
       #
       # @param font_path [String] Path to input font file
       # @param options [Hash] Conversion options
-      # @option options [String] :to Target format (ttf, otf, woff, woff2)
+      # @option options [String, Array<String>] :to Target format(s):
+      #   ttf, otf, woff, woff2, type1, ttc, otc, dfont, svg. Pass a
+      #   comma-separated string ("woff,woff2") or an array (["woff",
+      #   "woff2"]) for multi-format output. Single-font → single-font
+      #   only; multi-format + collection input is rejected.
       # @option options [String] :output Output file path (required)
       # @option options [Integer] :font_index Index for TTC/OTC (default: 0)
       # @option options [String] :coordinates Coordinate string (e.g., "wght=700,wdth=100")
@@ -69,8 +78,13 @@ module Fontisan
 
         @output_path = @options[:output]
 
-        # Parse target format
-        @target_format = parse_target_format(@options[:to])
+        # Parse target format(s). Always an Array<Symbol>, deduped, order
+        # preserved. Single-format callsites get a one-element array.
+        @target_formats = parse_target_formats(@options[:to])
+
+        # Resolve per-format output paths up front so filename ambiguity
+        # surfaces before any pipeline work is done.
+        @output_paths = resolve_output_paths
 
         # Extract ConversionOptions if provided
         @conv_options = extract_conversion_options(@options)
@@ -92,17 +106,26 @@ module Fontisan
 
       # Execute the conversion
       #
-      # @return [Hash] Result information
+      # @return [Hash, Array<Hash>] Result information. Single-format
+      #   returns one result hash (back-compat). Multi-format returns
+      #   an array of result hashes, one per target format.
       # @raise [ArgumentError] If output path is not specified
       # @raise [Error] If conversion fails
       def run
         validate_options!
 
-        # Check if input is a collection
         if collection_file?
+          if multi_format?
+            raise ArgumentError,
+                  "Multi-format conversion is not supported for collection " \
+                  "input. Specify a single target format."
+          end
+
           convert_collection
+        elsif multi_format?
+          convert_multi_format
         else
-          convert_single_font
+          convert_single_font(@target_formats.first, @output_paths.first)
         end
       rescue ArgumentError
         # Let ArgumentError propagate for validation errors
@@ -113,6 +136,11 @@ module Fontisan
 
       private
 
+      # @return [Boolean] true when more than one target format was given
+      def multi_format?
+        @target_formats.size > 1
+      end
+
       # Check if input file is a collection
       #
       # @return [Boolean] true if collection
@@ -123,15 +151,36 @@ module Fontisan
         false
       end
 
-      # Convert a single font (original implementation)
+      # Convert to each target format and aggregate results.
       #
+      # @return [Array<Hash>]
+      def convert_multi_format
+        unless @options[:quiet]
+          puts "Converting #{File.basename(font_path)} to " \
+               "#{@target_formats.join(', ')}..."
+        end
+
+        @target_formats.zip(@output_paths).map do |fmt, out_path|
+          result = convert_single_font(fmt, out_path)
+          unless @options[:quiet]
+            puts "  #{fmt}: wrote #{File.basename(out_path)} " \
+                 "(#{format_size(File.size(out_path))})"
+          end
+          result
+        end
+      end
+
+      # Convert a single font to a single target format at +out_path+.
+      #
+      # @param target_format [Symbol]
+      # @param out_path [String]
       # @return [Hash] Result information
-      def convert_single_font
-        puts "Converting #{File.basename(font_path)} to #{@target_format}..." unless @options[:quiet]
+      def convert_single_font(target_format, out_path)
+        puts "Converting #{File.basename(font_path)} to #{target_format}..." unless @options[:quiet]
 
         # Build pipeline options
         pipeline_options = {
-          target_format: @target_format,
+          target_format: target_format,
           validate: @validate,
           verbose: @options[:verbose],
         }
@@ -160,7 +209,7 @@ module Fontisan
         # Use TransformationPipeline for universal conversion
         pipeline = Pipeline::TransformationPipeline.new(
           font_path,
-          @output_path,
+          out_path,
           pipeline_options,
         )
 
@@ -168,12 +217,12 @@ module Fontisan
 
         # Display results
         unless @options[:quiet]
-          output_size = File.size(@output_path)
+          output_size = File.size(out_path)
           input_size = File.size(font_path)
 
           puts "Conversion complete!"
           puts "  Input:  #{font_path} (#{format_size(input_size)})"
-          puts "  Output: #{@output_path} (#{format_size(output_size)})"
+          puts "  Output: #{out_path} (#{format_size(output_size)})"
           puts "  Format: #{result[:details][:source_format]} → #{result[:details][:target_format]}"
 
           if result[:details][:variation_preserved]
@@ -186,11 +235,11 @@ module Fontisan
         {
           success: true,
           input_path: font_path,
-          output_path: @output_path,
+          output_path: out_path,
           source_format: result[:details][:source_format],
           target_format: result[:details][:target_format],
           input_size: File.size(font_path),
-          output_size: File.size(@output_path),
+          output_size: File.size(out_path),
           variation_strategy: result[:details][:variation_strategy],
         }
       end
@@ -200,11 +249,11 @@ module Fontisan
       # @return [Hash] Result information
       def convert_collection
         # Determine target collection type from target format
-        target_type = collection_type_from_format(@target_format)
+        target_type = collection_type_from_format(@target_formats.first)
 
         unless target_type
           raise ArgumentError,
-                "Target format #{@target_format} is not a collection format. " \
+                "Target format #{@target_formats.first} is not a collection format. " \
                 "Use ttc, otc, or dfont for collection conversion."
         end
 
@@ -302,12 +351,41 @@ module Fontisan
                 "Output path is required. Use --output option."
         end
 
-        unless @target_format
+        if @target_formats.empty?
           raise ArgumentError,
                 "Target format is required. Use --to option."
         end
       end
 
+      # Normalize the +--to+ value into a deduplicated Array<Symbol>.
+      #
+      # Accepts:
+      #   - "woff"               → [:woff]
+      #   - "woff,woff2"         → [:woff, :woff2]
+      #   - ["woff", "woff2"]    → [:woff, :woff2]
+      #   - ["woff,woff2", "ttf"] → [:woff, :woff2, :ttf]
+      #   - nil / ""             → []
+      #
+      # @return [Array<Symbol>]
+      def parse_target_formats(raw)
+        array = Array(raw).flat_map { |s| s.to_s.split(",") }
+          .map { |s| s.strip.downcase }
+          .reject(&:empty?)
+          .map { |s| parse_target_format(s) }
+        array.uniq
+      end
+
+      # Resolve the per-format output paths via {MultiFormatOutput}.
+      # Returns nil when no target formats have been parsed yet (the
+      # validate_options! path will surface the missing-format error).
+      #
+      # @return [Array<String>, nil]
+      def resolve_output_paths
+        return nil if @target_formats.empty? || @output_path.nil?
+
+        MultiFormatOutput.new(@output_path, @target_formats).paths
+      end
+
       # Parse target format from string/symbol
       #
       # @param format [String, Symbol, nil] Target format

data/lib/fontisan/commands/multi_format_output.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Resolves the on-disk output path for each target format in a
+    # multi-format conversion (TODO 72).
+    #
+    # Rules:
+    #   - One format + path has extension → use the path as-is.
+    #   - One format + path has no extension → append ".<format>".
+    #   - Many formats + path has extension → +ArgumentError+ (ambiguous).
+    #   - Many formats + path has no extension → append ".<format>" per target.
+    #
+    # Pure value object: no I/O, no mutation. Extracted from
+    # {ConvertCommand} so multi-format path resolution can be tested
+    # independently of the transformation pipeline.
+    class MultiFormatOutput
+      # @param base_path [String] user-supplied --output value
+      # @param target_formats [Array<Symbol>] non-empty, deduplicated
+      def initialize(base_path, target_formats)
+        @base_path = base_path
+        @target_formats = target_formats
+      end
+
+      # @return [Array<String>] one resolved path per target format,
+      #   in the same order as +target_formats+
+      # @raise [ArgumentError] if the base path is ambiguous
+      def paths
+        single? ? [single_format_path] : multi_format_paths
+      end
+
+      private
+
+      def single?
+        @target_formats.size == 1
+      end
+
+      def single_format_path
+        has_extension? ? @base_path : "#{@base_path}.#{@target_formats.first}"
+      end
+
+      def multi_format_paths
+        if has_extension?
+          raise ArgumentError,
+                "Output path #{@base_path.inspect} has an extension but " \
+                "#{@target_formats.size} target formats were given " \
+                "(#{@target_formats.join(', ')}). Drop the extension or " \
+                "specify a single format."
+        end
+
+        @target_formats.map { |fmt| "#{@base_path}.#{fmt}" }
+      end
+
+      def has_extension?
+        !File.extname(@base_path).strip.downcase.empty?
+      end
+    end
+  end
+end

data/lib/fontisan/commands/validate_collection_command.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Commands
+    # Validates the structural integrity of a TTC/OTC/dfont collection
+    # (TODO 74). Complements {ValidateCommand}, which runs profile-based
+    # checks against a single face. This command runs collection-level
+    # checks: face count, per-face glyph cap, optional cmap-union size.
+    #
+    # Returns an integer exit code (0 = all checks passed, 1 = any check
+    # failed) suitable for use as the CLI's exit status.
+    #
+    # The command is intentionally narrow: it does not subclass
+    # {BaseCommand} (which eagerly loads a single font at construction
+    # time) because the input here is a collection, not a single face.
+    # It owns its own loading via {Collection::Reader}.
+    class ValidateCollectionCommand
+      # Per-check result. The +message+ is +nil+ on pass.
+      #
+      # @!attribute [r] name
+      #   @return [Symbol] check identifier (:face_count, :glyph_cap, :cmap_union)
+      # @!attribute [r] passed
+      #   @return [Boolean]
+      # @!attribute [r] message
+      #   @return [String, nil] human-readable failure detail
+      Check = Struct.new(:name, :passed, :message, keyword_init: true) do
+        # Predicate form so callers can write +check.passed?+ instead of
+        # +check.passed+. Struct does not provide the +?+ suffix
+        # automatically.
+        def passed?
+          passed
+        end
+      end
+
+      DEFAULT_MAX_GLYPHS = 65_535
+
+      # @param input [String] path to a TTC/OTC/dfont
+      # @param expected_faces [Integer, nil] required face count, or nil to skip
+      # @param max_glyphs [Integer] per-face glyph cap (default 65,535)
+      # @param expected_cmap_union [Integer, nil] minimum cmap-union size, or nil to skip
+      def initialize(input:, expected_faces: nil, max_glyphs: DEFAULT_MAX_GLYPHS,
+                     expected_cmap_union: nil)
+        @input = input
+        @expected_faces = expected_faces
+        @max_glyphs = max_glyphs
+        @expected_cmap_union = expected_cmap_union
+      end
+
+      # @return [Integer] 0 if all checks passed, 1 otherwise
+      def run
+        reader = Collection::Reader.open(@input)
+        @checks = [
+          check_face_count(reader),
+          check_glyph_cap(reader),
+          check_cmap_union(reader),
+        ].compact
+
+        render_report(reader)
+        @checks.all?(&:passed?) ? 0 : 1
+      end
+
+      # @return [Array<Check>] the most recent run's checks
+      attr_reader :checks
+
+      private
+
+      def check_face_count(reader)
+        return nil unless @expected_faces
+
+        actual = reader.face_count
+        passed = actual == @expected_faces
+        Check.new(
+          name: :face_count,
+          passed: passed,
+          message: passed ? nil : "expected #{@expected_faces} faces, got #{actual}",
+        )
+      end
+
+      def check_glyph_cap(reader)
+        over = reader.stats.select { |s| s.glyph_count > @max_glyphs }
+        Check.new(
+          name: :glyph_cap,
+          passed: over.empty?,
+          message: over.empty? ? nil : "faces over cap: #{over.map { |s| "##{s.index}=#{s.glyph_count}" }.join(', ')}",
+        )
+      end
+
+      def check_cmap_union(reader)
+        return nil unless @expected_cmap_union
+
+        actual = reader.cmap_union.size
+        passed = actual >= @expected_cmap_union
+        Check.new(
+          name: :cmap_union,
+          passed: passed,
+          message: passed ? nil : "cmap union #{actual} < expected #{@expected_cmap_union}",
+        )
+      end
+
+      # Default rendering. Callers wanting structured output can
+      # instantiate the command, call +#run+, then read +#checks+
+      # directly instead of relying on stdout.
+      def render_report(reader)
+        reader.stats.each do |s|
+          marker = s.glyph_count <= @max_glyphs ? "✓" : "✗"
+          puts format("face %<index>d: %<glyphs>7d glyphs %<marker>s",
+                      index: s.index, glyphs: s.glyph_count, marker: marker)
+        end
+        puts "all #{reader.face_count} faces within #{@max_glyphs}-glyph cap ✓"
+
+        @checks.each do |check|
+          if check.passed?
+            puts "#{check.name}: ✓"
+          else
+            puts "#{check.name}: ✗ (#{check.message})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/commands.rb

@@ -13,6 +13,7 @@ module Fontisan
     autoload :InfoCommand, "fontisan/commands/info_command"
     autoload :InstanceCommand, "fontisan/commands/instance_command"
     autoload :LsCommand, "fontisan/commands/ls_command"
+    autoload :MultiFormatOutput, "fontisan/commands/multi_format_output"
     autoload :OpticalSizeCommand, "fontisan/commands/optical_size_command"
     autoload :PackCommand, "fontisan/commands/pack_command"
     autoload :ScriptsCommand, "fontisan/commands/scripts_command"
@@ -20,6 +21,7 @@ module Fontisan
     autoload :TablesCommand, "fontisan/commands/tables_command"
     autoload :UnicodeCommand, "fontisan/commands/unicode_command"
     autoload :UnpackCommand, "fontisan/commands/unpack_command"
+    autoload :ValidateCollectionCommand, "fontisan/commands/validate_collection_command"
     autoload :ValidateCommand, "fontisan/commands/validate_command"
     autoload :VariableCommand, "fontisan/commands/variable_command"
   end

data/lib/fontisan/error.rb

@@ -237,6 +237,31 @@ module Fontisan
     end
   end
 
+  # Partition strategy could not satisfy the requested cap.
+  #
+  # Raised by {Stitcher::PartitionStrategy} when a single Unicode block
+  # contains more codepoints than the configured cap, so the partitioner
+  # cannot sub-split it further. This is a partitioning-time detection
+  # distinct from {GlyphLimitExceededError}, which fires at compile time
+  # after the Stitcher has produced more glyphs than the output format
+  # supports. Both surface the same underlying constraint (65,535-glyph
+  # cap) but at different stages.
+  class PartitionCapExceededError < Error
+    attr_reader :block_label, :actual, :cap
+
+    # @param block_label [String] e.g. "CJK_Ext_B", or "plane_N" if the
+    #   overflow is not attributable to a known block
+    # @param actual [Integer] number of codepoints in the block
+    # @param cap [Integer] the cap that was exceeded
+    def initialize(block_label:, actual:, cap:)
+      @block_label = block_label
+      @actual = actual
+      @cap = cap
+      super("single Unicode block #{block_label} (#{actual} cps) exceeds " \
+            "cap #{cap}; cannot sub-split further")
+    end
+  end
+
   # Variation data corrupted (for use in data_extractor)
   #
   # Raised when extracted variation data appears corrupted.

data/lib/fontisan/models.rb

@@ -15,7 +15,6 @@ module Fontisan
     autoload :CollectionListInfo, "fontisan/models/collection_list_info"
     autoload :CollectionValidationReport,
              "fontisan/models/collection_validation_report"
-    autoload :Cldr, "fontisan/models/cldr"
     autoload :ColorGlyph, "fontisan/models/color_glyph"
     autoload :ColorLayer, "fontisan/models/color_layer"
     autoload :ColorPalette, "fontisan/models/color_palette"