fontisan 0.4.9 → 0.4.11

data/lib/fontisan/stitcher/partition_strategy/by_script.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    module PartitionStrategy
+      # Partition codepoints by Unicode script property.
+      #
+      # Each non-empty script becomes one or more partitions. Scripts
+      # that overflow +cap+ are chunked (Han has 80k+ codepoints) —
+      # chunks are named +:script_<name>_a+, +:script_<name>_b+, etc.,
+      # matching ByPlane's sub-split convention.
+      #
+      # Codepoints whose script is unknown (unassigned blocks) fall
+      # into +:script_other+. Codepoints in the +Common+ script
+      # (digits, punctuation shared across scripts) and +Inherited+
+      # script (combining marks) get their own buckets — they're
+      # typically useful as standalone subfonts.
+      #
+      # The script data is derived from {ByBlock::BLOCKS}: each Unicode
+      # block maps to exactly one primary script (with a few exceptions
+      # that we resolve explicitly). This keeps the data DRY — the
+      # authoritative block list lives in one place.
+      class ByScript < Base
+        # Maps each Unicode block label to its primary script.
+        # Block labels match ByBlock::BLOCKS keys.
+        #
+        # Special scripts:
+        #   - +:common+ — shared across scripts (digits, punctuation)
+        #   - +:inherited+ — combining marks that inherit the base char's script
+        #   - +:other+ — fallback for unlisted blocks
+        SCRIPT_OF_BLOCK = {
+          # Latin family
+          "Basic_Latin" => :common,
+          "Latin-1_Supplement" => :latin,
+          "Latin_Extended-A" => :latin,
+          "Latin_Extended-B" => :latin,
+          "Latin_Extended-C" => :latin,
+          "Latin_Extended-D" => :latin,
+          "Latin_Extended-E" => :latin,
+          "Latin_Extended-F" => :latin,
+          "Latin_Extended_Additional" => :latin,
+          "Phonetic_Extensions" => :latin,
+          "Phonetic_Extensions_Supplement" => :latin,
+          "Modifier_Tone_Letters" => :latin,
+          "Spacing_Modifier_Letters" => :common,
+          "Combining_Diacritical_Marks" => :inherited,
+          "Combining_Diacritical_Marks_Extended" => :inherited,
+          "Combining_Diacritical_Marks_Supplement" => :inherited,
+          "Combining_Diacritical_Marks_for_Symbols" => :inherited,
+          "Combining_Half_Marks" => :inherited,
+
+          # Greek
+          "Greek_and_Coptic" => :greek,
+          "Greek_Extended" => :greek,
+
+          # Cyrillic
+          "Cyrillic" => :cyrillic,
+          "Cyrillic_Supplement" => :cyrillic,
+          "Cyrillic_Extended-A" => :cyrillic,
+          "Cyrillic_Extended-B" => :cyrillic,
+          "Cyrillic_Extended-C" => :cyrillic,
+          "Cyrillic_Extended-D" => :cyrillic,
+
+          # Middle Eastern
+          "Armenian" => :armenian,
+          "Hebrew" => :hebrew,
+          "Arabic" => :arabic,
+          "Arabic_Supplement" => :arabic,
+          "Arabic_Extended-A" => :arabic,
+          "Arabic_Extended-B" => :arabic,
+          "Arabic_Extended-C" => :arabic,
+          "Arabic_Extended-D" => :arabic,
+          "Arabic_Presentation_Forms-A" => :arabic,
+          "Arabic_Presentation_Forms-B" => :arabic,
+          "Syriac" => :syriac,
+          "Syriac_Supplement" => :syriac,
+          "Thaana" => :thaana,
+          "Samaritan" => :samaritan,
+          "Mandaic" => :mandaic,
+
+          # Indic
+          "Devanagari" => :devanagari,
+          "Devanagari_Extended" => :devanagari,
+          "Bengali" => :bengali,
+          "Gurmukhi" => :gurmukhi,
+          "Gujarati" => :gujarati,
+          "Oriya" => :oriya,
+          "Tamil" => :tamil,
+          "Tamil_Supplement" => :tamil,
+          "Telugu" => :telugu,
+          "Kannada" => :kannada,
+          "Malayalam" => :malayalam,
+          "Sinhala" => :sinhala,
+          "Sinhala_Archaic_Numbers" => :sinhala,
+          "Vedic_Extensions" => :inherited,
+
+          # Southeast Asian
+          "Thai" => :thai,
+          "Lao" => :lao,
+          "Tibetan" => :tibetan,
+          "Myanmar" => :myanmar,
+          "Myanmar_Extended-A" => :myanmar,
+          "Myanmar_Extended-B" => :myanmar,
+          "Myanmar_Extended-C" => :myanmar,
+          "Khmer" => :khmer,
+          "Khmer_Symbols" => :khmer,
+          "Tagalog" => :tagalog,
+          "Hanunoo" => :hanunoo,
+          "Buhid" => :buhid,
+          "Tagbanwa" => :tagbanwa,
+
+          # Hangul
+          "Hangul_Jamo" => :hangul,
+          "Hangul_Compatibility_Jamo" => :hangul,
+          "Hangul_Jamo_Extended-A" => :hangul,
+          "Hangul_Jamo_Extended-B" => :hangul,
+          "Hangul_Syllables" => :hangul,
+
+          # CJK — Han + native Japanese / Korean
+          "CJK_Unified_Ideographs" => :han,
+          "CJK_Unified_Ideographs_Extension_A" => :han,
+          "CJK_Unified_Ideographs_Extension_B" => :han,
+          "CJK_Unified_Ideographs_Extension_C" => :han,
+          "CJK_Unified_Ideographs_Extension_D" => :han,
+          "CJK_Unified_Ideographs_Extension-E" => :han,
+          "CJK_Unified_Ideographs_Extension-F" => :han,
+          "CJK_Unified_Ideographs_Extension_G" => :han,
+          "CJK_Unified_Ideographs_Extension_H" => :han,
+          "CJK_Unified_Ideographs_Extension_I" => :han,
+          "CJK_Compatibility_Ideographs" => :han,
+          "CJK_Compatibility_Ideographs_Supplement" => :han,
+          "CJK_Radicals_Supplement" => :han,
+          "Kangxi_Radicals" => :han,
+          "CJK_Symbols_and_Punctuation" => :common,
+          "CJK_Compatibility" => :han,
+          "CJK_Compatibility_Forms" => :common,
+          "CJK_Strokes" => :han,
+          "Ideographic_Description_Characters" => :common,
+          "Enclosed_CJK_Letters_and_Months" => :common,
+          "Hiragana" => :hiragana,
+          "Katakana" => :katakana,
+          "Katakana_Phonetic_Extensions" => :katakana,
+          "Kana_Supplement" => :hiragana,
+          "Kana_Extended-A" => :hiragana,
+          "Kana_Extended-B" => :hiragana,
+          "Small_Kana_Extension" => :hiragana,
+          "Halfwidth_and_Fullwidth_Forms" => :common,
+          "Vertical_Forms" => :common,
+          "Ideographic_Symbols_and_Punctuation" => :common,
+
+          # Other scripts (single-block each)
+          "Ethiopic" => :ethiopic,
+          "Ethiopic_Supplement" => :ethiopic,
+          "Ethiopic_Extended" => :ethiopic,
+          "Ethiopic_Extended-A" => :ethiopic,
+          "Ethiopian_Extended-B" => :ethiopic,
+          "Cherokee" => :cherokee,
+          "Cherokee_Supplement" => :cherokee,
+          "Unified_Canadian_Aboriginal_Syllabics" => :canadian_aboriginal,
+          "Unified_Canadian_Aboriginal_Syllabics_Extended" => :canadian_aboriginal,
+          "Unified_Canadian_Aboriginal_Syllabics_Extended-A" => :canadian_aboriginal,
+          "Ogham" => :ogham,
+          "Runic" => :runic,
+          "Glagolitic" => :glagolitic,
+          "Glagolitic_Supplement" => :glagolitic,
+          "Tifinagh" => :tifinagh,
+          "Georgian" => :georgian,
+          "Georgian_Supplement" => :georgian,
+          "Georgian_Extended" => :georgian,
+          "Mongolian" => :mongolian,
+          "Mongolian_Supplement" => :mongolian,
+          "Limbu" => :limbu,
+          "Tai_Le" => :tai_le,
+          "New_Tai_Lue" => :new_tai_lue,
+          "Tai_Tham" => :tai_tham,
+          "Tai_Viet" => :tai_viet,
+          "Ol_Chiki" => :ol_chiki,
+          "Bopomofo" => :bopomofo,
+          "Bopomofo_Extended" => :bopomofo,
+          "Yi_Syllables" => :yi,
+          "Yi_Radicals" => :yi,
+          "Vai" => :vai,
+          "Bamum" => :bamum,
+          "Bamum_Supplement" => :bamum,
+          "Syloti_Nagri" => :syloti_nagri,
+          "Phags-pa" => :phags_pa,
+          "Saurashtra" => :saurashtra,
+          "Kayah_Li" => :kayah_li,
+          "Rejang" => :rejang,
+          "Javanese" => :javanese,
+          "Cham" => :cham,
+          "Lepcha" => :lepcha,
+          "Meetei_Mayek" => :meetei_mayek,
+          "Meetei_Mayek_Extensions" => :meetei_mayek,
+          "Lisu" => :lisu,
+          "Lisu_Supplement" => :lisu,
+          "Sundanese" => :sundanese,
+          "Sundanese_Supplement" => :sundanese,
+          "Batak" => :batak,
+          "Buginese" => :buginese,
+          "Ahom" => :ahom,
+          "Dogra" => :dogra,
+          "Tulu-Tigalari" => :tulu_tigalari,
+          "Grantha" => :grantha,
+          "Newa" => :newa,
+          "Tirhuta" => :tirhuta,
+          "Siddham" => :siddham,
+          "Modi" => :modi,
+          "Sharada" => :sharada,
+          "Takri" => :takri,
+          "Kaithi" => :kaithi,
+          "Mahajani" => :mahajani,
+          "Multani" => :multani,
+          "Khudawadi" => :khudawadi,
+          "Nandinagari" => :nandinagari,
+          "Nushu" => :nushu,
+          "Wancho" => :wancho,
+          "Toto" => :toto,
+          "Nag_Mundari" => :nag_mundari,
+
+          # Numerals / symbols (Common)
+          "Superscripts_and_Subscripts" => :common,
+          "Number_Forms" => :common,
+          "Currency_Symbols" => :common,
+          "Letterlike_Symbols" => :common,
+          "Arrows" => :common,
+          "Mathematical_Operators" => :common,
+          "Miscellaneous_Technical" => :common,
+          "Control_Pictures" => :common,
+          "Optical_Character_Recognition" => :common,
+          "Enclosed_Alphanumerics" => :common,
+          "Box_Drawing" => :common,
+          "Block_Elements" => :common,
+          "Geometric_Shapes" => :common,
+          "Miscellaneous_Symbols" => :common,
+          "Dingbats" => :common,
+          "Miscellaneous_Mathematical_Symbols-A" => :common,
+          "Miscellaneous_Mathematical_Symbols-B" => :common,
+          "Supplemental_Arrows-A" => :common,
+          "Supplemental_Arrows-B" => :common,
+          "Supplemental_Arrows-C" => :common,
+          "Supplemental_Mathematical_Operators" => :common,
+          "Miscellaneous_Symbols_and_Arrows" => :common,
+          "Braille_Patterns" => :braille,
+          "General_Punctuation" => :common,
+          "Supplemental_Punctuation" => :common,
+          "Alphabetic_Presentation_Forms" => :common,
+          "Specials" => :common,
+          "Variation_Selectors" => :inherited,
+          "Variation_Selectors_Supplement" => :inherited,
+          "Tags" => :common,
+        }.freeze
+
+        # @param cp_map [Hash{Integer=>Object}] codepoint → donor label
+        # @param cap [Integer] max codepoints per partition
+        # @return [Blueprint]
+        def call(cp_map, cap: DEFAULT_CAP)
+          grouped = group_by_script(cp_map)
+          partitions = []
+
+          grouped.each do |script, entries|
+            chunks(entries, cap).each_with_index do |chunk, idx|
+              partitions << Partition.new(
+                name: partition_name(script, idx),
+                cps: chunk.map(&:first),
+                donor_map: chunk.to_h,
+              )
+            end
+          end
+
+          Blueprint.new(partitions: partitions)
+        end
+
+        private
+
+        def group_by_script(cp_map)
+          cp_map.each_with_object(Hash.new { |h, k| h[k] = [] }) do |(cp, label), h|
+            script = script_of_codepoint(cp)
+            h[script] << [cp, label]
+          end
+        end
+
+        def script_of_codepoint(cp)
+          block_label = ByBlock::BLOCKS.find { |_label, range| range.cover?(cp) }&.first
+          return :other unless block_label
+
+          SCRIPT_OF_BLOCK[block_label] || :other
+        end
+
+        def chunks(entries, cap)
+          entries.each_slice(cap).to_a
+        end
+
+        # First partition per script has no suffix; subsequent ones
+        # get _a, _b, ... matching ByPlane's sub-split convention.
+        def partition_name(script, idx)
+          return :"script_#{script}" if idx.zero?
+
+          suffix = ("a".ord + idx - 1).chr
+          :"script_#{script}_#{suffix}"
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher/partition_strategy.rb

