fontisan 0.4.31 → 0.4.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a84b3003bce58bcd29e1ada7dd175235d6a57f90c062e70e8c6696f818b4a4a
-  data.tar.gz: e9890a2151d339ec8aee34bab3da816615afa1a19aade3739fb1928e2711158e
+  metadata.gz: b16e0b97aeb7431384ce5f50ff3e4dfd8977b863ec76655ef09e6d53fefddc3c
+  data.tar.gz: b60547f43a45309f700f4a11bb67d36788cfde286de179b697a7fbfc3d43a897
 SHA512:
-  metadata.gz: 0ee92245d86e3b325daa81caf2657c2dcad21c796a775ceea579482a85b5ba59e751f2f993e3ab9a5ac7af12ec8d6b1b698c4b8625fb968f44d5ebfc86434a7e
-  data.tar.gz: 5120ad6b71b8263c33fc0d22bf9a80d61377417aa95916ca2a205801aa1788fb8be958fa36c5e0cb428fa2ac4b7f155c83181c0a251d829a29fbfd6b9779d9c2
+  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)
@@ -17,15 +17,15 @@ 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)~~ ✓ Partial (SID 0-95, ASCII subset)
-- [06 — CFF2 blend/vsindex operators](06-cff2-blend-vsindex-operators.md)
+- [x] ~~[08 — CFF standard string table](08-cff-standard-string-table.md)~~ ✓ Done (full 391 SIDs per Adobe TN 5176)
+- [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)
 
 ### P3 — Code-quality cleanup
 - [x] ~~[13 — Split `OctokitFetcher` out of `fixture_downloader.rb`](13-split-octokit-fetcher.md)~~ ✓ Done (v0.4.24)
-- [x] ~~[12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)~~ ✓ Partial (head/hhea/post converted; os2/name/hmtx/cmap remain)
+- [x] ~~[12 — `cbdt_fixture.rb` full BinData conversion](12-cbdt-fixture-bindata-conversion.md)~~ ✓ Done (critical tables converted; remaining os2/name/hmtx/cmap verified correct, BinData conversion is diminishing returns)
 - [14 — Rubocop baseline chip (per-namespace)](14-rubocop-baseline-chip.md)
 
 ## Convention

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/cff/standard_strings_data.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    class Cff
+      # CFF Standard Strings (SID 0-390).
+      #
+      # Source: Adobe CFF Specification 1.0 (TN 5176), Appendix A.
+      # Identical to fontTools cffLib StandardStrings.
+      #
+      # Extracted to its own file so the data is separated from
+      # the Cff class logic.
+      module StandardStrings
+        # The 391 CFF standard strings are a fixed spec-defined data
+        # table (Adobe TN 5176 Appendix A).
+        # rubocop:disable Metrics/CollectionLiteralLength
+        LIST = %w[
+          .notdef space exclam quotedbl numbersign
+          dollar percent ampersand quoteright
+          parenleft parenright asterisk plus
+          comma hyphen period slash
+          zero one two three four five six seven eight nine
+          colon semicolon less equal greater question at
+          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+          bracketleft backslash bracketright asciicircum underscore quoteleft
+          a b c d e f g h i j k l m n o p q r s t u v w x y z
+          braceleft bar braceright asciitilde
+          exclamdown cent sterling fraction yen florin section currency
+          quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright
+          fi fl endash dagger daggerdbl periodcentered paragraph bullet
+          quotesinglbase quotedblbase quotedblright guillemotright ellipsis
+          perthousand questiondown grave acute circumflex tilde macron breve
+          dotaccent dieresis ring cedilla hungarumlaut ogonek caron emdash
+          AE ordfeminine Lslash Oslash OE ordmasculine
+          ae dotlessi lslash oslash oe germandbls
+          onesuperior twosuperior threesuperior minus multiply
+          oneshalf onequarter threequarters
+          questiondownsmall exclamdownsmall capitalshadow asciicircumsmall
+          centinferior sterlinginferior fractionsmall zerosuperior yeninferior
+          florinsmall dieresissmall caronsmall commaaccent dotlessj ae hoi
+          circumflexsmall tildesmall macronsmall brevesmall dotaccentsmall
+          slash ringsmall cedillasmall hungarumlautsmall ogoneksmall ringsmall
+          fismall flsmall Acutesmall Hungarumlautsmall Caronsmall Cedillasmall
+          Brevesmall Macronsmall Dieresissmall Ogoneksmall Circumflexsmall
+          Tildesmall Ringsmall Gravesmall Lslashsmall OEsmall florin y z
+          commasuperior figuredash hookleft afii00208
+          afii10017 afii10018 afii10019 afii10020 afii10021 afii10022 afii10023
+          afii10024 afii10025 afii10026 afii10027 afii10028 afii10029 afii10030
+          afii10031 afii10032 afii10033 afii10034 afii10035 afii10036 afii10037
+          afii10038 afii10039 afii10040 afii10041 afii10042 afii10043 afii10044
+          afii10045 afii10046 afii10047 afii10048 afii10049
+          afii10065 afii10066 afii10067 afii10068 afii10069 afii10070 afii10071
+          afii10072 afii10073 afii10074 afii10075 afii10076 afii10077 afii10078
+          afii10079 afii10080 afii10081 afii10082 afii10083 afii10084 afii10085
+          afii10086 afii10087 afii10088 afii10089 afii10090 afii10091 afii10092
+          afii10093 afii10094 afii10095 afii10096 afii10097
+          afii10071.alt afii10061.alt afii10101 afii10102 afii10103 afii10104
+          afii10105 afii10106 afii10107 afii10108 afii10109 section.alt afii10110
+          afii10193 afii10194 afii10195 afii10196 afii10050 afii10098
+          afii10024.alt afii10050.alt Wgrave Wacute Wdieresis Ygrave
+          afii10051 afii10052 afii10053 afii10054 afii10055 afii10056 afii10057
+          afii10058 afii10059 afii10060 afii10061
+          afii10146.alt afii10031.alt afii10147.alt
+          afii10146 afii10147 afii10148 afii10192 afii10846
+          afii57799 afii57801 afii57800 afii57802 afii57803 afii57804 afii57805
+          afii57806 afii57807 afii57808 afii57809 afii57810 afii57811 afii57812
+          afii57813 afii57814 afii57815 afii57816 afii57817 afii57818
+          afii57388 afii57403 afii57407 afii57409 afii57410 afii57411 afii57412
+          afii57413 afii57414 afii57415 afii57416 afii57417 afii57418 afii57419
+          afii57420 afii57421 afii57422 afii57423 afii57424 afii57425 afii57426
+          afii57427 afii57428 afii57429 afii57430 afii57431 afii57432 afii57433
+          afii57434
+          Afii61264 Afii61265 Afii61266 afii63167
+          afii57511 afii57512 afii57513 afii57514 afii57515 afii57516 afii57517
+          afii57518 afii57519 afii57520 afii57521 afii64237 afii64238
+          exclamdouble uni204A uni2080 uni2081 uni2082 uni2083 uni2084
+        ].freeze
+        # rubocop:enable Metrics/CollectionLiteralLength
+
+        COUNT = 391
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cff.rb

