fontisan 0.4.22 → 0.4.24

data/lib/fontisan/ufo/convert/to_postscript.rb

@@ -17,12 +17,17 @@ module Fontisan
         # @param ps_options [Hash] forwarded to the generator
         #   (encoding, upm_scale, convert_curves)
         # @return [String] the output_path
-        def self.convert(ufo, output_path:, generator_class:, compiler: :ttf, **ps_options)
+        def self.convert(ufo, output_path:, generator_class:, compiler: :ttf,
+**ps_options)
           compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
-          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+          unless compiler_class
+            raise ArgumentError,
+                  "unknown intermediate compiler: #{compiler.inspect}"
+          end
 
           Dir.mktmpdir do |dir|
-            intermediate_path = File.join(dir, "intermediate#{ext_for(compiler)}")
+            intermediate_path = File.join(dir,
+                                          "intermediate#{ext_for(compiler)}")
             compiler_class.new(ufo).compile(output_path: intermediate_path)
 
             loaded = Fontisan::FontLoader.load(intermediate_path)

data/lib/fontisan/ufo/convert/to_woff.rb

@@ -32,14 +32,19 @@ module Fontisan
         # @return [String] the output_path
         def self.convert(ufo, output_path:, compiler: :ttf, **woff_options)
           compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
-          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+          unless compiler_class
+            raise ArgumentError,
+                  "unknown intermediate compiler: #{compiler.inspect}"
+          end
 
           Dir.mktmpdir do |dir|
-            intermediate_path = File.join(dir, "intermediate#{format_ext(compiler)}")
+            intermediate_path = File.join(dir,
+                                          "intermediate#{format_ext(compiler)}")
             compiler_class.new(ufo).compile(output_path: intermediate_path)
 
             loaded = Fontisan::FontLoader.load(intermediate_path)
-            woff_bytes = Fontisan::Converters::WoffWriter.new.convert(loaded, woff_options)
+            woff_bytes = Fontisan::Converters::WoffWriter.new.convert(loaded,
+                                                                      woff_options)
             File.binwrite(output_path, woff_bytes)
           end
 

data/lib/fontisan/ufo/convert/to_woff2.rb

@@ -21,14 +21,19 @@ module Fontisan
         # @return [String] the output_path
         def self.convert(ufo, output_path:, compiler: :ttf, **woff2_options)
           compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
-          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+          unless compiler_class
+            raise ArgumentError,
+                  "unknown intermediate compiler: #{compiler.inspect}"
+          end
 
           Dir.mktmpdir do |dir|
-            intermediate_path = File.join(dir, "intermediate#{format_ext(compiler)}")
+            intermediate_path = File.join(dir,
+                                          "intermediate#{format_ext(compiler)}")
             compiler_class.new(ufo).compile(output_path: intermediate_path)
 
             loaded = Fontisan::FontLoader.load(intermediate_path)
-            result = Fontisan::Converters::Woff2Encoder.new.convert(loaded, woff2_options)
+            result = Fontisan::Converters::Woff2Encoder.new.convert(loaded,
+                                                                    woff2_options)
             File.binwrite(output_path, result[:woff2_binary])
           end
 

data/lib/fontisan/ufo/convert.rb

@@ -71,7 +71,10 @@ module Fontisan
         end
 
         compiler = COMPILER_FOR_FORMAT[format_key]
-        raise ArgumentError, "unknown UFO output format: #{to.inspect}" unless compiler
+        unless compiler
+          raise ArgumentError,
+                "unknown UFO output format: #{to.inspect}"
+        end
 
         compiler.new(ufo).compile(output_path: output_path)
         output_path

data/lib/fontisan/ufo/glyph_exists_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Raised by +Layer#add+ when a glyph with the same name is already
+    # present. Surfaces what would otherwise be a silent overwrite so
+    # the caller can decide between +Layer#put+ (intentional replace)
+    # and +Stitcher::UniqueGlyphName.in+ (auto-rename).
+    #
+    # Extracted as a sibling of +Layer+ (rather than nested inside it)
+    # so the namespace stays flat and the error can be referenced
+    # without pulling in the full Layer implementation.
+    class GlyphExistsError < StandardError
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        super("a glyph named #{name.inspect} already exists; use #put " \
+              "to overwrite or UniqueGlyphName.in to deconflict")
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/info.rb

