fontisan 0.4.21 → 0.4.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55632b625474e82c1cf9573ad6fce2de32f5636823701023abee87fc8817d8fc
-  data.tar.gz: 5a26b3428874b792c101484dbed0468c25eb9f8eb7644a2c0ffff61c8f2baf6a
+  metadata.gz: c7e00355898ff37e38b4948f9a607bf95b96b73df17225c81ebe0b6f6b757b1d
+  data.tar.gz: 9009d6fb96c8168a098236d7b80355749d6c65463376119695ab2a65c20de01d
 SHA512:
-  metadata.gz: e7334f4be856d9a86712a0215c3671c7148d623649d4b81d232aa5f70b8aee71e1e55047a2780f48a7018721026e13dc99f0fff6dcbeda49801f88a832cbf99e
-  data.tar.gz: a6432a0a4db97bdfedd597f5f79f40be36b0fd5d450f21e43319023a85b3e331377b2ee7e002fceb9f90c2e9e9a9ee4c1489ebd25e295058e5605d5be0482f57
+  metadata.gz: 0c82bc6f0d6a871e84d85e4ac6bd51260a39f2b1d373b3055801354c89d99eda1ce3f78ba62ce640e5193eededeba9c8f5101146378124b5d5ac8e5c52bb60c0
+  data.tar.gz: 3e957b040dd2660ce7b8ddea3d4592cfef37ad8d434dd5e43d1be4417459992150fcd414f7547ead7f89a9ad8fd4ea8e01a847eb57ef352a70335e691cb386d6

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-07-08 06:50:36 UTC using RuboCop version 1.86.1.
+# on 2026-07-08 08:05:45 UTC using RuboCop version 1.86.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -12,7 +12,7 @@ Gemspec/RequiredRubyVersion:
     - 'docs/node_modules/speakingurl/speakingurl-rails.gemspec'
     - 'fontisan.gemspec'
 
-# Offense count: 2110
+# Offense count: 2116
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
@@ -88,6 +88,11 @@ Lint/UnusedMethodArgument:
     - 'lib/fontisan/tables/cff2/private_dict_blend_handler.rb'
     - 'lib/fontisan/variation/table_accessor.rb'
     - 'lib/fontisan/woff_font.rb'
+    # Subset strategies share a uniform (context:, tag:, table:) interface
+    # so the dispatcher can call every registered class the same way. Not
+    # every strategy reads every arg; the interface contract justifies the
+    # unused warnings here.
+    - 'lib/fontisan/subset/table_strategy/**/*'
 
 # Offense count: 5
 Lint/UselessConstantScoping:
@@ -95,7 +100,7 @@ Lint/UselessConstantScoping:
     - 'lib/fontisan/conversion_options.rb'
     - 'lib/fontisan/type1/charstrings.rb'
 
-# Offense count: 704
+# Offense count: 705
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
@@ -221,7 +226,7 @@ RSpec/DescribeMethod:
     - 'spec/fontisan/type1/seac_expander_spec.rb'
     - 'spec/fontisan/type1_real_fonts_spec.rb'
 
-# Offense count: 1666
+# Offense count: 1673
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 66
@@ -298,7 +303,7 @@ RSpec/MultipleDescribes:
     - 'spec/fontisan/utils/thread_pool_spec.rb'
     - 'spec/fontisan/variation/cache_spec.rb'
 
-# Offense count: 2103
+# Offense count: 2105
 RSpec/MultipleExpectations:
   Max: 19
 

data/lib/fontisan/config/subset_profiles.yml

@@ -55,6 +55,8 @@ web:
     - glyf
     - GSUB
     - GPOS
+    - CBDT
+    - CBLC
 
 # Minimal Profile: Absolute minimum tables for font rendering
 minimal:

data/lib/fontisan/stitcher/cbdt_propagator.rb