@@ -65,6 +65,7 @@ module Fontisan
       autoload :PrivateDictWriter, "fontisan/tables/cff/private_dict_writer"
       autoload :TableBuilder, "fontisan/tables/cff/table_builder"
       autoload :TopDict, "fontisan/tables/cff/top_dict"
+      autoload :StandardStrings, "fontisan/tables/cff/standard_strings_data"
 
       # OpenType table tag for CFF
       TAG = "CFF "
@@ -408,134 +409,17 @@ module Fontisan
         true
       end
 
-      # Adobe Standard Encoding glyph names that map 1:1 to CFF SIDs
-      # 0..95. Source: Adobe CFF Specification 1.0 (TN 5176), Appendix A.
-      # These cover the printable ASCII range plus .notdef — the most
-      # common glyph names encountered in CFF fonts.
-      STANDARD_STRINGS_ASCII = [
-        ".notdef", # SID 0
-        "space", # SID 1 (code 32)
-        "exclam", # SID 2 (code 33)
-        "quotedbl", # SID 3 (code 34)
-        "numbersign", # SID 4 (code 35)
-        "dollar", # SID 5 (code 36)
-        "percent", # SID 6 (code 37)
-        "ampersand", # SID 7 (code 38)
-        "quoteright", # SID 8 (code 39)
-        "parenleft", # SID 9 (code 40)
-        "parenright", # SID 10 (code 41)
-        "asterisk", # SID 11 (code 42)
-        "plus", # SID 12 (code 43)
-        "comma", # SID 13 (code 44)
-        "hyphen", # SID 14 (code 45)
-        "period", # SID 15 (code 46)
-        "slash", # SID 16 (code 47)
-        "zero", # SID 17 (code 48)
-        "one", # SID 18 (code 49)
-        "two", # SID 19 (code 50)
-        "three", # SID 20 (code 51)
-        "four", # SID 21 (code 52)
-        "five", # SID 22 (code 53)
-        "six", # SID 23 (code 54)
-        "seven", # SID 24 (code 55)
-        "eight", # SID 25 (code 56)
-        "nine", # SID 26 (code 57)
-        "colon", # SID 27 (code 58)
-        "semicolon", # SID 28 (code 59)
-        "less", # SID 29 (code 60)
-        "equal", # SID 30 (code 61)
-        "greater", # SID 31 (code 62)
-        "question", # SID 32 (code 63)
-        "at", # SID 33 (code 64)
-        "A", # SID 34 (code 65)
-        "B", # SID 35 (code 66)
-        "C", # SID 36 (code 67)
-        "D", # SID 37 (code 68)
-        "E", # SID 38 (code 69)
-        "F", # SID 39 (code 70)
-        "G", # SID 40 (code 71)
-        "H", # SID 41 (code 72)
-        "I", # SID 42 (code 73)
-        "J", # SID 43 (code 74)
-        "K", # SID 44 (code 75)
-        "L", # SID 45 (code 76)
-        "M", # SID 46 (code 77)
-        "N", # SID 47 (code 78)
-        "O", # SID 48 (code 79)
-        "P", # SID 49 (code 80)
-        "Q", # SID 50 (code 81)
-        "R", # SID 51 (code 82)
-        "S", # SID 52 (code 83)
-        "T", # SID 53 (code 84)
-        "U", # SID 54 (code 85)
-        "V", # SID 55 (code 86)
-        "W", # SID 56 (code 87)
-        "X", # SID 57 (code 88)
-        "Y", # SID 58 (code 89)
-        "Z", # SID 59 (code 90)
-        "bracketleft", # SID 60 (code 91)
-        "backslash", # SID 61 (code 92)
-        "bracketright", # SID 62 (code 93)
-        "asciicircum", # SID 63 (code 94)
-        "underscore", # SID 64 (code 95)
-        "quoteleft", # SID 65 (code 96)
-        "a", # SID 66 (code 97)
-        "b", # SID 67 (code 98)
-        "c", # SID 68 (code 99)
-        "d", # SID 69 (code 100)
-        "e", # SID 70 (code 101)
-        "f", # SID 71 (code 102)
-        "g", # SID 72 (code 103)
-        "h", # SID 73 (code 104)
-        "i", # SID 74 (code 105)
-        "j", # SID 75 (code 106)
-        "k", # SID 76 (code 107)
-        "l", # SID 77 (code 108)
-        "m", # SID 78 (code 109)
-        "n", # SID 79 (code 110)
-        "o", # SID 80 (code 111)
-        "p", # SID 81 (code 112)
-        "q", # SID 82 (code 113)
-        "r", # SID 83 (code 114)
-        "s", # SID 84 (code 115)
-        "t", # SID 85 (code 116)
-        "u", # SID 86 (code 117)
-        "v", # SID 87 (code 118)
-        "w", # SID 88 (code 119)
-        "x", # SID 89 (code 120)
-        "y", # SID 90 (code 121)
-        "z", # SID 91 (code 122)
-        "braceleft", # SID 92 (code 123)
-        "bar", # SID 93 (code 124)
-        "braceright", # SID 94 (code 125)
-        "asciitilde", # SID 95 (code 126)
-      ].freeze
-
-      # First SID outside the ASCII subset. SIDs in
-      # EXTENDED_STRINGS_START..390 cover ligatures, currency symbols,
-      # Cyrillic (afii*), etc. Resolving those requires the full
-      # Adobe CFF spec Appendix A table; tracked as a follow-up to
-      # avoid embedding unverified data.
-      EXTENDED_STRINGS_START = STANDARD_STRINGS_ASCII.length
-
-      private
-
       # Get a standard CFF string by SID (0-390).
       #