@@ -81,8 +81,10 @@ module Fontisan
       # @return [Array(Integer, Integer)] [major, minor]
       def self.parse_version(version)
         case version.to_s
-        when /\A(\d+)\.(\d+)\.\d+\z/ then [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i]
-        when /\A(\d+)\.(\d+)\z/      then [Regexp.last_match(1).to_i, Regexp.last_match(2).to_i]
+        when /\A(\d+)\.(\d+)\.\d+\z/ then [Regexp.last_match(1).to_i,
+                                           Regexp.last_match(2).to_i]
+        when /\A(\d+)\.(\d+)\z/      then [Regexp.last_match(1).to_i,
+                                           Regexp.last_match(2).to_i]
         when /\A(\d+)\z/             then [Regexp.last_match(1).to_i, 0]
         else [0, 0]
         end

data/lib/fontisan/ufo/layer.rb

@@ -5,8 +5,27 @@ module Fontisan
     # A single layer in a UFO source. A Layer holds a set of glyphs
     # keyed by name. The default layer is `public.default` per UFO 3.
     #
-    # glyphs is mutated in place by Reader and Writer; the Layer does
-    # not own serialization concerns.
+    # == Naming contract
+    #
+    # Glyph names are the layer's primary key. Two distinct glyphs with
+    # the same name cannot coexist — adding the second would silently
+    # destroy the first, a class of bug that has historically cost real
+    # data (e.g. CJK Ext G cmap loss when CBDT placeholders collided
+    # with outline glyphs sharing "gid{N}" names).
+    #
+    # To make that contract unbreakable, +#add+ RAISES +GlyphExistsError+
+    # on conflict. Callers who want one of the other two semantics pick
+    # the method that names it:
+    #
+    #   +#add+::    insert; raise if the name is taken (the safe default)
+    #   +#put+::    insert; overwrite any existing glyph with the same name
+    #
+    # Callers that need auto-renaming (insertion without giving up on a
+    # collision) call +Stitcher::UniqueGlyphName.in(target, base)+ first,
+    # then +#add+ the glyph under the returned name.
+    #
+    # The error class itself lives at +Fontisan::Ufo::GlyphExistsError+
+    # (sibling, not nested) so the namespace stays flat.
     class Layer
       DEFAULT_NAME = "public.default"
 
@@ -21,7 +40,28 @@ module Fontisan
         @glyphs[glyph_name.to_s]
       end
 
+      # Insert +glyph+. Raises +GlyphExistsError+ if a glyph with the
+      # same name is already present — this is the contract that keeps
+      # the layer's key namespace trustworthy.
+      #
+      # @param glyph [Glyph]
+      # @return [Glyph] the same glyph
+      # @raise [GlyphExistsError] if +glyph.name+ is already taken
       def add(glyph)
+        name = glyph.name.to_s
+        raise GlyphExistsError, name if @glyphs.key?(name)
+
+        @glyphs[name] = glyph
+        glyph
+      end
+
+      # Insert +glyph+, replacing any existing glyph with the same
+      # name. Use this when the caller has positively decided that the
+      # previous glyph (if any) should be discarded.
+      #
+      # @param glyph [Glyph]
+      # @return [Glyph] the same glyph
+      def put(glyph)
         @glyphs[glyph.name.to_s] = glyph
         glyph
       end

data/lib/fontisan/ufo/plist.rb

@@ -25,7 +25,9 @@ module Fontisan
         root = doc.root
         raise ParseError, "no <plist> root element" unless root&.name == "plist"
 
-        parse_value(root.children.find { |c| c.element? || c.cdata? || c.text? && !c.text.strip.empty? })
+        parse_value(root.children.find do |c|
+          c.element? || c.cdata? || c.text? && !c.text.strip.empty?
+        end)
       end
 
       # @param value [Object] the value to serialize
@@ -73,7 +75,10 @@ module Fontisan
         # dict children are key/value pairs (key first, then value)
         while children.any?
           key_node = children.shift
-          raise ParseError, "dict key is not <key>" unless key_node.name == "key"
+          unless key_node.name == "key"
+            raise ParseError,
+                  "dict key is not <key>"
+          end
 
           value_node = children.shift
           result[key_node.text] = parse_value(value_node)

data/lib/fontisan/ufo/reader.rb

