fontisan 0.4.5 → 0.4.7

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `meta` table.
+      #
+      # The meta table stores font metadata as tagged data — longer-form
+      # strings than the `name` table supports. Common tags:
+      #   "dlng" — design languages (BCP-47 tags)
+      #   "slng" — supported languages
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/meta
+      module Meta
+        VERSION = 1
+        HEADER_SIZE = 16
+        DATA_MAP_SIZE = 12 # tag(4) + offset(4) + length(4)
+
+        # @param data [Hash<String,String>] tag → UTF-8 string value
+        # @return [String, nil] meta table bytes, or nil if no data
+        def self.build(data:)
+          return nil if data.nil? || data.empty?
+
+          count = data.size
+          data_offset = HEADER_SIZE + (count * DATA_MAP_SIZE)
+
+          io = +""
+          io << [VERSION, 0, count, data_offset].pack("NNNN")
+
+          # Two iterations over the same data: the meta table has two
+          # distinct output sections (data map entries then data values)
+          # that cannot be interleaved. The map-entry section records
+          # offsets that depend on the total size of the value section,
+          # so the value section must be produced last.
+          #
+          # rubocop:disable Style/CombinableLoops
+          offset = data_offset
+          data.each do |tag, value|
+            io << tag.ljust(4, " ")[0, 4]
+            io << [offset, value.bytesize].pack("NN")
+            offset += value.bytesize
+          end
+          data.each_value { |value| io << value.b }
+          # rubocop:enable Style/CombinableLoops
+
+          io
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `MVAR` (Metrics Variation) table.
+      #
+      # Stores deltas for font-wide metrics (ascender, descender, etc.)
+      # so they can vary across the design space.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/MVAR
+      module Mvar
+        HEADER_SIZE = 10 # majorVersion(2) + minorVersion(2) + valueRecordSize(2) +
+        #                valueRecordCount(2) + itemVariationStoreOffset(2)
+        VALUE_RECORD_SIZE = 8 # tag(4) + outerIndex(2) + innerIndex(2)
+
+        # @param default_metrics [Hash<Symbol, Integer>] e.g. { hasc: 800, hdsc: -200 }
+        # @param master_metrics [Array<Hash<Symbol, Integer>>] per master
+        # @param axis_count [Integer]
+        # @return [String] MVAR table bytes
+        def self.build(default_metrics:, master_metrics:, axis_count:)
+          tags = default_metrics.keys
+          return nil if tags.empty?
+
+          master_count = master_metrics.size
+
+          deltas = []
+          records = +""
+          tags.each_with_index do |tag, idx|
+            tag_bytes = tag.to_s.ljust(4, " ")[0, 4]
+            delta = master_metrics.dig(0, tag).to_i - default_metrics[tag].to_i
+            records << tag_bytes
+            records << [0, idx].pack("nn") # outerIndex=0, innerIndex=idx
+            deltas << [delta]
+          end
+
+          store = ItemVariationStore.build(
+            axis_count: axis_count,
+            master_count: master_count,
+            item_count: tags.size,
+            deltas: deltas,
+          )
+
+          store_offset = HEADER_SIZE + records.bytesize
+
+          io = +""
+          io << [1].pack("n")                # majorVersion
+          io << [0].pack("n")                # minorVersion
+          io << [VALUE_RECORD_SIZE].pack("n")
+          io << [tags.size].pack("n")        # valueRecordCount
+          io << [store_offset].pack("n")     # itemVariationStoreOffset (Offset16)
+          io << records
+          io << store
+          io
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → OTF (CFF2). Uses CFF2 outlines instead of CFF1.
+      #
+      # CFF2 uses the same OTTO sfnt signature as CFF1. The difference
+      # is the table tag: `CFF2` (vs `CFF ` for CFF1). CFF2 enables
+      # variable font support and improved subroutinization.
+      #
+      # Note: CFF2 does NOT bypass the 65,535 glyph cap. The maxp
+      # table's numGlyphs is uint16 in all OpenType versions, and the
+      # CFF2 CharStrings INDEX count must match it. For > 65,535
+      # glyphs, use TTC splitting.
+      class Otf2Compiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_OPEN_TYPE
+
+        def build_outline_tables
+          {
+            "CFF2" => Cff2.build(font, glyphs: font.glyphs.values),
+          }
+        end
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          tables = {
+            "head" => Head.build(font, glyphs: glyphs, loca_format: Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: glyphs),
+            "maxp" => Maxp.build(font, glyphs: glyphs, version: Maxp::VERSION_OPEN_TYPE),
+            "OS/2" => Os2.build(font, glyphs: glyphs),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: glyphs),
+            "cmap" => Cmap.build(font, glyphs: glyphs),
+            "CFF2" => Cff2.build(font, glyphs: glyphs),
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `sbix` (Apple Bitmap) table.
+      #
+      # sbix stores bitmap strikes (PNG/JPEG) at multiple sizes. Each
+      # strike is a set of glyph-to-bitmap mappings at a specific ppem
+      # and resolution.
+      #
+      # Layout:
+      #   Header (8 bytes):
+      #     uint16 version (= 1)
+      #     uint16 flags
+      #     uint32 numStrikes
+      #     Offset32 strikeOffsets[numStrikes]
+      #
+      #   Strike (per ppem):
+      #     uint16 ppem
+      #     uint16 resolution (ppi)
+      #     Offset32 glyphDataOffsets[numGlyphs + 1]
+      #
+      #   Glyph Data (per glyph):
+      #     int16 originOffsetX
+      #     int16 originOffsetY
+      #     uint16 graphicType ("png " or "jpeg")
+      #     uint8 bitmapData[]
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/sbix
+      module Sbix
+        VERSION = 1
+        PNG_TYPE = "png "
+        JPEG_TYPE = "jpeg"
+
+        # @param strikes [Array<Hash>] each with :ppem, :resolution,
+        #   and :glyphs (Array<Hash> with :origin_x, :origin_y,
+        #   :graphic_type, :data per glyph)
+        # @param num_glyphs [Integer] total glyph count
+        # @return [String, nil] sbix bytes, or nil if no strikes
+        def self.build(strikes:, num_glyphs:)
+          return nil if strikes.nil? || strikes.empty?
+
+          num_strikes = strikes.size
+          header_size = 4 + 4 + (num_strikes * 4) # version + flags + offsets
+
+          strike_bytes = strikes.map { |s| build_strike(s, num_glyphs) }
+
+          io = +""
+          io << [VERSION, 0, num_strikes].pack("nnN")
+
+          offset = header_size
+          strike_bytes.each do |s|
+            io << [offset].pack("N")
+            offset += s.bytesize
+            io << s
+          end
+          io
+        end
+
+        def self.build_strike(strike, num_glyphs)
+          glyphs = strike[:glyphs] || []
+          ppem = strike[:ppem] || 0
+          resolution = strike[:resolution] || 72
+
+          # Offset table: ppem(2) + resolution(2) + (numGlyphs+1) × offset(4)
+          offset_table_size = 4 + ((num_glyphs + 1) * 4)
+
+          offsets = []
+          glyph_data = +""
+          current_offset = offset_table_size
+
+          num_glyphs.times do |gid|
+            glyph = glyphs[gid]
+            if glyph && glyph[:data]
+              offsets << current_offset
+              data = glyph[:data].b
+              glyph_data << [glyph[:origin_x] || 0, glyph[:origin_y] || 0].pack("nn")
+              glyph_data << (glyph[:graphic_type] || PNG_TYPE).ljust(4)[0, 4]
+              glyph_data << data
+              current_offset += 8 + data.bytesize
+            else
+              offsets << current_offset
+            end
+          end
+          offsets << current_offset # sentinel
+
+          io = +""
+          io << [ppem, resolution].pack("nn")
+          offsets.each { |o| io << [o].pack("N") }
+          io << glyph_data
+          io
+        end
+
+        private_class_method :build_strike
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `STAT` (Style Attributes) table.
+      #
+      # Describes style attributes for each axis and named instances.
+      # Required for proper font matching in operating systems.
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/STAT
+      module Stat
+        HEADER_SIZE = 20
+        DESIGN_AXIS_RECORD_SIZE = 8 # tag(4) + nameID(2) + ordering(2)
+        AXIS_VALUE_OFFSET_SIZE = 4  # uint32 per axis value
+
+        # @param axes [Array<Hash>] axis definitions with tag + name_id + ordering
+        # @param axis_values [Array<Hash>] value records per axis
+        # @param elided_name_id [Integer, nil] fallback name ID
+        # @return [String] STAT table bytes
+        def self.build(axes:, axis_values: nil, elided_name_id: nil)
+          return nil if axes.nil? || axes.empty?
+
+          design_axis_count = axes.size
+          axis_value_list = axis_values || []
+          axis_value_count = axis_value_list.size
+
+          design_axes = serialize_design_axes(axes)
+          value_tables, value_offsets = serialize_axis_values(axis_value_list, design_axes.bytesize)
+
+          header = serialize_header(
+            design_axis_count: design_axis_count,
+            design_axes_size: design_axes.bytesize,
+            axis_value_count: axis_value_count,
+            elided_name_id: elided_name_id,
+          )
+
+          io = +""
+          io << header
+          io << design_axes
+          axis_value_list.each_index do |i|
+            io << [value_offsets[i]].pack("N")
+          end
+          io << value_tables
+          io
+        end
+
+        def self.serialize_header(design_axis_count:, design_axes_size:, axis_value_count:, elided_name_id:)
+          design_axes_offset = HEADER_SIZE
+          offset_to_axis_value_offsets = design_axes_offset + design_axes_size
+
+          [
+            0x00010001, # version 1.1
+            DESIGN_AXIS_RECORD_SIZE,
+            design_axis_count,
+            design_axes_offset,
+            axis_value_count,
+            offset_to_axis_value_offsets,
+            elided_name_id || 0,
+          ].pack("NnnNnNn")
+        end
+
+        def self.serialize_design_axes(axes)
+          io = +""
+          axes.each_with_index do |axis, i|
+            tag = (axis[:tag] || axis["tag"] || "    ").to_s.ljust(4, " ")[0, 4]
+            name_id = axis[:name_id] || axis["name_id"] || 0
+            ordering = axis[:ordering] || axis["ordering"] || i
+            io << tag
+            io << [name_id, ordering].pack("nn")
+          end
+          io
+        end
+
+        # Each AxisValueTable is Format 1 (nominal): format(2) + axisIndex(2)
+        # + flags(2) + valueNameID(2) + value(F2DOT14) = 10 bytes.
+        def self.serialize_axis_values(axis_values, design_axes_size)
+          value_tables = +""
+          value_offsets = []
+          base = HEADER_SIZE + design_axes_size + (axis_values.size * AXIS_VALUE_OFFSET_SIZE)
+
+          axis_values.each do |av|
+            value_offsets << (base + value_tables.bytesize)
+            format = 1
+            axis_idx = av[:axis_index] || av["axis_index"] || 0
+            flags = av[:flags] || av["flags"] || 0
+            name_id = av[:name_id] || av["name_id"] || 0
+            value = f2dot14(av[:value] || av["value"] || 0)
+            value_tables << [format, axis_idx, flags, name_id, value].pack("nnnnn")
+          end
+
+          [value_tables, value_offsets]
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+        private_class_method :serialize_header, :serialize_design_axes,
+                             :serialize_axis_values, :f2dot14
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `SVG ` table for SVG-in-OpenType color glyphs.
+      #
+      # Layout:
+      #   Header (10 bytes):
+      #     uint16 version (= 0)
+      #     Offset32 documentListOffset (= 10, immediately after header)
+      #     uint32 reserved (= 0)
+      #
+      #   Document List:
+      #     uint16 numEntries
+      #     DocumentRecord[numEntries]:
+      #       uint16 startGlyphID
+      #       uint16 endGlyphID
+      #       Offset32 svgDocOffset (from start of SVG table)
+      #       uint32 svgDocLength
+      #
+      #   SVG Documents (raw XML, optionally gzipped)
+      #
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/svg
+      module SvgTable
+        VERSION = 0
+        HEADER_SIZE = 10
+        DOCUMENT_RECORD_SIZE = 12
+
+        # @param entries [Array<Hash>] each with :start_gid (Integer),
+        #   :end_gid (Integer), :svg (String — raw SVG XML)
+        # @return [String, nil] SVG table bytes, or nil if no entries
+        def self.build(entries:)
+          return nil if entries.nil? || entries.empty?
+
+          num_entries = entries.size
+          doc_list_size = 2 + (num_entries * DOCUMENT_RECORD_SIZE)
+          doc_data_offset = HEADER_SIZE + doc_list_size
+
+          header = [VERSION, HEADER_SIZE, 0].pack("nNN")
+
+          records = +""
+          docs = +""
+          offset = doc_data_offset
+          entries.each do |entry|
+            svg_bytes = entry[:svg].b
+            records << [entry[:start_gid], entry[:end_gid],
+                        offset, svg_bytes.bytesize].pack("nnNN")
+            docs << svg_bytes
+            offset += svg_bytes.bytesize
+          end
+
+          doc_list = [num_entries].pack("n") + records
+
+          header + doc_list + docs
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,8 @@ module Fontisan
       class TtfCompiler < BaseCompiler
         SFNT_VERSION = SFNT_VERSION_TRUE_TYPE
 
