fontisan 0.4.32 → 0.4.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e6bea227da5d5c91a615e71d69d65cd7f8c98b7f374719e0f81da4cccc65c4c
-  data.tar.gz: f38990f5900782d7881a2a4b676d09c1f656599f1281bb63086ed0f4be975d9b
+  metadata.gz: b16e0b97aeb7431384ce5f50ff3e4dfd8977b863ec76655ef09e6d53fefddc3c
+  data.tar.gz: b60547f43a45309f700f4a11bb67d36788cfde286de179b697a7fbfc3d43a897
 SHA512:
-  metadata.gz: 2094827e33d51d8352391ff13ca61b450b17e51a6b588ae3ea4844b4ffd05d0e2845c1c031616af0ae140488367ddcc29cbedc2d808053d006063d9d53f803ba
-  data.tar.gz: cbb253b31ba6f06442c3b08eda2acb046f26546652b80fa5b28140144ffeba415bdb92b9a9f4ef6db7398acd15364df1f800dfcf6ba5d19c899ea3b509f69317
+  metadata.gz: c5b05277f8c003e64537cfeb57eb933b8e34f26449acc86de639b1ed90e8b344e502f0a8181417c92de1b8d4c51ffbd98ed9ccacf04ae38b4ff5e0deeb6e80b4
+  data.tar.gz: ee1631c92ebf6a5fd7ba66c4f40bef089a8725560f08d013fd16dfafed46e6c8c3890d35128ded48d03c996f6a547bac1f2d8c17939a12bf5a429bd6ac9a1f58

data/TODO.improvements/README.md