@@ -17,6 +17,8 @@ module Fontisan
       autoload :Blueprint, "fontisan/stitcher/partition_strategy/blueprint"
       autoload :Partition, "fontisan/stitcher/partition_strategy/partition"
       autoload :ByPlane, "fontisan/stitcher/partition_strategy/by_plane"
+      autoload :ByBlock, "fontisan/stitcher/partition_strategy/by_block"
+      autoload :ByScript, "fontisan/stitcher/partition_strategy/by_script"
     end
   end
 end

data/lib/fontisan/stitcher/source.rb

@@ -15,14 +15,49 @@ module Fontisan
     # #bitmap_mode. When a source is :cbdt, the Stitcher propagates
     # the raw CBDT/CBLC tables into the output instead of extracting
     # outlines. The glyph data lives in the bitmap tables, not in glyf.
+    #
+    # = Codepoint remap
+    #
+    # Some donor fonts ship glyphs at non-canonical codepoints — a
+    # keyboard-mapped font whose "A" is at U+0041, or a PUA-allocated
+    # pre-Unicode font. Pass a +remap:+ hash at construction to expose
+    # those glyphs at their canonical codepoints without mutating the
+    # donor font's cmap:
+    #
+    #   Source.new(font, remap: { 0x41 => 0x11DB0 })
+    #
+    # With a remap set, the source answers +gid_for_codepoint+ for the
+    # *target* codepoints (0x11DB0 in the example) by translating them
+    # to the donor's *source* codepoints (0x41). Source codepoints not
+    # listed in the remap are hidden — only the remapped coverage is
+    # exposed. This matches the typical "use this donor for exactly
+    # these output characters" intent, and avoids leaking the donor's
+    # ASCII/PUA noise into the output.
     class Source
       MAX_COMPOUND_DEPTH = 32
 