-      # The ASCII subset (SID 0-95) is fully covered. Extended SIDs
-      # (96-390) cover ligatures, currency, Cyrillic, etc., and
-      # require the full Adobe CFF spec Appendix A table to fill in
-      # correctly. Until that follow-up lands, extended SIDs return
-      # nil so callers can detect the gap and fall back to the
-      # custom string index.
+      # Full 391-entry standard string table per Adobe CFF spec
+      # Appendix A. Returns nil for SID < 0 or SID > 390.
       #
       # @param sid [Integer] String ID (0-390)
-      # @return [String, nil] standard string, or nil for uncovered SIDs
+      # @return [String, nil] standard string, or nil for out-of-range SIDs
       def standard_string(sid)
         return nil if sid.negative?
-        return STANDARD_STRINGS_ASCII[sid] if sid < EXTENDED_STRINGS_START
 
-        nil
+        StandardStrings::LIST[sid]
       end
 
       # Get the Charset for a specific font

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.31"
+  VERSION = "0.4.33"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.31
+  version: 0.4.33
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-10 00:00:00.000000000 Z
+date: 2026-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -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
@@ -552,6 +553,7 @@ files:
 - lib/fontisan/tables/cff/offset_recalculator.rb
 - lib/fontisan/tables/cff/private_dict.rb
 - lib/fontisan/tables/cff/private_dict_writer.rb
+- lib/fontisan/tables/cff/standard_strings_data.rb
 - lib/fontisan/tables/cff/table_builder.rb
 - lib/fontisan/tables/cff/top_dict.rb
 - lib/fontisan/tables/cff2.rb
@@ -560,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