@@ -8,7 +8,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 ### P0 — Correctness gaps (open bugs / silent failures)
 - [x] ~~[01 — CBDT/CBLC GID-stable propagation](01-cbdt-cblc-gid-stable-propagation.md)~~ ✓ Done (PR #115)
 - [x] ~~[02 — Collection-mode outline-priority regression](02-collection-outline-priority.md)~~ ✓ Already fixed
-- [15 — CFF/CFF2 subsetter strategy](15-cff-cff2-subsetter-strategy.md) — Head crash fixed, profiles updated; CFF→UFO extraction done (TODO #10b); blocked on TODO #05 for full round-trip (PR #108 unskipped the test; now passing with TODO 01)
+- [x] ~~[15 — CFF/CFF2 subsetter strategy](15-cff-cff2-subsetter-strategy.md)~~ ✓ Done — CFF via UFO round-trip, CFF2 via standalone INDEX filter with VStore preservation
 
 ### P1 — High-value features
 - [03 — `fontisan audit` command (identity+style+features lens)](03-fontisan-audit-command.md)
@@ -18,7 +18,7 @@ Each file is `NN-short-name.md` where `NN` is the priority order.
 ### P2 — Specialist feature parity
 - [x] ~~[07 — CPAL v1 header fields](07-cpal-v1-header-fields.md)~~ ✓ Done (v0.4.25)
 - [x] ~~[08 — CFF standard string table](08-cff-standard-string-table.md)~~ ✓ Done (full 391 SIDs per Adobe TN 5176)
-- [06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)
+- [x] ~~[06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)~~ ✓ Done — `Cff2.build_variable` emits blend operators in charstrings; `VariableOtf` passes masters through; VStore embedded with regions
 - [09 — Type 1 seac expansion](09-type1-seac-expansion.md)
 - [10 — UFO image set + feature writers](10-ufo-image-set-feature-writers.md)
 - [x] ~~[11 — kern groups.plist support](11-kern-groups-plist.md)~~ ✓ Done (Groups model in PR #116 + GPOS group resolution in this PR)

data/lib/fontisan/subset/table_strategy/cff2.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CFF2 (Compact Font Format 2) subsetter strategy.
+      #
+      # Subsets CFF2 tables by filtering the CharStrings INDEX and FDSelect
+      # to the subset glyphs, then rebuilding the table with patched offsets.
+      # The Variable Store (ItemVariationStore) is preserved unchanged —
+      # its `vsindex` references in charstrings remain valid because
+      # charstrings are carried as opaque bytes.
+      #
+      # Unlike the CFF1 subsetter (which routes through UFO), CFF2 uses a
+      # standalone binary filter because CFF2 charstrings carry blend/vsindex
+      # operators for variation that the UFO round-trip would strip.
+      #
+      # Layout of the rebuilt table:
+      #
+      #   Header (5 bytes)
+      #   Top DICT               (offsets patched to new positions)
+      #   Global Subr INDEX      (preserved as-is)
+      #   [Variable Store]       (preserved as-is, if present)
+      #   [FDArray INDEX]        (Private DICT offsets patched)
+      #   [Private DICTs]        (preserved as-is, relocated after FDArray)
+      #   [FDSelect]             (filtered to subset glyphs, if present)
+      #   CharStrings INDEX      (filtered to subset glyphs)
+      #
+      # Private DICT offsets in Font DICTs always use the 5-byte integer
+      # encoding (operator 29 + int32). This makes the FDArray byte size
+      # independent of the offset values, breaking the layout chicken-and-egg.
+      #
+      # See TODO #15 for the full design rationale.
+      class Cff2
+        # CFF2 Top DICT operator codes (per Adobe TN 5177 §8.1).
+        OP_CHARSTRINGS = 17
+        OP_VSTORE = 24
+        OP_FDARRAY = [12, 36].freeze
+        OP_FDSELECT = [12, 37].freeze
+        OP_PRIVATE = 18
+
+        MAX_TOPDICT_ITERATIONS = 16
+
+        # @param context [SubsetContext]
+        # @param tag [String] "CFF2"
+        # @param table [Object] parsed CFF2 table (unused — we read raw bytes)
+        # @return [String] subset CFF2 table bytes
+        def self.call(context:, tag:, table:)
+          raw = raw_bytes_from_font(context.font) || raw_bytes_from_table(table)
+          return raw unless raw && !raw.empty?
+
+          new(raw, context.mapping).subset
+        end
+
+        def self.raw_bytes_from_font(font)
+          t = font.table("CFF2") if font.respond_to?(:table)
+          t&.raw_data
+        end
+        private_class_method :raw_bytes_from_font
+
+        def self.raw_bytes_from_table(table)
+          table&.raw_data if table.respond_to?(:raw_data)
+        end
+        private_class_method :raw_bytes_from_table
+
+        # ------------------------------------------------------------------
+
+        def initialize(raw_data, mapping)
+          @raw = raw_data
+          @mapping = mapping
+          @reader = Tables::Cff2::TableReader.new(raw_data)
+          @reader.read_top_dict
+        end
+
+        # Build the subset CFF2 table.
+        #
+        # @return [String]
+        def subset
+          sections = gather_sections
+          retained_gids = @mapping.old_ids.sort
+
+          filtered = build_filtered_sections(sections, retained_gids)
+          layout = converge_layout(sections, filtered)
+          write_table(layout, filtered)
+        end
+
+        # ------------------------------------------------------------------
+        # Source section gathering
+        # ------------------------------------------------------------------
+
+        def gather_sections
+          td = @reader.top_dict
+          hdr = @reader.header
+          gsubr_off = hdr[:header_size] + hdr[:top_dict_length]
+
+          {
+            header_size: hdr[:header_size],
+            charstrings: read_index(td[OP_CHARSTRINGS]),
+            gsubr: read_index(gsubr_off),
+            fdarray: td[OP_FDARRAY] ? read_index(td[OP_FDARRAY]) : nil,
+            fdselect_offset: td[OP_FDSELECT],
+            vstore_offset: td[OP_VSTORE],
+          }
+        end
+
+        def read_index(offset)
+          Tables::Cff2::Index.read(@raw, offset)
+        end
+
+        # ------------------------------------------------------------------
+        # Section filtering
+        # ------------------------------------------------------------------
+
+        # Build all filtered/rebuilt section bytes.
+        def build_filtered_sections(sections, retained_gids)
+          {
+            charstrings_bytes: filter_charstrings(sections[:charstrings], retained_gids),
+            fdselect_bytes: filter_fdselect(sections, retained_gids),
+            fdarray_entries: sections[:fdarray] ? parse_fdarray_entries(sections[:fdarray]) : [],
+          }
+        end
+
+        # Build a new CharStrings INDEX containing only the retained glyphs.
+        def filter_charstrings(source_cs, retained_gids)
+          items = retained_gids.map do |gid|
+            item = source_cs[gid]
+            item.nil? || item.empty? ? "\x0e".b : item
+          end
+          Tables::Cff2::IndexBuilder.build(items)
+        end
+
+        # Rebuild FDSelect to cover only retained glyphs in their new order.
+        def filter_fdselect(sections, retained_gids)
+          return nil unless sections[:fdselect_offset]
+
+          assignments = Tables::Cff2::FdSelect.read(
+            @raw, sections[:fdselect_offset], sections[:charstrings].count
+          )
+          new_assigns = retained_gids.map { |gid| assignments[gid] || 0 }
+          Tables::Cff2::FdSelect.build(new_assigns)
+        end
+
+        # Parse each Font DICT in the FDArray, extract Private DICT bytes,
+        # and prepare entries for relocation.
+        def parse_fdarray_entries(source_fdarray)
+          source_fdarray.to_a.map do |fd_bytes|
+            parsed = @reader.parse_dict(fd_bytes)
+            priv = parsed[OP_PRIVATE]
+            entry = { parsed: parsed, priv_bytes: nil, priv_size: nil }
+            next entry unless priv.is_a?(Array) && priv.size == 2
+
+            size, offset = priv
+            entry[:priv_bytes] = @raw.byteslice(offset, size)
+            entry[:priv_size] = size
+            entry
+          end
+        end
+
+        # Build the FDArray INDEX bytes with the given Private DICT offsets.
+        # Private offsets always use 5-byte int32 encoding for deterministic
+        # sizing across layout iterations.
+        def build_fdarray_bytes(entries, priv_offsets)
+          rebuilt = entries.each_with_index.map do |entry, idx|
+            parsed = entry[:parsed].dup
+            if entry[:priv_size]
+              parsed[OP_PRIVATE] = [entry[:priv_size], priv_offsets[idx] || 0]
+            end
+            encode_font_dict(parsed)
+          end
+          Tables::Cff2::IndexBuilder.build(rebuilt)
+        end
+
+        # ------------------------------------------------------------------
+        # Layout convergence
+        # ------------------------------------------------------------------
+
+        # Iterate Top DICT encoding to stability, then produce the final
+        # layout with FDArray patched with concrete Private DICT offsets.
+        def converge_layout(sections, filtered)
+          top_dict_size = @reader.header[:top_dict_length]
+          placeholder_offsets = Array.new(filtered[:fdarray_entries].size, 0)
+          fdarray_placeholder = if filtered[:fdarray_entries].any?
+                                  build_fdarray_bytes(filtered[:fdarray_entries],
+                                                      placeholder_offsets)
+                                end
+          priv_bytes = filtered[:fdarray_entries].map { |e| e[:priv_bytes] }.compact
+
+          prev_size = nil
+          layout = nil
+          MAX_TOPDICT_ITERATIONS.times do
+            layout = layout_offsets(sections, top_dict_size, filtered,
+                                    fdarray_placeholder, priv_bytes)
+            new_td = build_top_dict_bytes(layout)
+            top_dict_size = new_td.bytesize
+            break if top_dict_size == prev_size
+
+            prev_size = top_dict_size
+          end
+
+          finalize_layout(layout, sections, top_dict_size, filtered,
+                          fdarray_placeholder, priv_bytes)
+        end
+
+        # Assign byte offsets to every section.
+        def layout_offsets(sections, top_dict_size, filtered, fdarray_bytes, priv_bytes)
+          pos = sections[:header_size] + top_dict_size
+          layout = { top_dict_size: top_dict_size }
+
+          layout[:global_subrs_offset] = pos
+          layout[:global_subrs_bytes] = index_bytes(sections[:gsubr])
+          pos += layout[:global_subrs_bytes].bytesize
+
+          if sections[:vstore_offset]
+            layout[:vstore_offset] = pos
+            layout[:vstore_bytes] = vstore_bytes(sections[:vstore_offset])
+            pos += layout[:vstore_bytes].bytesize
+          end
+
+          if fdarray_bytes
+            layout[:fdarray_offset] = pos
+            layout[:fdarray_bytes] = fdarray_bytes
+            pos += fdarray_bytes.bytesize
+
+            priv_offsets = priv_bytes.map do |pb|
+              off = pos
+              pos += pb.bytesize
+              off
+            end
+            layout[:private_dict_offsets] = priv_offsets
+            layout[:private_dicts] = priv_bytes
+          end
+
+          if filtered[:fdselect_bytes]
+            layout[:fdselect_offset] = pos
+            layout[:fdselect_bytes] = filtered[:fdselect_bytes]
+            pos += layout[:fdselect_bytes].bytesize
+          end
+
+          layout[:charstrings_offset] = pos
+          layout[:charstrings_bytes] = filtered[:charstrings_bytes]
+          layout
+        end
+
+        # Build the Top DICT bytes with updated section offsets.
+        def build_top_dict_bytes(layout)
+          td = @reader.top_dict.dup
+          td[OP_CHARSTRINGS] = layout[:charstrings_offset]
+          td[OP_VSTORE] = layout[:vstore_offset] if layout[:vstore_offset]
+          td[OP_FDARRAY] = layout[:fdarray_offset] if layout[:fdarray_offset]
+          td[OP_FDSELECT] = layout[:fdselect_offset] if layout[:fdselect_offset]
+          encode_dict(td)
+        end
+
+        # Produce the final layout: stabilized Top DICT bytes, header,
+        # and FDArray rebuilt with concrete Private DICT offsets.
+        def finalize_layout(layout, sections, top_dict_size, filtered,
+                            fdarray_placeholder, priv_bytes)
+          final = layout.dup
+          final[:top_dict_bytes] = build_top_dict_bytes(layout)
+          final[:header_bytes] = Tables::Cff2::Header.build(
+            top_dict_size: top_dict_size,
+          )
+          if filtered[:fdarray_entries].any?
+            final[:fdarray_bytes] = build_fdarray_bytes(
+              filtered[:fdarray_entries], final[:private_dict_offsets] || []
+            )
+          end
+          final
+        end
+
+        # ------------------------------------------------------------------
+        # Table serialization
+        # ------------------------------------------------------------------
+
+        def write_table(layout, filtered)
+          io = StringIO.new(+"")
+          io << layout[:header_bytes]
+          io << layout[:top_dict_bytes]
+          io << layout[:global_subrs_bytes]
+          io << layout[:vstore_bytes] if layout[:vstore_bytes]
+          io << layout[:fdarray_bytes] if layout[:fdarray_bytes]
+          (layout[:private_dicts] || []).each { |pd| io << pd }
+          io << layout[:fdselect_bytes] if layout[:fdselect_bytes]
+          io << layout[:charstrings_bytes]
+          io.string
+        end
+
+        # ------------------------------------------------------------------
+        # Binary helpers
+        # ------------------------------------------------------------------
+
+        # Extract the raw bytes of a parsed INDEX from the source table.
+        def index_bytes(index)
+          @raw.byteslice(index.start_offset, index.total_size)
+        end
+
+        # Extract VStore bytes by computing its byte extent.
+        def vstore_bytes(vstore_offset)
+          size = vstore_extent(vstore_offset)
+          @raw.byteslice(vstore_offset, size)
+        end
+
+        # Compute the byte size of an ItemVariationStore.
+        def vstore_extent(vs_off)
+          io = StringIO.new(@raw)
+          io.seek(vs_off)
+          _format = read_u16(io)
+          region_list_off = read_u32(io)
+          data_count = read_u16(io)
+          data_offsets = Array.new(data_count) { read_u32(io) }
+
+          extents = []
+          extents << region_list_end(vs_off + region_list_off) if region_list_off.positive?
+          data_offsets.each do |rel_off|
+            extents << item_variation_data_end(vs_off + rel_off) if rel_off.positive?
+          end
+          end_off = extents.max || (8 + (data_count * 4))
+          end_off - vs_off
+        end
+
+        def region_list_end(abs_off)
+          io = StringIO.new(@raw)
+          io.seek(abs_off)
+          axis_count = read_u16(io)
+          region_count = read_u16(io)
+          abs_off + 4 + (region_count * axis_count * 6)
+        end
+
+        def item_variation_data_end(abs_off)
+          io = StringIO.new(@raw)
+          io.seek(abs_off)
+          item_count = read_u16(io)
+          short_delta_count = read_u16(io)
+          region_index_count = read_u16(io)
+          long_count = region_index_count - short_delta_count
+          delta_set_size = (short_delta_count * 2) + long_count
+          abs_off + 6 + (region_index_count * 2) + (item_count * delta_set_size)
+        end
+
+        def read_u16(io)
+          io.read(2).unpack1("n")
+        end
+
+        def read_u32(io)
+          io.read(4).unpack1("N")
+        end
+
+        # ------------------------------------------------------------------
+        # DICT encoding
+        # ------------------------------------------------------------------
+
+        # Encode a DICT hash to binary using the CFF2 DictEncoder.
+        def encode_dict(dict)
+          io = +""
+          dict.each do |operator, operands|
+            vals = Array(operands)
+            vals.each do |v|
+              io << Tables::Cff2::DictEncoder.encode_integer(v.to_i)
+            end
+            io << Tables::Cff2::DictEncoder.encode_operator(operator)
+          end
+          io
+        end
+
+        # Encode a Font DICT. The Private operator (18) always uses 5-byte
+        # integer encoding for BOTH operands so the Font DICT byte size
+        # is deterministic across layout iterations.
+        def encode_font_dict(parsed)
+          io = +""
+          parsed.each do |operator, operands|
+            vals = Array(operands)
+            if operator == OP_PRIVATE && vals.size == 2
+              io << encode_int32(vals[0].to_i)
+              io << encode_int32(vals[1].to_i)
+            else
+              vals.each { |v| io << Tables::Cff2::DictEncoder.encode_integer(v.to_i) }
+            end
+            io << Tables::Cff2::DictEncoder.encode_operator(operator)
+          end
+          io
+        end
+
+        # 5-byte integer encoding: byte 29 (marker) + 4-byte big-endian.
+        def encode_int32(value)
+          [29, value].pack("CN")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy.rb

@@ -17,6 +17,7 @@ module Fontisan
       autoload :Cblc, "fontisan/subset/table_strategy/cblc"
       autoload :Cbdt, "fontisan/subset/table_strategy/cbdt"
       autoload :Cff, "fontisan/subset/table_strategy/cff"
+      autoload :Cff2, "fontisan/subset/table_strategy/cff2"
       autoload :Cmap, "fontisan/subset/table_strategy/cmap"
       autoload :ColorBitmapPlacement,
                "fontisan/subset/table_strategy/color_bitmap_placement"
@@ -57,6 +58,7 @@ module Fontisan
         "head" => :Head,
         "OS/2" => :Os2,
         "CFF " => :Cff,
+        "CFF2" => :Cff2,
         "CBDT" => :Cbdt,
         "CBLC" => :Cblc,
       }.freeze

data/lib/fontisan/tables/cff/cff2_charstring_builder.rb

@@ -73,8 +73,11 @@ width: nil)
           @num_regions = num_regions
           @has_blend = false
 
-          outline.commands.each_with_index do |cmd, i|
-            master_cmds = master_outlines.map { |mo| mo.commands[i] }
+          commands = outline.to_cff_commands
+          master_commands = master_outlines.map(&:to_cff_commands)
+
+          commands.each_with_index do |cmd, i|
+            master_cmds = master_commands.map { |mc| mc[i] }
             encode_variable_command(cmd, master_cmds)
           end
 

data/lib/fontisan/tables/cff2/fd_select.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 module Fontisan
   module Tables
     class Cff2
@@ -17,10 +19,81 @@ module Fontisan
       #
       # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
       class FdSelect
+        # Read an FDSelect subtable and return the flat FD-index array
+        # (one entry per glyph).
+        #
+        # @param raw_data [String] full CFF2 table bytes
+        # @param offset [Integer] byte offset of the FDSelect
+        # @param num_glyphs [Integer] glyph count (from maxp)
+        # @return [Array<Integer>] FD index per glyph
+        def self.read(raw_data, offset, num_glyphs)
+          io = StringIO.new(raw_data)
+          io.seek(offset)
+          format = io.read(1).unpack1("C")
+
+          case format
+          when 0 then read_format0(io, num_glyphs)
+          when 3 then read_format3(io, num_glyphs)
+          when 4 then read_format4(io, num_glyphs)
+          else
+            raise CorruptedTableError, "unsupported FDSelect format: #{format}"
+          end
+        end
+
+        # Format 0: uint8 fd_index[numGlyphs]
+        def self.read_format0(io, num_glyphs)
+          io.read(num_glyphs).unpack("C*")
+        end
+        private_class_method :read_format0
+
+        # Format 3: uint16 numRanges, Range3[], uint16 sentinel
+        def self.read_format3(io, num_glyphs)
+          num_ranges = io.read(2).unpack1("n")
+          assignments = Array.new(num_glyphs, 0)
+          ranges = Array.new(num_ranges) do
+            first = io.read(2).unpack1("n")
+            fd = io.read(1).unpack1("C")
+            [first, fd]
+          end
+          sentinel = io.read(2).unpack1("n")
+
+          ranges.each_cons(2) do |(first, fd), (next_first, _)|
+            assignments.fill(fd, first, next_first - first)
+          end
+          if ranges.any?
+            last_first, last_fd = ranges.last
+            assignments.fill(last_fd, last_first, sentinel - last_first)
+          end
+          assignments
+        end
+        private_class_method :read_format3
+
+        # Format 4: uint32 numRanges, Range4[], uint32 sentinel
+        def self.read_format4(io, num_glyphs)
+          num_ranges = io.read(4).unpack1("N")
+          assignments = Array.new(num_glyphs, 0)
+          ranges = Array.new(num_ranges) do
+            first = io.read(4).unpack1("N")
+            fd = io.read(2).unpack1("n")
+            [first, fd]
+          end
+          sentinel = io.read(4).unpack1("N")
+
+          ranges.each_cons(2) do |(first, fd), (next_first, _)|
+            assignments.fill(fd, first, next_first - first)
+          end
+          if ranges.any?
+            last_first, last_fd = ranges.last
+            assignments.fill(last_fd, last_first, sentinel - last_first)
+          end
+          assignments
+        end
+        private_class_method :read_format4
+
         # @param assignments [Array<Integer>] FD index per glyph (length = numGlyphs)
         # @return [String] FDSelect bytes in the most compact format
         def self.build(assignments)
-          return 0.to_s if assignments.empty?
+          return [0].pack("C").to_s + "".b if assignments.empty?
 
           format0_bytes(assignments)
         end

data/lib/fontisan/tables/cff2/index.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    class Cff2
+      # Reads a CFF2 INDEX structure.
+      #
+      # A CFF2 INDEX uses a 4-byte count (Card32) instead of the
+      # 2-byte count (Card16) used by CFF1. Otherwise the layout is
+      # the same: count, offSize, offset array (1-based), then data.
+      #
+      # An empty INDEX is just the 4-byte count field (= 0).
+      #
+      # @example
+      #   idx = Cff2::Index.read(raw_cff2_bytes, charstrings_offset)
+      #   idx[0]  # first item
+      #   idx.count
+      #   idx.total_size
+      class Index
+        include Enumerable
+
+        attr_reader :count, :off_size, :offsets, :data, :start_offset
+
+        # Read a CFF2 INDEX at +offset+ within +raw_data+.
+        #
+        # @param raw_data [String] full CFF2 table bytes
+        # @param offset [Integer] byte offset of the INDEX
+        def self.read(raw_data, offset)
+          io = StringIO.new(raw_data)
+          io.seek(offset)
+          new(io, offset)
+        end
+
+        # Build an INDEX from a list of data items.
+        # Delegates to {IndexBuilder}.
+        #
+        # @param items [Array<String>]
+        # @return [String] binary INDEX bytes
+        def self.build(items)
+          IndexBuilder.build(items)
+        end
+
+        # @param io [IO, StringIO] positioned at the INDEX start
+        # @param start_offset [Integer] byte offset (for diagnostics)
+        def initialize(io, start_offset = 0)
+          @io = io
+          @start_offset = start_offset
+          parse!
+        end
+
+        # Fetch the item at +index+ (0-based).
+        #
+        # @return [String, nil] binary data, or nil if out of range
+        def [](index)
+          return nil if index.negative? || index >= count
+          return "".b if count.zero?
+
+          start_pos = offsets[index] - 1
+          end_pos = offsets[index + 1] - 1
+          data[start_pos, end_pos - start_pos]
+        end
+
+        # Iterate over all items.
+        def each
+          return enum_for(:each) unless block_given?
+
+          count.times { |i| yield self[i] }
+        end
+
+        # All items as an array.
+        def to_a
+          Array.new(count) { |i| self[i] }
+        end
+
+        def empty?
+          count.zero?
+        end
+
+        # Total size of the INDEX in bytes (count + offSize + offsets + data).
+        def total_size
+          return 4 if count.zero?
+
+          4 + 1 + ((count + 1) * off_size) + data.bytesize
+        end
+
+        private
+
+        def parse!
+          @count = read_uint32
+
+          if @count.zero?
+            @off_size = 0
+            @offsets = []
+            @data = "".b
+            return
+          end
+
+          @off_size = read_uint8
+          raise CorruptedTableError, "invalid CFF2 offSize: #{@off_size}" unless (1..4).cover?(@off_size)
+
+          @offsets = Array.new(@count + 1) { read_offset(@off_size) }
+          validate_offsets!
+
+          data_size = @offsets.last - 1
+          @data = read_bytes(data_size)
+        end
+
+        def read_uint32
+          read_bytes(4).unpack1("N")
+        end
+
+        def read_uint8
+          read_bytes(1).unpack1("C")
+        end
+
+        def read_offset(size)
+          bytes = read_bytes(size)
+          case size
+          when 1 then bytes.unpack1("C")
+          when 2 then bytes.unpack1("n")
+          when 3 then bytes.unpack("C3").inject(0) { |s, b| (s << 8) | b }
+          when 4 then bytes.unpack1("N")
+          end
+        end
+
+        def read_bytes(n)
+          return "".b if n.zero?
+
+          bytes = @io.read(n)
+          if bytes.nil? || bytes.bytesize < n
+            raise CorruptedTableError,
+                  "unexpected EOF in CFF2 INDEX at offset #{@start_offset}"
+          end
+
+          bytes
+        end
+
+        def validate_offsets!
+          unless @offsets.first == 1
+            raise CorruptedTableError,
+                  "CFF2 INDEX first offset must be 1, got #{@offsets.first}"
+          end
+
+          @offsets.each_cons(2) do |prev, curr|
+            next unless curr < prev
+
+            raise CorruptedTableError, "CFF2 INDEX offsets not ascending"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff2/table_reader.rb

@@ -235,25 +235,7 @@ module Fontisan
           Cff::Index.new(@io, start_offset: offset)
         end
 
-        private
-
-        # Read bytes safely with EOF checking
-        #
-        # @param bytes [Integer] Number of bytes to read
-        # @param description [String] Description for error messages
-        # @return [String] Binary data
-        # @raise [EOFError] If not enough bytes available
-        def read_safely(bytes, description)
-          data = @io.read(bytes)
-          if data.nil? || data.bytesize < bytes
-            raise EOFError,
-                  "Unexpected EOF while reading #{description}"
-          end
-
-          data
-        end
-
-        # Parse DICT structure
+        # Parse a DICT structure (public: reused by the CFF2 subsetter).
         #
         # @param data [String] DICT binary data
         # @return [Hash] Parsed operators and values
@@ -281,20 +263,37 @@ module Fontisan
           dict
         end
 
+        private
+
+        # Read bytes safely with EOF checking
+        #
+        # @param bytes [Integer] Number of bytes to read
+        # @param description [String] Description for error messages
+        # @return [String] Binary data
+        # @raise [EOFError] If not enough bytes available
+        def read_safely(bytes, description)
+          data = @io.read(bytes)
+          if data.nil? || data.bytesize < bytes
+            raise EOFError,
+                  "Unexpected EOF while reading #{description}"
+          end
+
+          data
+        end
+
         # Check if byte is an operator
         #
-        # CFF2 extends the operator range to include operator 24 (vstore)
+        # CFF/CFF2 DICT operator bytes are 0-21 (with 12 as the two-byte
+        # escape prefix) and 24 (vstore, CFF2-specific). Number encoding
+        # prefixes (28, 29, 30) and ranges (32-254) are NOT operators.
         #
         # @param byte [Integer] Byte value
         # @return [Boolean] True if operator
         def operator_byte?(byte)
-          # Standard DICT operators (0-21, excluding number markers)
-          return true if byte <= 21 && ![12, 28, 29, 30, 31].include?(byte)
-
-          # CFF2-specific operators
-          return true if byte == VSTORE_OPERATOR
+          return false if (28..30).cover?(byte) # number prefixes
+          return false if (32..254).cover?(byte) # number ranges
 
-          false
+          true # 0-27 (incl. 12 escape), 31, 255 — treat as operator
         end
 
         # Read DICT operator

data/lib/fontisan/tables/cff2.rb

@@ -26,6 +26,7 @@ module Fontisan
       autoload :CharstringParser, "fontisan/tables/cff2/charstring_parser"
       autoload :FdSelect, "fontisan/tables/cff2/fd_select"
       autoload :Header, "fontisan/tables/cff2/header"
+      autoload :Index, "fontisan/tables/cff2/index"
       autoload :IndexBuilder, "fontisan/tables/cff2/index_builder"
       autoload :DictEncoder, "fontisan/tables/cff2/dict_encoder"
       autoload :OperandStack, "fontisan/tables/cff2/operand_stack"

data/lib/fontisan/ufo/compile/cff2.rb

@@ -33,42 +33,143 @@ module Fontisan
 
         # @param font [Fontisan::Ufo::Font]
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @param masters [Array<Hash>, nil] variation masters for variable
+        #   CFF2. Each hash: { font:, axes: }. When present, charstrings
+        #   emit blend operators and a VariationStore is embedded.
+        # @param axis_count [Integer, nil] number of variation axes
         # @param variation_store [String, nil] ItemVariationStore bytes
         #   for variable CFF2 fonts. When present, embedded between the
         #   GlobalSubr INDEX and CharStrings INDEX, and referenced from
         #   the Top DICT via operator 24.
         # @return [String] CFF2 table bytes
-        def self.build(_font, glyphs:, variation_store: nil)
+        def self.build(font, glyphs:, masters: nil, axis_count: nil,
+                       variation_store: nil)
+          if masters&.any?
+            build_variable(font, glyphs, masters, axis_count)
+          else
+            build_static(font, glyphs, variation_store:)
+          end
+        end
+
+        # Build a static CFF2 table (no variation data).
+        def self.build_static(font, glyphs, variation_store:)
           charstrings = glyphs.map { |g| charstring_for(g) }
           global_subr_index = empty_global_subr_index
           font_dict = build_font_dict(private_size: 0, private_offset: 0)
           font_dict_index = Tables::Cff2::IndexBuilder.build([font_dict])
           vs_bytes = variation_store&.b
 
-          # Fixed-point iteration: encode Top DICT, compute offsets, repeat.
-          top_dict = encode_top_dict(
-            charstrings_offset: 0, font_dict_index_offset: 0,
-            variation_store_offset: vs_bytes ? 0 : nil
+          layout = converge_layout(
+            charstrings:, global_subr_index:, font_dict_index:,
+            variation_store: vs_bytes
           )
-          layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
-                                  font_dict_index:, variation_store: vs_bytes)
+          assemble(layout:)
+        end
 
-          10.times do
-            top_dict = encode_top_dict(
-              charstrings_offset: layout[:charstrings_offset],
-              font_dict_index_offset: layout[:font_dict_index_offset],
-              variation_store_offset: layout[:variation_store_offset],
-            )
-            next_layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
-                                         font_dict_index:, variation_store: vs_bytes)
-            break if same_offsets?(layout, next_layout)
+        # Build a variable CFF2 table with blend operators and a VStore.
+        #
+        # Each glyph gets a variable charstring with blend operators when
+        # master outlines are available for it. Glyphs without masters fall
+        # back to static charstrings. The VStore contains one region per
+        # master, each peaking at the master's axis location.
+        def self.build_variable(font, glyphs, masters, axis_count)
+          num_regions = masters.size
+          vstore = build_variation_store(masters, axis_count)
 