-      attr_reader :font
+      attr_reader :font, :remap
 
-      def initialize(font)
+      # @param font [TrueTypeFont, OpenTypeFont, Ufo::Font] donor font
+      # @param remap [Hash{Integer=>Integer}, nil] optional
+      #   {source_codepoint => target_codepoint}. When present (even
+      #   empty), source codepoints not listed are hidden from
+      #   lookups. Pass +nil+ (the default) for the passthrough
+      #   behavior — every donor codepoint is exposed as-is.
+      def initialize(font, remap: nil)
         @font = font
         @bin_data_cache = nil
+
+        # Distinguish "no remap kwarg" (nil → passthrough) from
+        # "explicit empty remap" ({} → drop everything). The latter
+        # still flips the source into remapped mode, just with no
+        # entries — every donor codepoint gets filtered out.
+        return unless remap
+
+        @remap = remap.to_h.transform_keys(&:to_i).transform_values(&:to_i)
+        @inverse_remap = @remap.each_with_object({}) do |(src, target), h|
+          h[target] = src
+        end
       end
 
       # @return [Symbol] :ufo, :ttf, :otf
@@ -57,12 +92,21 @@ module Fontisan
       end
 
       # Find the gid for a Unicode codepoint in this source.
+      #
+      # When +remap+ was set at construction, +codepoint+ is treated as
+      # a *target* codepoint — the source codepoint that maps to it via
+      # +remap+ is what actually gets looked up. Returns +nil+ for
+      # codepoints the remap does not cover.
+      #
       # @param codepoint [Integer]
       # @return [Integer, nil]
       def gid_for_codepoint(codepoint)