@@ -0,0 +1,173 @@
+# frozen_string: true
+
+module Fontisan
+  class Stitcher
+    # Owns every CBDT-specific concern in the stitch pipeline.
+    #
+    # The Stitcher has two distinct CBDT responsibilities that benefit
+    # from being in one place:
+    #
+    #   1. Detection: exactly one CBDT source per stitch is supported.
+    #      Multiple CBDT sources raise MultipleCbdtSourcesError.
+    #
+    #   2. Action: when a CBDT source exists, the stitcher
+    #      - injects empty CBDT placeholder glyphs into the target UFO
+    #        (the bitmap data lives in CBDT/CBLC tables, not in outlines),
+    #      - propagates the raw CBDT/CBLC tables into the compiled font
+    #        file so the bitmaps survive the round-trip.
+    #
+    # Both responsibilities are model-driven from the CBDT Source itself
+    # (`Source#bitmap_mode == :cbdt`), so the propagator is stateless
+    # given a list of sources. Tests can construct one with synthetic
+    # sources directly.
+    class CbdtPropagator
+      # @param sources [Array<Stitcher::Source>] all sources the stitcher
+      #   knows about, in label order (the propagator does not care
+      #   about labels).
+      def initialize(sources)
+        @sources = sources
+      end
+
+      # @return [Stitcher::Source, nil] the single CBDT source, or nil
+      #   if there is none.
+      # @raise [MultipleCbdtSourcesError] if more than one source is
+      #   marked :cbdt.
+      def cbdt_source
+        cbdts = @sources.select { |s| s.bitmap_mode == :cbdt }
+        return nil if cbdts.empty?
+
+        if cbdts.size > 1
+          raise MultipleCbdtSourcesError,
+                "multiple CBDT sources not supported (found #{cbdts.size})"
+        end
+
+        cbdts.first
+      end
+
+      # Safe variant: returns nil instead of raising when there are
+      # multiple CBDT sources. Used inside the per-subfont glyph-copy
+      # pass where raising mid-compile would leave partial state.
+      #
+      # @return [Stitcher::Source, nil]
+      def safe_cbdt_source
+        cbdt_source
+      rescue MultipleCbdtSourcesError
+        nil
+      end
+
+      # Inject empty CBDT placeholder glyphs from `source` into the
+      # target UFO. One placeholder per gid in the source's maxp/cmap.
+      # Outline data is intentionally absent — the bitmap lives in
+      # the CBDT table that #propagate_tables_into will copy later.
+      #
+      # == Why placeholders are name-deconflicted
+      #
+      # Placeholders are named after the CBDT source's gid ("gid{N}").
+      # Outline donors compiled earlier into the same target use the
+      # SAME naming scheme (see Source#extract_truetype_glyph), so a
+      # CBDT placeholder at "gid110" would collide with an outline
+      # glyph at "gid110" from a different donor. Layer#add raises on
+      # conflict (it never silently overwrites — that path previously
+      # erased real outline glyphs and dropped their cmap entries,
+      # causing the CJK Ext G loss in Essenfont-Regular.ttc). We
+      # allocate a unique name via UniqueGlyphName so each placeholder
+      # lands at its own GID slot without touching the outlines.
+      #
+      # Glyphs are NOT registered with the deduplicator: each CBDT
+      # glyph is unique to its source, and deduplication would
+      # incorrectly collapse distinct bitmaps.
+      #
+      # @param source [Stitcher::Source] the CBDT source
+      # @param target [Ufo::Font] target UFO font to receive placeholders
+      def add_placeholder_glyphs(source, target)
+        ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
+        if ufo
+          ufo.glyphs.each_value do |g|
+            name = UniqueGlyphName.in(target, g.name)
+            target.layers.default_layer.add(GlyphCloner.clone(g, name: name))
+          end
+          return
+        end
+
+        maxp = source.font.table("maxp")
+        num_glyphs = maxp&.num_glyphs || 0
+        cmap = source.font.table("cmap")
+        mappings = cmap&.unicode_mappings || {}
+
+        gid_cps = Hash.new { |h, k| h[k] = [] }
+        mappings.each { |cp, gid| gid_cps[gid] << cp }
+
+        num_glyphs.times do |gid|
+          base_name = gid.zero? ? ".notdef" : "gid#{gid}"
+          name = UniqueGlyphName.in(target, base_name)
+          glyph = Ufo::Glyph.new(name: name)
+          glyph.width = 0
+          gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
+          target.layers.default_layer.add(glyph)
+        end
+      end
+
+      # Propagate the raw CBDT/CBLC tables from the CBDT source into
+      # the compiled font at `path`, rewriting the file in place.
+      #
+      # Reads every table from the compiled font as raw bytes (bypassing
+      # BinData #table because some tables — notably CFF2 — don't yet
+      # have round-trippable BinData models), splices in CBDT/CBLC,
+      # and rewrites the file.
+      #
+      # No-op when called with a non-CBDT source or nil.
+      #
+      # == Limitation: GID stability
+      #
+      # The propagation copies CBDT/CBLC bytes verbatim. CBLC indexes
+      # glyphs by SOURCE GID — the GIDs of the CBDT donor. The compiled
+      # font's GIDs may differ because:
+      #
+      #   1. +add_placeholder_glyphs+ renames CBDT placeholders via
+      #      UniqueGlyphName when their default "gid{N}" name collides
+      #      with outline glyphs sharing the same donor-gid scheme
+      #      (see Layer's naming contract).
+      #   2. The compiler assigns GIDs in target-namespace order, which
+      #      is not the same as source-GID order once renaming happens.
+      #
+      # The bitmaps line up correctly only when the CBDT source and
+      # every outline source cover disjoint codepoint ranges (the
+      # Essenfont TTC case: emoji vs CJK Ext G). When ranges overlap,
+      # CBLC's source-GID-indexed bitmaps may point at the wrong
+      # compiled glyphs and the colour rendering for affected
+      # codepoints will fall back to outlines.
+      #
+      # A proper fix requires a CBLC rebuild pass: walk the compiled
+      # font's cmap to find the new GID for every CBDT-covered source
+      # glyph, then rewrite CBLC's IndexSubTableArray + IndexSubTable
+      # offsets to match. Tracked as a follow-up.
+      #
+      # @param source [Stitcher::Source, nil] the CBDT source
+      # @param path [String] compiled font file to rewrite
+      def propagate_tables_into(source, path)
+        return unless source
+
+        compiled = FontLoader.load(path)
+
+        # Read every table as raw bytes straight from the file's table
+        # directory. We deliberately bypass #table (which parses via
+        # BinData) because some tables — notably CFF2 — don't yet have
+        # round-trippable BinData models; calling #table on them returns
+        # nil and would silently drop them from the rewritten font.
+        tables = {}
+        compiled.table_names.each do |tag|
+          raw = compiled.table_data[tag]
+          tables[tag] = raw if raw
+        end
+
+        cbdt_bytes = source.raw_table_bytes("CBDT")
+        cblc_bytes = source.raw_table_bytes("CBLC")
+        tables["CBDT"] = cbdt_bytes if cbdt_bytes
+        tables["CBLC"] = cblc_bytes if cblc_bytes
+
+        sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
+        FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_cloner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Deep-clone helper for UFO glyphs. Stateless — every call returns
+    # a fresh +Ufo::Glyph+ with copied contours, components, anchors,
+    # and guidelines plus the original's width/height.
+    #
+    # Extracted as a collaborator so +GlyphCopier+ and +CbdtPropagator+
+    # share one implementation of the clone algorithm. Both previously
+    # defined identical +clone_glyph+ / +clone_contour+ private methods
+    # — a DRY violation that risked drifting apart as the glyph model
+    # gained fields.
+    module GlyphCloner
+      # @param original [Ufo::Glyph] glyph to copy
+      # @param name [String, nil] name for the copy; defaults to the
+      #   original's name (used by callers that have already allocated
+      #   a unique name via +UniqueGlyphName+).
+      # @return [Ufo::Glyph] a fresh glyph with the original's geometry
+      #   and metrics, sharing no mutable state with it.
+      def self.clone(original, name: nil)
+        copy = Ufo::Glyph.new(name: name || original.name)
+        copy.width = original.width
+        copy.height = original.height
+        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+        original.components.each { |c| copy.add_component(c) }
+        original.anchors.each { |a| copy.add_anchor(a) }
+        original.guidelines.each { |g| copy.add_guideline(g) }
+        copy
+      end
+
+      def self.clone_contour(original)
+        points = original.points.map do |p|
+          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+        end
+        Ufo::Contour.new(points)
+      end
+      private_class_method :clone_contour
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_copier.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Owns the mechanical concerns of copying glyphs from donor sources
+    # into a target UFO font.
+    #
+    # The Stitcher's per-subfont build needs to:
+    #   - inject a `.notdef` glyph at GID 0
+    #   - copy outline glyphs from donor sources, optionally skipping
+    #     donors the caller names (e.g. the CBDT source, whose glyphs
+    #     take a different code path)
+    #   - register each copied glyph with the deduplicator so visually
+    #     identical glyphs from different donors share a gid
+    #
+    # GlyphCopier centralizes that logic in one stateless-per-call
+    # collaborator. The Stitcher constructs one with a deduplicator and
+    # calls its methods in the order the cmap contract requires
+    # (see Fontisan::Ufo::Compile::Cmap for first-wins semantics).
+    class GlyphCopier
+      # @param deduplicator [Stitcher::Deduplicator, nil] when non-nil,
+      #   visually identical glyphs share a gid in the target. Pass nil
+      #   to disable deduplication.
+      def initialize(deduplicator)
+        @deduplicator = deduplicator
+      end
+
+      # Inject a `.notdef` glyph at GID 0 of `target`.
+      #
+      # If a binding exists with `donor_gid == 0`, copy the donor's
+      # .notdef; otherwise synthesize an empty one. The injected glyph
+      # is registered with the deduplicator so subsequent .notdef
+      # references deduplicate against it.
+      #
+      # @param bindings [Array<Hash>] stitch bindings to search
+      # @param target [Ufo::Font] target UFO
+      def inject_notdef(bindings, target)
+        notdef_binding = bindings.find { |b| b[:donor_gid].zero? }
+        if notdef_binding
+          copy_glyph_into(target, name: ".notdef",
+                                  source: notdef_binding[:source],
+                                  donor_gid: 0)
+        else
+          target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
+        end
+        dedup_target = target.glyphs[".notdef"]
+        @deduplicator&.register(dedup_target, ".notdef") if dedup_target
+      end
+
+      # Copy outline glyphs from `bindings` into `target`, skipping any
+      # sources the caller names (e.g. the CBDT source).
+      #
+      # Bindings are sorted by `[codepoint, donor_gid]` for deterministic
+      # output. For each binding:
+      #   - if deduplicator has seen a visually identical glyph that's
+      #     already in the target, attach the codepoint to that glyph
+      #     (extra unicode mapping);
+      #   - otherwise copy the glyph under a unique name and register
+      #     with the deduplicator.
+      #
+      # @param bindings [Array<Hash>] stitch bindings
+      # @param target [Ufo::Font] target UFO
+      # @param skip_sources [Array<Stitcher::Source>] sources whose
+      #   bindings should be skipped (e.g. CBDT placeholder source)
+      def copy_outlines(bindings, target, skip_sources: [])
+        sorted_bindings(bindings).each do |binding|
+          next if binding[:donor_gid].zero?
+          next if skip_sources.any? { |s| s.equal?(binding[:source]) }
+
+          glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
+          next unless glyph
+
+          canonical = @deduplicator&.find(glyph)
+          if canonical && target.glyphs.key?(canonical)
+            add_extra_unicode(target, canonical, binding[:codepoint])
+          else
+            name = UniqueGlyphName.in(target, glyph.name)
+            copy_glyph_into(target, name: name, source: binding[:source],
+                                    donor_gid: binding[:donor_gid],
+                                    codepoint: binding[:codepoint])
+            @deduplicator&.register(glyph, name)
+          end
+        end
+      end
+
+      private
+
+      def sorted_bindings(bindings)
+        bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
+      end
+
+      def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
+        original = source.glyph_for_gid(donor_gid)
+        return unless original
+
+        copy = GlyphCloner.clone(original, name: name)
+        copy.add_unicode(codepoint) if codepoint
+        target_font.layers.default_layer.add(copy)
+      end
+
+      def add_extra_unicode(target_font, glyph_name, codepoint)
+        return unless codepoint
+
+        glyph = target_font.glyph(glyph_name)
+        glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/unique_glyph_name.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Stateless glyph-name deconfliction for the Stitcher's target UFO.
+    #
+    # The Layer's contract (see +Ufo::Layer+) is that two glyphs cannot
+    # share a name — +#add+ raises on conflict. Most Stitcher call sites
+    # already know the name they want is free (e.g. they just synthesised
+    # it). The two that don't — GlyphCopier (outline donors may share
+    # post-table names) and CbdtPropagator (placeholders named "gid{N}"
+    # collide with outline glyphs sharing the same donor-gid scheme) —
+    # ask this helper to allocate a non-colliding name first.
+    #
+    # Centralising the rule here keeps the deconfliction algorithm in
+    # one place: the suffix-search loop, the separator, the order in
+    # which candidates are tried. Changing the rule (e.g. to a UUID
+    # scheme) is a one-file edit.
+    module UniqueGlyphName
+      # Separator between the base name and the disambiguating suffix.
+      # A literal period so the generated name ("gid110.1") still
+      # reads as a variant of the original.
+      SUFFIX_SEPARATOR = "."
+
+      # @param target [Ufo::Font, #glyphs] the target whose +#glyphs+
+      #   hash is the namespace being deconflicted against. Accepts the
+      #   UFO font directly so callers don't have to dig out the layer.
+      # @param base_name [String, #to_s] the requested name.
+      # @return [String] +base_name+ unchanged if no glyph with that
+      #   name exists in +target.glyphs+; otherwise the first
+      #   +"base.1"+, +"base.2"+, ... that does not exist.
+      def self.in(target, base_name)
+        base = base_name.to_s
+        return base unless target.glyphs.key?(base)
+
+        suffix = 1
+        loop do
+          candidate = "#{base}#{SUFFIX_SEPARATOR}#{suffix}"
+          return candidate unless target.glyphs.key?(candidate)
+
+          suffix += 1
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher.rb