-            layout = next_layout
+          master_glyph_sets = masters.map do |m|
+            { font: m[:font], by_name: m[:font].glyphs }
+          end
+
+          charstrings = glyphs.map.with_index do |glyph, _idx|
+            master_outlines = master_glyph_sets.filter_map do |mg|
+              mg[:by_name][glyph.name]&.to_outline
+            end
+
+            if master_outlines.size == num_regions && glyph.contours.any?
+              Tables::Cff::Cff2CharStringBuilder.build_variable(
+                glyph.to_outline,
+                master_outlines: master_outlines,
+                num_regions: num_regions,
+                width: glyph.width.to_i,
+              )
+            else
+              charstring_for(glyph)
+            end
           end
 
+          global_subr_index = empty_global_subr_index
+          font_dict = build_font_dict(private_size: 0, private_offset: 0)
+          font_dict_index = Tables::Cff2::IndexBuilder.build([font_dict])
+
+          layout = converge_layout(
+            charstrings:, global_subr_index:, font_dict_index:,
+            variation_store: vstore
+          )
           assemble(layout:)
         end
 
+        # Build the ItemVariationStore for CFF2: one region per master,
+        # each peaking at the master's axis location.
+        def self.build_variation_store(masters, axis_count)
+          ac = axis_count || masters.first&.dig(:axes)&.size || 1
+          regions = masters.each_with_index.map do |_master, midx|
+            Array.new(ac) do |aidx|
+              if aidx == midx
+                { start: -1.0, peak: 1.0, end: 1.0 }
+              else
+                { start: -1.0, peak: 0.0, end: 1.0 }
+              end
+            end
+          end
+
+          region_list = serialize_region_list(regions, ac)
+          # One ItemVariationData with all regions referenced but zero items.
+          # The actual deltas live in charstrings (pushed via blend operands).
+          var_data = serialize_empty_variation_data(regions.size)
+
+          header_size = 8
+          offsets_array_size = 4
+          region_list_offset = header_size + offsets_array_size
+          var_data_offset = region_list_offset + region_list.bytesize
+
+          store = +""
+          store << [1].pack("n")
+          store << [region_list_offset].pack("N")
+          store << [1].pack("n")
+          store << [var_data_offset].pack("N")
+          store << region_list
+          store << var_data
+          store
+        end
+
+        def self.serialize_region_list(regions, axis_count)
+          io = +""
+          io << [axis_count].pack("n")
+          io << [regions.size].pack("n")
+          regions.each do |region|
+            region.each do |coords|
+              io << [f2dot14(coords[:start]), f2dot14(coords[:peak]),
+                     f2dot14(coords[:end])].pack("nnn")
+            end
+          end
+          io
+        end
+
+        # Serialize an ItemVariationData with all regions referenced but
+        # zero items. CFF2 charstrings push their own deltas via blend.
+        def self.serialize_empty_variation_data(region_count)
+          io = +""
+          io << [0].pack("n")               # itemCount = 0
+          io << [region_count].pack("n")    # shortDeltaCount
+          io << [region_count].pack("n")    # regionIndexCount
+          region_count.times { |i| io << [i].pack("n") }
+          io
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+
         # ---------- charstring per-glyph ----------
 
         def self.charstring_for(glyph)