+        src_cp = source_codepoint_for(codepoint)
+        return nil unless src_cp
+
         case @font
-        when Fontisan::Ufo::Font then ufo_gid_for(codepoint)
-        else bin_data_gid_for(codepoint)
+        when Fontisan::Ufo::Font then ufo_gid_for(src_cp)
+        else bin_data_gid_for(src_cp)
         end
       end
 
@@ -317,14 +361,51 @@ module Fontisan
       end
 
       # Add Unicode codepoints from the cmap that map to this gid.
+      #
+      # When +remap+ was set at construction, the source's raw codepoints
+      # are translated through the remap (source→target), and source
+      # codepoints not in the remap are dropped. Otherwise the raw cmap
+      # codepoints are attached as-is.
       def add_cmap_unicodes(gid, glyph)
-        cmap = @font.table("cmap")
-        return unless cmap
+        effective_codepoints_for_gid(gid).each { |cp| glyph.add_unicode(cp) }
+      end
+
+      # Translate a caller-facing codepoint to the donor's own codepoint.
+      # Without remap, the two are identical. With remap, the caller's
+      # codepoint is the *target*; look up the source codepoint that
+      # maps to it. Returns +nil+ if no remap entry covers the target.
+      def source_codepoint_for(codepoint)
+        return codepoint unless @remap
 