@@ -34,6 +34,10 @@ module Fontisan
     autoload :SubfontStats,     "fontisan/stitcher/collection_result"
     autoload :FormatMetadata,   "fontisan/stitcher/format_metadata"
     autoload :PartitionStrategy, "fontisan/stitcher/partition_strategy"
+    autoload :CbdtPropagator,   "fontisan/stitcher/cbdt_propagator"
+    autoload :GlyphCloner,      "fontisan/stitcher/glyph_cloner"
+    autoload :GlyphCopier,      "fontisan/stitcher/glyph_copier"
+    autoload :UniqueGlyphName,  "fontisan/stitcher/unique_glyph_name"
 
     # Internal: pairs a compiled loaded font with its stats so
     # +write_collection+ can build the collection and the result from a
@@ -98,7 +102,7 @@ module Fontisan
       metadata = FormatMetadata.resolve(format)
       metadata.compiler_class.new(target).compile(output_path: path)
 
-      propagate_cbdt_tables(path) if cbdt_source
+      cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source, path)
       path
     end
 
@@ -129,25 +133,6 @@ module Fontisan
       end
     end
 
-    def cbdt_source
-      cbdts = @sources.values.select { |s| s.bitmap_mode == :cbdt }
-      if cbdts.size > 1
-        raise MultipleCbdtSourcesError,
-              "multiple CBDT sources not supported (found #{cbdts.size})"
-      end
-
-      cbdts.first
-    end
-
-    # Safe variant of #cbdt_source: returns nil instead of raising when
-    # the project has multiple CBDT sources. Used inside the per-subfont
-    # glyph-copy pass where raising mid-compile would leave partial state.
-    def safe_cbdt_source
-      cbdt_source
-    rescue MultipleCbdtSourcesError
-      nil
-    end
-
     def build_target_for(subfont_name)
       bindings = @subfonts[subfont_name] || []
       target = Ufo::Font.new