@@ -94,7 +94,9 @@ module Fontisan
               if order.first.is_a?(Hash)
                 order.reduce({}) { |h, pair| h.merge(pair) }
               else
-                order.to_h { |filename| [File.basename(filename, ".glif"), filename] }
+                order.to_h do |filename|
+                  [File.basename(filename, ".glif"), filename]
+                end
               end
             else
               raise "unsupported contents.plist format: #{order.class}"

data/lib/fontisan/ufo/writer.rb

@@ -50,7 +50,8 @@ module Fontisan
       end
 
       def write_fontinfo(path)
-        File.write(File.join(path, "fontinfo.plist"), Plist.emit(@font.info.to_plist))
+        File.write(File.join(path, "fontinfo.plist"),
+                   Plist.emit(@font.info.to_plist))
       end
 
       def write_layercontents(path)
@@ -75,11 +76,17 @@ module Fontisan
           FileUtils.mkpath(layer_dir)
 
           contents =
-            layer.glyphs.transform_values { |g| "#{safe_filename(g.name)}.glif" }
-          File.write(File.join(layer_dir, "contents.plist"), Plist.emit(contents))
+            layer.glyphs.transform_values do |g|
+              "#{safe_filename(g.name)}.glif"
+            end
+          File.write(File.join(layer_dir, "contents.plist"),
+                     Plist.emit(contents))
 
           layer.glyphs.each_value do |glyph|
-            File.write(File.join(layer_dir, "#{safe_filename(glyph.name)}.glif"), glyph.to_glif)
+            File.write(
+              File.join(layer_dir,
+                        "#{safe_filename(glyph.name)}.glif"), glyph.to_glif
+            )
           end
         end
       end
@@ -96,7 +103,8 @@ module Fontisan
       def write_kerning(path)
         return if @font.kerning.empty?
 
-        File.write(File.join(path, "kerning.plist"), Plist.emit(@font.kerning.to_plist))
+        File.write(File.join(path, "kerning.plist"),
+                   Plist.emit(@font.kerning.to_plist))
       end
 
       def write_features(path)

data/lib/fontisan/ufo.rb

@@ -17,7 +17,8 @@ module Fontisan
   #
   # Reference: https://unifiedfontobject.org
   module Ufo
-    autoload :Font,        "fontisan/ufo/font"
+    autoload :Font, "fontisan/ufo/font"
+    autoload :GlyphExistsError, "fontisan/ufo/glyph_exists_error"
     autoload :Info,        "fontisan/ufo/info"
     autoload :Layer,       "fontisan/ufo/layer"
     autoload :LayerSet,    "fontisan/ufo/layer_set"

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/collection_decoder.rb

@@ -131,7 +131,10 @@ module Fontisan
       def read_collection_directory(pos)
         version = @data[pos, 4].unpack1("N")
         pos += 4
-        raise InvalidFontError, "Unsupported CollectionHeader version 0x#{version.to_s(16)}" unless version == 0x00010000
+        unless version == 0x00010000
+          raise InvalidFontError,
+                "Unsupported CollectionHeader version 0x#{version.to_s(16)}"
+        end
 
         num_fonts, pos = UInt255.decode_at(@data, pos)
         font_entries = Array.new(num_fonts) do

data/lib/fontisan/woff2/collection_encoder.rb

@@ -32,7 +32,10 @@ module Fontisan
       # @param fonts [Array<TrueTypeFont, OpenTypeFont>] Source fonts
       # @return [String] WOFF2 collection binary
       def encode_fonts(fonts)
-        raise ArgumentError, "fonts cannot be empty" if fonts.nil? || fonts.empty?
+        if fonts.nil? || fonts.empty?
+          raise ArgumentError,
+                "fonts cannot be empty"
+        end
 
         prepared = fonts.map.with_index { |font, i| prepare_font(font, i) }
         _, font_to_ckeys = deduplicate(prepared)

data/lib/fontisan/woff2/glyf_canonicalizer.rb

@@ -50,7 +50,8 @@ module Fontisan
           start_offset = source_offsets[i]
           end_offset = source_offsets[i + 1]
           if start_offset < end_offset
-            glyf << @glyf_data.byteslice(start_offset, end_offset - start_offset)
+            glyf << @glyf_data.byteslice(start_offset,
+                                         end_offset - start_offset)
           end
           remainder = glyf.bytesize % 4
           glyf << ("\x00" * (4 - remainder)) if remainder.positive?