-        (cmap.unicode_mappings || {}).each do |cp, g|
-          glyph.add_unicode(cp) if g == gid
+        @inverse_remap[codepoint]
+      end
+
+      # Codepoints that should be attached to a glyph at the given gid,
+      # after applying the remap (if any).
+      def effective_codepoints_for_gid(gid)
+        raw_cmap = self.raw_cmap
+        raw_cmap.each_with_object([]) do |(src_cp, g), cps|
+          next unless g == gid
+
+          if @remap
+            target = @remap[src_cp]
+            cps << target if target
+          else
+            cps << src_cp
+          end
         end
       end
+
+      # The raw cmap hash from the donor's table. Always {src_cp => gid};
+      # never remapped. UFO sources return {} (no cmap table).
+      def raw_cmap
+        cmap = @font.table("cmap")
+        return {} unless cmap
+
+        cmap.unicode_mappings || {}
+      rescue StandardError
+        {}
+      end
     end
   end
 end

data/lib/fontisan/stitcher.rb

@@ -32,6 +32,7 @@ module Fontisan
     autoload :GlyphLimit,       "fontisan/stitcher/glyph_limit"
     autoload :CollectionResult, "fontisan/stitcher/collection_result"
     autoload :SubfontStats,     "fontisan/stitcher/collection_result"
+    autoload :FormatMetadata,   "fontisan/stitcher/format_metadata"
     autoload :PartitionStrategy, "fontisan/stitcher/partition_strategy"
 
     # Internal: pairs a compiled loaded font with its stats so
@@ -51,8 +52,8 @@ module Fontisan
       @deduplicate = deduplicate
     end
 
-    def add_source(label, font)
-      @sources[label.to_sym] = Source.new(font)
+    def add_source(label, font, remap: nil)
+      @sources[label.to_sym] = Source.new(font, remap: remap)
     end
 
     def include_range(range, from:, into:)
@@ -94,8 +95,8 @@ module Fontisan
       target = build_target_for(subfont)
       GlyphLimit.check!(target.glyphs.size, format: format)
 
-      compiler = compiler_for(format)
-      compiler.new(target).compile(output_path: path)
+      metadata = FormatMetadata.resolve(format)
+      metadata.compiler_class.new(target).compile(output_path: path)
 
       propagate_cbdt_tables(path) if cbdt_source
       path