@@ -165,7 +150,7 @@ module Fontisan
       Dir.mktmpdir do |dir|
         sub_path = File.join(dir, "sub#{subfont_name}#{metadata.extension}")
         metadata.compiler_class.new(target).compile(output_path: sub_path)
-        propagate_cbdt_tables(sub_path) if cbdt_source
+        cbdt_propagator.propagate_tables_into(cbdt_propagator.cbdt_source, sub_path)
 
         loaded = Fontisan::FontLoader.load(sub_path)
         stats = SubfontStats.new(
@@ -178,152 +163,22 @@ module Fontisan
     end
 
     def assign_gids_and_copy_glyphs(bindings, target, deduplicator)
-      cbdt = safe_cbdt_source
+      cbdt = cbdt_propagator.safe_cbdt_source
+      copier = GlyphCopier.new(deduplicator)
 
       # Glyph ordering matters: Cmap.build uses first-wins semantics
       # (Cmap.build docstring), so outline donors must be stitched
       # before CBDT placeholders. Otherwise the empty CBDT placeholder
       # would land at a lower GID and win the cp→gid mapping for any
       # codepoint covered by both donors, hiding the real outline glyph.
-      # CBDT bitmap data still propagates via propagate_cbdt_tables.
-      add_notdef_from(bindings, target, deduplicator)
-      add_outline_glyphs(bindings, target, deduplicator,
-                         skip_sources: cbdt ? [cbdt] : [])
-      add_all_cbdt_glyphs(cbdt, target) if cbdt
-    end
-
-    def add_outline_glyphs(bindings, target, deduplicator, skip_sources:)
-      sorted_bindings(bindings).each do |binding|
-        next if binding[:donor_gid].zero?
-        next if skip_sources.any? { |s| s.equal?(binding[:source]) }
-
-        glyph = binding[:source].glyph_for_gid(binding[:donor_gid])
-        next unless glyph
-
-        canonical = deduplicator&.find(glyph)
-        if canonical && target.glyphs.key?(canonical)
-          add_extra_unicode(target, canonical, binding[:codepoint])
-        else
-          name = unique_target_name(target, glyph.name)
-          copy_glyph_into(target, name: name, source: binding[:source],
-                                  donor_gid: binding[:donor_gid],
-                                  codepoint: binding[:codepoint])
-          deduplicator&.register(glyph, name)
-        end
-      end
-    end
-
-    def sorted_bindings(bindings)
-      bindings.sort_by { |b| [b[:codepoint] || Float::INFINITY, b[:donor_gid]] }
-    end
-
-    def add_notdef_from(bindings, target, deduplicator)
-      notdef_binding = bindings.find { |b| b[:donor_gid].zero? }
-      if notdef_binding
-        copy_glyph_into(target, name: ".notdef",
-                                source: notdef_binding[:source],
-                                donor_gid: 0)
-      else
-        target.layers.default_layer.add(Ufo::Glyph.new(name: ".notdef"))
-      end
-      dedup_target = target.glyphs[".notdef"]
-      deduplicator&.register(dedup_target, ".notdef") if dedup_target
-    end
-
-    def copy_glyph_into(target_font, name:, source:, donor_gid:, codepoint: nil)
-      original = source.glyph_for_gid(donor_gid)
-      return unless original
-
-      copy = clone_glyph(original, name: name)
-      copy.add_unicode(codepoint) if codepoint
-      target_font.layers.default_layer.add(copy)
-    end
-
-    def add_extra_unicode(target_font, glyph_name, codepoint)
-      return unless codepoint
-
-      glyph = target_font.glyph(glyph_name)
-      glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
+      # CBDT bitmap data still propagates via CbdtPropagator.
+      copier.inject_notdef(bindings, target)
+      copier.copy_outlines(bindings, target, skip_sources: cbdt ? [cbdt] : [])
+      cbdt_propagator.add_placeholder_glyphs(cbdt, target) if cbdt
     end
 
-    def unique_target_name(target_font, base_name)
-      return base_name unless target_font.glyphs.key?(base_name)
-
-      suffix = 1
-      loop do
-        candidate = "#{base_name}.#{suffix}"
-        return candidate unless target_font.glyphs.key?(candidate)
-
-        suffix += 1
-      end
-    end
-
-    def clone_glyph(original, name:)
-      copy = Ufo::Glyph.new(name: name)
-      copy.width = original.width
-      copy.height = original.height
-      original.contours.each { |c| copy.add_contour(clone_contour(c)) }
-      original.components.each { |c| copy.add_component(c) }
-      original.anchors.each { |a| copy.add_anchor(a) }
-      original.guidelines.each { |g| copy.add_guideline(g) }
-      copy
-    end
-
-    def clone_contour(original)
-      points = original.points.map do |p|
-        Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
-      end
-      Ufo::Contour.new(points)
-    end
-
-    def propagate_cbdt_tables(path)
-      source = cbdt_source
-      return unless source
-
-      compiled = Fontisan::FontLoader.load(path)
-
-      # Read every table as raw bytes straight from the file's table
-      # directory. We deliberately bypass #table (which parses via
-      # BinData) because some tables — notably CFF2 — don't yet have
-      # round-trippable BinData models; calling #table on them returns
-      # nil and would silently drop them from the rewritten font.
-      tables = {}
-      compiled.table_names.each do |tag|
-        raw = compiled.table_data[tag]
-        tables[tag] = raw if raw
-      end
-
-      cbdt_bytes = source.raw_table_bytes("CBDT")
-      cblc_bytes = source.raw_table_bytes("CBLC")
-      tables["CBDT"] = cbdt_bytes if cbdt_bytes
-      tables["CBLC"] = cblc_bytes if cblc_bytes
-
-      sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
-      Fontisan::FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
-    end
-
-    def add_all_cbdt_glyphs(source, target)
-      ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
-      if ufo
-        ufo.glyphs.each_value { |g| target.layers.default_layer.add(clone_glyph(g, name: g.name)) }
-        return
-      end
-
-      maxp = source.font.table("maxp")
-      num_glyphs = maxp&.num_glyphs || 0
-      cmap = source.font.table("cmap")
-      mappings = cmap&.unicode_mappings || {}
-
-      gid_cps = Hash.new { |h, k| h[k] = [] }
-      mappings.each { |cp, gid| gid_cps[gid] << cp }
-
-      num_glyphs.times do |gid|
-        name = gid.zero? ? ".notdef" : "gid#{gid}"
-        glyph = Ufo::Glyph.new(name: name)
-        glyph.width = 0
-        gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
-        target.layers.default_layer.add(glyph)
-      end
+    def cbdt_propagator
+      @cbdt_propagator ||= CbdtPropagator.new(@sources.values)
     end
   end
 end