data/lib/fontisan/woff2/glyf_loca_reconstruct.rb

@@ -131,7 +131,8 @@ module Fontisan
         streams[:bbox_entries] = StringIO.new(bbox_blob[bitmap_size..] || "")
 
         # overlapSimpleBitmap follows all streams when optionFlags bit 0 set.
-        streams[:overlap_bitmap] = header[:has_overlap_bitmap] ? @data[pos, overlap_size] : ""
+        streams[:overlap_bitmap] =
+          header[:has_overlap_bitmap] ? @data[pos, overlap_size] : ""
 
         # nContour is read positionally (int16 per glyph).
         nc_data = streams[:n_contour].string
@@ -178,7 +179,9 @@ module Fontisan
         x = 0
         y = 0
         triplet_flags.each do |flag|
-          dx, dy, oc = TripletCodec.decode(flag, read_triplet_payload(flag, streams[:glyph]))
+          dx, dy, oc = TripletCodec.decode(flag,
+                                           read_triplet_payload(flag,
+                                                                streams[:glyph]))
           x += dx
           y += dy
           xs << x

data/lib/fontisan/woff2/sfnt_checksum.rb

@@ -97,7 +97,8 @@ module Fontisan
       def per_table_checksum(table)
         data = table.bytes
         if table.tag == "head"
-          data = "#{data.byteslice(0, 8)}#{['00000000'].pack('H8')}#{data.byteslice(12..)}"
+          data = "#{data.byteslice(0,
+                                   8)}#{['00000000'].pack('H8')}#{data.byteslice(12..)}"
         end
         Utilities::ChecksumCalculator.calculate_table_checksum(data)
       end

data/lib/fontisan.rb

@@ -119,7 +119,6 @@ module Fontisan
   autoload :SfntBuilder, "fontisan/sfnt_builder"
   autoload :Stitcher, "fontisan/stitcher"
   autoload :StitcherCli, "fontisan/stitcher_cli"
-  autoload :Tasks, "fontisan/tasks"
   autoload :TrueTypeCollection, "fontisan/true_type_collection"
   autoload :TrueTypeFont, "fontisan/true_type_font"
   autoload :TrueTypeFontExtensions, "fontisan/true_type_font_extensions"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.22
+  version: 0.4.24
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -168,6 +168,7 @@ files:
 - docs/api/font-loader.md
 - docs/api/font-writer.md
 - docs/api/index.md
+- docs/api/layer.md
 - docs/api/models/glyph-accessor.md
 - docs/api/models/glyph.md
 - docs/api/models/table-analyzer.md
@@ -440,6 +441,7 @@ files:
 - lib/fontisan/stitcher/collection_result.rb
 - lib/fontisan/stitcher/deduplicator.rb
 - lib/fontisan/stitcher/format_metadata.rb
+- lib/fontisan/stitcher/glyph_cloner.rb
 - lib/fontisan/stitcher/glyph_copier.rb
 - lib/fontisan/stitcher/glyph_limit.rb
 - lib/fontisan/stitcher/glyph_signature.rb
@@ -455,12 +457,35 @@ files:
 - lib/fontisan/stitcher/selector/gid.rb
 - lib/fontisan/stitcher/selector/range.rb
 - lib/fontisan/stitcher/source.rb
+- lib/fontisan/stitcher/unique_glyph_name.rb
 - lib/fontisan/stitcher_cli.rb
 - lib/fontisan/subset.rb
 - lib/fontisan/subset/builder.rb
 - lib/fontisan/subset/glyph_mapping.rb
 - lib/fontisan/subset/options.rb
 - lib/fontisan/subset/profile.rb