-        def compile(output_path:)
+        # @return [Hash<String, #to_binary_s>] all TTF tables, not yet written
+        def build_tables
           glyphs = font.glyphs.values
 
           # Deep-clone glyphs so filters don't mutate the source UFO.
@@ -22,7 +23,7 @@ module Fontisan
           glyf_loca = GlyfLoca.build(font, glyphs: filtered)
           loca_format = glyf_loca.delete(:loca_format)
 
-          tables = {
+          {
             "head" => Head.build(font, glyphs: filtered,
                                        loca_format: loca_format || Head::LOCA_FORMAT_LONG),
             "hhea" => Hhea.build(font, glyphs: filtered),
@@ -36,8 +37,10 @@ module Fontisan
             "glyf" => glyf_loca["glyf"],
             "loca" => glyf_loca["loca"],
           }
+        end
 
-          write(tables, output_path)
+        def compile(output_path:)
+          write(build_tables, output_path)
           output_path
         end
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # VariableOtf — produces a variable OTF with CFF2 outlines.
+      #
+      # 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)
+      #   - 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
+        # @param master_fonts [Array<Fontisan::Ufo::Font>] variation masters
+        # @param axes [Array<Hash>] fvar axes (tag, min, default, max, name_id)
+        # @param instances [Array<Hash>] named instances
+        def initialize(default_font, master_fonts: [], axes: [], instances: [])
+          @default = default_font
+          @masters = master_fonts
+          @axes = axes
+          @instances = instances
+        end
+
+        # Compile the variable OTF directly to the output path.
+        # @param output_path [String] output file path
+        # @return [String] the output path
+        def compile(output_path:)
+          tables = build_tables
+          Fontisan::FontWriter.write_to_file(
+            tables.transform_values { |t| t.is_a?(String) ? t : t.to_binary_s },
+            output_path,
+            sfnt_version: 0x4F54544F,
+          )
+          output_path
+        end
+
+        # Build all tables for the variable OTF.
+        # @return [Hash<String,String>] table tag → bytes
+        def build_tables
+          glyphs = @default.glyphs.values
+
+          tables = {
+            "head" => Head.build(@default, glyphs: glyphs, loca_format: Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(@default, glyphs: glyphs),
+            "maxp" => Maxp.build(@default, glyphs: glyphs, version: Maxp::VERSION_OPEN_TYPE),
+            "OS/2" => Os2.build(@default, glyphs: glyphs),
+            "name" => Name.build(@default),
+            "post" => Post.build(@default),
+            "hmtx" => Hmtx.build(@default, glyphs: glyphs),
+            "cmap" => Cmap.build(@default, glyphs: glyphs),
+            "CFF2" => Cff2.build(@default, glyphs: glyphs),
+            "fvar" => Fvar.build(@default, axes: @axes, instances: @instances),
+            "STAT" => Stat.build(axes: @axes),
+          }
+
+          avar_bytes = Avar.build(axes: @axes)
+          tables["avar"] = avar_bytes if avar_bytes
+
+          tables
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Orchestrates compilation of a UFO source plus its variation
+      # masters into a single variable TrueType font.
+      #
+      # Pipeline:
+      #
+      #   default UFO font
+      #     │
+      #     ├─ TtfCompiler tables (head, hhea, maxp, OS/2, name,
+      #     │                     post, hmtx, cmap, glyf, loca)
+      #     │
+      #     ├─ fvar  (axes + named instances)
+      #     ├─ gvar  (per-glyph point deltas across masters)
+      #     ├─ HVAR  (advance-width deltas across masters)
+      #     ├─ MVAR  (font-wide metric deltas across masters)
+      #     ├─ avar  (per-axis non-linear maps; defaults to identity)
+      #     └─ STAT  (style attributes for OS matching)
+      #
+      # Masters are supplied as an Array of Hashes, each with:
+      #   - :font   — the master UFO::Font
+      #   - :axes   — Hash<String, Float> mapping axis tag → region peak
+      #
+      class VariableTtf
+        SFNT_VERSION = BaseCompiler::SFNT_VERSION_TRUE_TYPE
+
+        # @param font [Fontisan::Ufo::Font] default master
+        # @param axes [Array<Hash>] axis definitions (tag, min/default/max,
+        #   optional name_id, ordering, maps)
+        # @param masters [Array<Hash>] each master: { font:, axes: }
+        # @param instances [Array<Hash>] named instances for fvar
+        # @param stat_axis_values [Array<Hash>, nil] STAT axis value records
+        # @param stat_elided_name_id [Integer, nil] STAT elided fallback name
+        # @param default_metrics [Hash<Symbol, Integer>, nil] MVAR defaults
+        # @param master_metrics [Array<Hash<Symbol, Integer>>, nil] MVAR per-master
+        def initialize(font:, axes:, masters:, instances: nil,
+                       stat_axis_values: nil, stat_elided_name_id: nil,
+                       default_metrics: nil, master_metrics: nil)
+          @font = font
+          @axes = axes
+          @masters = masters
+          @instances = instances
+          @stat_axis_values = stat_axis_values
+          @stat_elided_name_id = stat_elided_name_id
+          @default_metrics = default_metrics
+          @master_metrics = master_metrics
+        end
+
+        # @param output_path [String]
+        # @return [String] the output path
+        def compile(output_path:)
+          tables = base_tables.merge(variation_tables)
+          write(tables, output_path)
+          output_path
+        end
+
+        private
+
+        def base_tables
+          @base_tables ||= TtfCompiler.new(@font).build_tables
+        end
+
+        def variation_tables
+          axis_count = @axes.size
+          tables = {}
+
+          fvar_bytes = Fvar.build(@font, axes: @axes, instances: @instances)
+          tables["fvar"] = fvar_bytes if fvar_bytes
+
+          avar_bytes = Avar.build(axes: @axes)
+          tables["avar"] = avar_bytes if avar_bytes
+
+          stat_bytes = Stat.build(
+            axes: stat_axes,
+            axis_values: @stat_axis_values,
+            elided_name_id: @stat_elided_name_id,
+          )
+          tables["STAT"] = stat_bytes if stat_bytes
+
+          default_glyphs = @font.glyphs.values
+          glyph_order = default_glyphs.map(&:name)
+
+          gvar_masters = @masters.map do |m|
+            {
+              axes: m[:axes],
+              glyphs: glyphs_for_master(m[:font], glyph_order),
+            }
+          end
+          tables["gvar"] = Gvar.build(
+            default_glyphs: default_glyphs,
+            masters: gvar_masters,
+            axis_count: axis_count,
+          )
+
+          default_widths = default_glyphs.map { |g| g.width.to_i }
+          master_widths = @masters.map do |m|
+            glyphs_for_master(m[:font], glyph_order).map { |g| g.width.to_i }
+          end
+          tables["HVAR"] = Hvar.build(
+            default_widths: default_widths,
+            master_widths: master_widths,
+            axis_count: axis_count,
+          )
+
+          if @default_metrics && @master_metrics
+            mvar = Mvar.build(
+              default_metrics: @default_metrics,
+              master_metrics: @master_metrics,
+              axis_count: axis_count,
+            )
+            tables["MVAR"] = mvar if mvar
+          end
+
+          tables
+        end
+
+        # Project a master's glyphs onto the default master's glyph order
+        # so deltas align by index. Missing glyphs default to the master's
+        # .notdef (index 0).
+        def glyphs_for_master(master_font, glyph_order)
+          by_name = master_font.glyphs
+          notdef = by_name.values.first
+          glyph_order.map { |name| by_name[name] || notdef }
+        end
+
+        # STAT design-axis records derived from @axes. Each axis may
+        # supply :name_id and :ordering; missing values default sensibly.
+        def stat_axes
+          @axes.each_with_index.map do |axis, i|
+            {
+              tag: axis[:tag] || axis["tag"],
+              name_id: axis[:name_id] || axis["name_id"] || 0,
+              ordering: axis[:ordering] || axis["ordering"] || i,
+            }
+          end
+        end
+
+        def write(tables_hash, output_path)
+          dir = File.dirname(output_path)
+          FileUtils.mkpath(dir) unless dir == "."
+          Fontisan::FontWriter.write_to_file(
+            tables_hash.transform_values { |t| serialize_table(t) },
+            output_path,
+            sfnt_version: SFNT_VERSION,
+          )
+        end
+
+        # BinData records respond to to_binary_s; raw String values pass through.
+        def serialize_table(table)
+          case table
+          when String then table
+          else table.to_binary_s
+          end
+        end
+      end
+    end
+  end
+end