@@ -148,6 +249,43 @@ module Fontisan
           }
         end
 
+        # Iteratively encode the Top DICT and recompute offsets until the
+        # layout stabilizes. After convergence, performs one final
+        # encode + compute pass so +layout[:top_dict]+ carries the
+        # converged offsets (not the stale initial placeholder).
+        def self.converge_layout(charstrings:, global_subr_index:,
+                                 font_dict_index:, variation_store: nil)
+          has_vs = !variation_store.nil?
+          top_dict = encode_top_dict(
+            charstrings_offset: 0, font_dict_index_offset: 0,
+            variation_store_offset: has_vs ? 0 : nil
+          )
+          layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                  font_dict_index:, variation_store:)
+
+          10.times do
+            top_dict = encode_top_dict(
+              charstrings_offset: layout[:charstrings_offset],
+              font_dict_index_offset: layout[:font_dict_index_offset],
+              variation_store_offset: layout[:variation_store_offset],
+            )
+            next_layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                         font_dict_index:, variation_store:)
+            break if same_offsets?(layout, next_layout)
+
+            layout = next_layout
+          end
+
+          # Final encode ensures layout[:top_dict] matches converged offsets
+          final_td = encode_top_dict(
+            charstrings_offset: layout[:charstrings_offset],
+            font_dict_index_offset: layout[:font_dict_index_offset],
+            variation_store_offset: layout[:variation_store_offset],
+          )
+          compute_layout(top_dict: final_td, charstrings:, global_subr_index:,
+                         font_dict_index:, variation_store:)
+        end
+
         def self.same_offsets?(a, b)
           a[:charstrings_offset] == b[:charstrings_offset] &&
             a[:font_dict_index_offset] == b[:font_dict_index_offset] &&