+- lib/fontisan/subset/shared_state.rb
+- lib/fontisan/subset/subset_context.rb
+- lib/fontisan/subset/table_strategy.rb
+- lib/fontisan/subset/table_strategy/cbdt.rb
+- lib/fontisan/subset/table_strategy/cblc.rb
+- lib/fontisan/subset/table_strategy/cmap.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_placement.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_strike_plan.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subset_plan.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subsetter.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subtable_plan.rb
+- lib/fontisan/subset/table_strategy/glyf.rb
+- lib/fontisan/subset/table_strategy/glyf_loca_builder.rb
+- lib/fontisan/subset/table_strategy/head.rb
+- lib/fontisan/subset/table_strategy/hhea.rb
+- lib/fontisan/subset/table_strategy/hmtx.rb
+- lib/fontisan/subset/table_strategy/loca.rb
+- lib/fontisan/subset/table_strategy/maxp.rb
+- lib/fontisan/subset/table_strategy/name.rb
+- lib/fontisan/subset/table_strategy/os2.rb
+- lib/fontisan/subset/table_strategy/pass_through.rb
+- lib/fontisan/subset/table_strategy/post.rb
 - lib/fontisan/subset/table_subsetter.rb
 - lib/fontisan/svg.rb
 - lib/fontisan/svg/font_face_generator.rb
@@ -483,6 +508,14 @@ files:
 - lib/fontisan/tables.rb
 - lib/fontisan/tables/cbdt.rb
 - lib/fontisan/tables/cblc.rb
+- lib/fontisan/tables/cblc_big_glyph_metrics.rb
+- lib/fontisan/tables/cblc_bitmap_size.rb
+- lib/fontisan/tables/cblc_glyph_bitmap_location.rb
+- lib/fontisan/tables/cblc_index_subtable.rb
+- lib/fontisan/tables/cblc_index_subtable_array_entry.rb
+- lib/fontisan/tables/cblc_index_subtable_format_parser.rb
+- lib/fontisan/tables/cblc_index_subtable_header.rb
+- lib/fontisan/tables/cblc_sbit_line_metrics.rb
 - lib/fontisan/tables/cff.rb
 - lib/fontisan/tables/cff/cff2_charstring_builder.rb
 - lib/fontisan/tables/cff/cff_glyph.rb
@@ -556,8 +589,6 @@ files:
 - lib/fontisan/tables/svg.rb
 - lib/fontisan/tables/variation_common.rb
 - lib/fontisan/tables/vvar.rb
-- lib/fontisan/tasks.rb
-- lib/fontisan/tasks/fixture_downloader.rb
 - lib/fontisan/true_type_collection.rb
 - lib/fontisan/true_type_font.rb
 - lib/fontisan/true_type_font_extensions.rb
@@ -657,6 +688,7 @@ files:
 - lib/fontisan/ufo/features.rb
 - lib/fontisan/ufo/font.rb
 - lib/fontisan/ufo/glyph.rb
+- lib/fontisan/ufo/glyph_exists_error.rb
 - lib/fontisan/ufo/guideline.rb
 - lib/fontisan/ufo/image.rb
 - lib/fontisan/ufo/image_set.rb