@@ -109,7 +110,7 @@ module Fontisan
       end
       fonts = compiled.map(&:font)
 
-      collection_format = collection_format_for(format)
+      collection_format = FormatMetadata.resolve(format).collection_format
       Collection::Builder.new(fonts, format: collection_format,
                                      optimize: true).build_to_file(path)
 
@@ -138,20 +139,6 @@ module Fontisan
       cbdts.first
     end
 
-    def compiler_for(format)
-      case format.to_sym
-      when :ttf then Ufo::Compile::TtfCompiler
-      when :otf then Ufo::Compile::OtfCompiler
-      when :otf2 then Ufo::Compile::Otf2Compiler
-      else
-        raise ArgumentError, "unknown format: #{format.inspect}"
-      end
-    end
-
-    def collection_format_for(subfont_format)
-      subfont_format == :ttf ? :ttc : :otc
-    end
-
     def build_target_for(subfont_name)
       bindings = @subfonts[subfont_name] || []
       target = Ufo::Font.new
@@ -161,19 +148,14 @@ module Fontisan
       target
     end
 
-    def compile_subfont_to_loaded_font(subfont_name, format:)
-      compile_subfont_with_stats(subfont_name, format: format).font
-    end
-
     def compile_subfont_with_stats(subfont_name, format:)
       target = build_target_for(subfont_name)
       GlyphLimit.check!(target.glyphs.size, format: format)
 
-      ext = format == :ttf ? ".ttf" : ".otf"
+      metadata = FormatMetadata.resolve(format)
       Dir.mktmpdir do |dir|
-        sub_path = File.join(dir, "sub#{subfont_name}#{ext}")
-        compiler = compiler_for(format)
-        compiler.new(target).compile(output_path: sub_path)
+        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
 
         loaded = Fontisan::FontLoader.load(sub_path)

data/lib/fontisan/subset/table_subsetter.rb

@@ -417,12 +417,130 @@ module Fontisan
       # Creates a minimal cmap table with format 4 subtable for BMP
       # and format 12 for supplementary planes if needed.
       #
-      # @param mappings [Hash<Integer, Integer>] Char code => glyph ID
+      # @param mappings [Hash<Integer, Integer>] Char code => new glyph ID
       # @return [String] Binary cmap data