@@ -173,8 +311,12 @@ module Fontisan
 
         private_class_method :charstring_for, :empty_charstring,
                              :encode_top_dict, :build_font_dict,
-                             :compute_layout, :same_offsets?,
-                             :empty_global_subr_index, :assemble
+                             :compute_layout, :converge_layout,
+                             :same_offsets?,
+                             :empty_global_subr_index, :assemble,
+                             :build_static, :build_variable,
+                             :build_variation_store, :serialize_region_list,
+                             :serialize_empty_variation_data, :f2dot14
       end
     end
   end

data/lib/fontisan/ufo/compile/variable_otf.rb

@@ -9,16 +9,13 @@ module Fontisan
       #
       # The orchestrator assembles a default-master UFO plus variation
       # masters into a variable OpenType font with:
-      #   - CFF2 outlines (static — blend/vsindex operators are TODO 07/18)
+      #   - CFF2 outlines with blend operators for each varying coordinate
+      #   - ItemVariationStore embedded in the CFF2 table (regions only;
+      #     deltas live in charstring blend operands)
       #   - fvar (axes + instances)
       #   - STAT (style attributes)
       #   - avar (axis remapping, when maps are provided)
       #
-      # NOTE: the CFF2 table currently contains static outlines (no
-      # VariationStore, no blend operators). Full variable CFF2 requires
-      # TODO 07 (blend/vsindex) and TODO 18 (blend integration) to be
-      # wired into the charstring builder.
-      #
       # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
       class VariableOtf
         # @param default_font [Fontisan::Ufo::Font] the default master