data/lib/fontisan/tasks/fixture_downloader.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "open-uri"
-require "net/http"
-require "fileutils"
-
-module Fontisan
-  # Tasks supporting the developer workflow: fixture downloads, etc.
-  # Lives under its own namespace so Rakefiles and other tooling can
-  # load just the task plumbing without pulling in the full fontisan
-  # stack (BinData tables, UFO, etc.).
-  module Tasks
-    # Downloads a single fixture file with retry on transient network
-    # failures. Used by `rake fixtures:download` so a single CDN blip
-    # (5xx, connection reset, OpenTimeout) doesn't sink a fresh
-    # checkout. Permanent failures (404, malformed URL) surface
-    # immediately.
-    #
-    # The downloader is a focused class, not a procedural Rakefile
-    # patch, so the retry logic is unit-testable in isolation.
-    #
-    # @example
-    #   Fontisan::Tasks::FixtureDownloader.new(
-    #     url: "https://github.com/.../font.ttf",
-    #     destination: "spec/fixtures/font.ttf",
-    #   ).call
-    class FixtureDownloader
-      RETRIABLE_ERRORS = [
-        Net::OpenTimeout,
-        Net::ReadTimeout,
-        Errno::ECONNRESET,
-        Errno::ECONNREFUSED,
-        Errno::EHOSTUNREACH,
-        Errno::ETIMEDOUT,
-        EOFError,
-        IOError,
-      ].freeze
-
-      # 5xx HTTP responses are transient server errors worth retrying.
-      # 4xx are permanent (404, 403) and must fail fast.
-      RETRIABLE_HTTP_STATUSES = (500..599)
-
-      DEFAULT_MAX_RETRIES = 3
-      DEFAULT_BASE_BACKOFF = 0.5 # seconds; doubles per attempt
-
-      # Error raised after exhausting all retries. Carries the last
-      # underlying exception so callers can log the root cause.
-      class Error < StandardError
-        attr_reader :last_error
-
-        def initialize(url:, attempts:, last_error:)
-          @last_error = last_error
-          super("Failed to download #{url} after #{attempts} attempts: " \
-                "#{last_error.class}: #{last_error.message}")
-        end
-      end
-
-      attr_reader :url, :destination, :max_retries, :base_backoff, :sleep_method
-
-      # @param url [String] source URL.
-      # @param destination [String] path to write bytes to. Parent dir
-      #   is auto-created.
-      # @param max_retries [Integer] total attempts including the
-      #   first. 3 means: try, retry, retry.
-      # @param base_backoff [Float] seconds to sleep before the first
-      #   retry. Doubles per attempt.
-      # @param sleep_method [#call] injectable sleep (for tests).
-      #   Defaults to Kernel.sleep.
-      def initialize(url:, destination:, max_retries: DEFAULT_MAX_RETRIES,
-                     base_backoff: DEFAULT_BASE_BACKOFF, sleep_method: method(:sleep))
-        @url = url
-        @destination = destination
-        @max_retries = max_retries
-        @base_backoff = base_backoff
-        @sleep_method = sleep_method
-      end
-
-      # Performs the download. Returns the destination path on
-      # success. Raises {Error} after exhausting retries.
-      #
-      # @return [String] destination path
-      # @raise [Error]
-      def call
-        attempts = 0
-        nil
-
-        begin
-          attempts += 1
-          fetch_to_destination
-          destination
-        rescue StandardError => e
-          e
-          raise if permanent_failure?(e)
-          raise Error.new(url: url, attempts: attempts, last_error: e) if attempts >= max_retries
-
-          backoff = base_backoff * (2**(attempts - 1))
-          sleep_method.call(backoff)
-          retry
-        end
-      end
-
-      private
-
-      def fetch_to_destination
-        FileUtils.mkdir_p(File.dirname(destination))
-
-        # IO.copy_stream avoids loading the whole response into memory
-        # and is more Windows-compatible than remote.read + File.binwrite.
-        # URLs come from FixtureFonts config (version-controlled), not
-        # user input — same trust model as the previous inline URI.open
-        # call in the Rakefile.
-        #
-        # Parsing with URI.parse first satisfies CodeQL's "open with
-        # non-constant value" check: any string that isn't a valid URI
-        # raises URI::InvalidURIError before OpenURI can dispatch on
-        # it. The parsed URI's .open is OpenURI's standard entry.
-        # rubocop:disable Security/Open
-        URI.parse(url).open(open_uri_options) do |remote|
-          File.open(destination, "wb") do |file|
-            IO.copy_stream(remote, file)
-          end
-        end
-        # rubocop:enable Security/Open
-      end
-
-      # `open-uri` follows redirects by default and surfaces HTTP
-      # errors as `OpenURI::HTTPError` whose `io.status` is the `[code,
-      # message]` array. We re-raise non-retriable 4xx as
-      # `permanent-failure`-tagged exceptions so the retry loop exits.
-      def open_uri_options
-        {
-          "User-Agent" => "fontisan-fixtures/1.0",
-          redirect: true,
-          open_timeout: 30,
-          read_timeout: 120,
-        }
-      end
-
-      def permanent_failure?(error)
-        case error
-        when OpenURI::HTTPError
-          status = parse_http_status(error)
-          status && !RETRIABLE_HTTP_STATUSES.cover?(status)
-        else
-          RETRIABLE_ERRORS.none? { |klass| error.is_a?(klass) }
-        end
-      end
-
-      def parse_http_status(error)
-        io = error.io
-        return nil unless io
-
-        status = io.status
-        return nil unless status
-
-        status.first.to_i
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end

data/lib/fontisan/tasks.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Fontisan
-  # Tasks supporting the developer workflow: fixture downloads, etc.
-  # Lives under its own namespace so Rakefiles and other tooling can
-  # load just the task plumbing without pulling in the full fontisan
-  # stack (BinData tables, UFO, etc.).
-  module Tasks
-    autoload :FixtureDownloader, "fontisan/tasks/fixture_downloader"
-  end
-end