-      def build_cmap_binary(_mappings)
-        # For now, pass through original cmap
-        # TODO: Implement proper cmap building
-        font.table_data["cmap"]
+      def build_cmap_binary(mappings)
+        # Edge case: empty mappings (e.g., block with no covered chars).
+        # Emit a minimal valid cmap with one format 4 subtable mapping
+        # only U+0000 → .notdef so the table isn't empty.
+        mappings = { 0 => 0 } if mappings.empty?
+
+        bmp = mappings.select { |cp, _| cp <= 0xFFFF }
+        supp = mappings.select { |cp, _| cp > 0xFFFF }
+
+        subtables = []
+        records = [] # [platform_id, encoding_id, subtable_index]
+
+        unless bmp.empty?
+          subtables << build_cmap_format_4(bmp)
+          idx = subtables.size - 1
+          records << [3, 1, idx] # Windows BMP
+          records << [0, 3, idx] # Unicode BMP
+        end
+
+        unless supp.empty?
+          # Format 12 covers both BMP and supplementary — include all
+          # mappings so a single subtable covers the full range.
+          subtables << build_cmap_format_12(mappings)
+          idx = subtables.size - 1
+          records << [3, 10, idx] # Windows UCS-4
+          records << [0, 4, idx]  # Unicode full
+        end
+
+        # Header: version (uint16) + numTables (uint16)
+        num_tables = records.size
+        header = [0, num_tables].pack("nn")
+
+        # Encoding records start immediately after the header.
+        # Each record is 8 bytes; subtables follow.
+        subtable_base = 4 + (8 * num_tables)
+
+        offsets = []
+        running = subtable_base
+        subtables.each do |st|
+          offsets << running
+          running += st.bytesize
+        end
+
+        record_bytes = +""
+        records.each do |pid, eid, idx|
+          record_bytes << [pid, eid, offsets[idx]].pack("nnN")
+        end
+
+        header + record_bytes + subtables.join
+      end
+
+      # Format 4 subtable: segment-mapping with idDelta, suitable for
+      # BMP codepoints (U+0000..U+FFFF). Builds compact segments where
+      # consecutive codepoints map to consecutive glyph IDs.
+      def build_cmap_format_4(bmp_mappings)
+        segments = coalesce_segments(bmp_mappings)
+        # Mandatory final segment: U+FFFF → gid 0 (per OpenType spec).
+        segments << { start_cp: 0xFFFF, end_cp: 0xFFFF, start_gid: 0 }
+
+        seg_count = segments.size
+        seg_count_x2 = seg_count * 2
+        search_range = 2**Math.log2(seg_count).floor * 2
+        search_range = 2 if search_range < 2
+        entry_selector = Math.log2(search_range / 2).to_i
+        range_shift = seg_count_x2 - search_range
+
+        end_codes = segments.map { |s| s[:end_cp] }
+        start_codes = segments.map { |s| s[:start_cp] }
+        # idDelta is int16 stored as uint16 (two's complement). For a
+        # sequential segment, idDelta = (start_gid - start_cp) & 0xFFFF.
+        id_deltas = segments.map { |s| (s[:start_gid] - s[:start_cp]) & 0xFFFF }
+        id_range_offsets = [0] * seg_count
+
+        subtable = +""
+        subtable << [4, 0, 0, seg_count_x2,
+                     search_range, entry_selector, range_shift].pack("n*")
+        subtable << end_codes.pack("n*")
+        subtable << [0].pack("n") # reservedPad
+        subtable << start_codes.pack("n*")
+        subtable << id_deltas.pack("n*")
+        subtable << id_range_offsets.pack("n*")
+
+        # Patch the length field (was placeholder 0).
+        subtable[2, 2] = [subtable.bytesize].pack("n")
+        subtable
+      end
+
+      # Format 12 subtable: segmented coverage for full Unicode range.
+      # Simpler than format 4 — just (start_char, end_char, start_gid)
+      # triples with no delta/offset indirection.
+      def build_cmap_format_12(all_mappings)
+        groups = coalesce_segments(all_mappings)
+        num_groups = groups.size
+
+        subtable = +""
+        subtable << [12, 0, 0, 0, num_groups].pack("nnNNN")
+        groups.each do |g|
+          subtable << [g[:start_cp], g[:end_cp], g[:start_gid]].pack("NNN")
+        end
+
+        # Patch the length field (was placeholder 0). Total length is
+        # 16-byte header + 12 bytes per group.
+        subtable[4, 4] = [subtable.bytesize].pack("N")
+        subtable
+      end
+
+      # Group codepoints into consecutive runs where both codepoint AND
+      # glyph ID are sequential. Each run becomes one segment/group.
+      def coalesce_segments(mappings)
+        sorted = mappings.sort_by { |cp, _| cp }
+        segments = []
+        current = nil
+        sorted.each do |cp, gid|
+          if current && cp == current[:end_cp] + 1 && gid == current[:start_gid] + (cp - current[:start_cp])
+            current[:end_cp] = cp
+          else
+            segments << current if current
+            current = { start_cp: cp, end_cp: cp, start_gid: gid }
+          end
+        end
+        segments << current if current
+        segments
       end
 
       # Build post table version 3.0 (no glyph names)

data/lib/fontisan/svg/font_generator.rb

@@ -28,7 +28,7 @@ module Fontisan
       # @return [TrueTypeFont, OpenTypeFont] Font instance
       attr_reader :font
 
-      # @return [Hash] Glyph data map (glyph_id => {outline, unicode, name, advance})
+      # @return [Hash] Glyph data map (glyph_id => {outline, codepoints, name, advance})
       attr_reader :glyph_data
 
       # @return [Hash] Generation options
@@ -179,7 +179,7 @@ module Fontisan
 
           glyph_generator.generate_glyph_xml(
             data[:outline],
-            unicode: data[:unicode],
+            codepoints: data[:codepoints],
             glyph_name: data[:name],
             advance_width: data[:advance],
             indent: "      ",