@@ -59,7 +56,7 @@ module Fontisan
             "post" => Post.build(@default),
             "hmtx" => Hmtx.build(@default, glyphs: glyphs),
             "cmap" => Cmap.build(@default, glyphs: glyphs),
-            "CFF2" => Cff2.build(@default, glyphs: glyphs),
+            "CFF2" => build_cff2(glyphs),
             "fvar" => Fvar.build(@default, axes: @axes, instances: @instances),
             "STAT" => Stat.build(axes: @axes),
           }
@@ -69,6 +66,18 @@ module Fontisan
 
           tables
         end
+
+        private
+
+        # Build the CFF2 table. When masters are supplied, variable
+        # charstrings with blend operators are emitted; otherwise a static
+        # CFF2 table is produced.
+        def build_cff2(glyphs)
+          masters = @masters.map { |mf| { font: mf, axes: @axes } }
+          Cff2.build(@default, glyphs: glyphs,
+                     masters: masters.any? ? masters : nil,
+                     axis_count: @axes.size)
+        end
       end
     end
   end

data/lib/fontisan/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.32
+  version: 0.4.33
 platform: ruby
 authors:
 - Ribose Inc.
@@ -486,6 +486,7 @@ files:
 - lib/fontisan/subset/table_strategy/cbdt.rb
 - lib/fontisan/subset/table_strategy/cblc.rb
 - lib/fontisan/subset/table_strategy/cff.rb
+- lib/fontisan/subset/table_strategy/cff2.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
@@ -561,6 +562,7 @@ files:
 - lib/fontisan/tables/cff2/dict_encoder.rb
 - lib/fontisan/tables/cff2/fd_select.rb
 - lib/fontisan/tables/cff2/header.rb
+- lib/fontisan/tables/cff2/index.rb
 - lib/fontisan/tables/cff2/index_builder.rb
 - lib/fontisan/tables/cff2/operand_stack.rb
 - lib/fontisan/tables/cff2/private_dict_blend_handler.rb