fontisan 0.4.47 → 0.4.48

data/lib/fontisan/commands/unpack_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "tmpdir"
 
 module Fontisan
   module Commands
@@ -98,8 +99,63 @@ module Fontisan
         raise Fontisan::Error, "Unexpected error during unpacking: #{e.message}"
       end
 
+      # Execute the command through the engine selection (the CLI entry): a
+      # tier other than Ruby serves the extraction when it can, and the result
+      # and the files written are those of {#run}. Anything the engine cannot
+      # honour (a +format+ or +prefix+, verbose output, an OTC input, a
+      # non-"ttcf" file, an index out of range) runs {#run} on the Ruby tier.
+      #
+      # @return [Hash] same as {#run}
+      def run_routed
+        indices = routed_indices
+        return run unless indices
+
+        FileUtils.mkdir_p(@output_dir)
+        files = indices.map { |index| extract_member(index) }
+        { collection: @collection_path, output_dir: @output_dir,
+          num_fonts: collection_member_count, fonts_extracted: files.size,
+          extracted_files: files }
+      rescue Fontisan::Error => e
+        raise Fontisan::Error, "Collection unpacking failed: #{e.message}"
+      end
+
       private
 
+      # Member indices to extract on a non-Ruby tier; nil when Ruby serves.
+      def routed_indices
+        return nil if @format || @prefix || @verbose || !ttcf_file?
+
+        count = collection_member_count
+        return nil if @font_index && @font_index >= count
+
+        indices = @font_index ? [@font_index] : (0...count).to_a
+        probe = { index: indices.first, output_dir: @output_dir.to_s }
+        Engine.resolve(:extract, @collection_path.to_s, probe) == :ruby ? nil : indices
+      end
+
+      def ttcf_file?
+        File.extname(@collection_path).casecmp?(".otc") ? false : File.binread(@collection_path, 4) == "ttcf"
+      end
+
+      # numFonts of the TTC header.
+      def collection_member_count
+        File.binread(@collection_path, 12).unpack1("@8N")
+      end
+
+      # One member through {Reference.extract}. A single requested index keeps
+      # the engine's file name; all members get Ruby's "<name>_<index>" form.
+      def extract_member(index)
+        return Reference.extract(@collection_path, index: index, output_dir: @output_dir) if @font_index
+
+        Dir.mktmpdir("fontisan-unpack") do |scratch|
+          file = Reference.extract(@collection_path, index: index, output_dir: scratch)
+          ext = File.extname(file)
+          target = File.join(@output_dir, "#{File.basename(file, ext)}_#{index}#{ext}")
+          FileUtils.mv(file, target)
+          target
+        end
+      end
+
       # Validate command options
       #
       # @raise [ArgumentError] if options are invalid

data/lib/fontisan/converters/cff_table_builder.rb

@@ -188,7 +188,7 @@ module Fontisan
           return font_name.dup.force_encoding("ASCII-8BIT") if font_name
         end
 
-        "UnnamedFont"
+        "UnnamedFont".b
       end
     end
   end

data/lib/fontisan/converters/collection_converter.rb

@@ -262,7 +262,9 @@ conv_options = nil)
             converter = FormatConverter.new
 
             # Build converter options, including ConversionOptions if provided
-            converter_opts = options.dup
+            # timestamp is a WOFF2 encoder option; the outline strategy rejects
+            # any option key it does not declare, even with a nil value.
+            converter_opts = options.except(:timestamp)
             converter_opts[:options] = conv_options if conv_options
 
             begin
@@ -288,7 +290,10 @@ conv_options = nil)
                   note: "Conversion failed, kept original: #{e.message}",
                 }
               else
-                raise Error, "Font #{index} conversion failed: #{e.message}"
+                # Keep MissingTableError as its class so callers can rescue it
+                # by type; the message format is unchanged.
+                error_class = e.is_a?(Fontisan::MissingTableError) ? Fontisan::MissingTableError : Fontisan::Error
+                raise error_class, "Font #{index} conversion failed: #{e.message}"
               end
             end
           else
@@ -348,7 +353,8 @@ conv_options = nil)
         elsif font.has_table?("glyf")
           :ttf
         else
-          raise Error, "Cannot detect font format"
+          raise Fontisan::MissingTableError,
+                "Font has neither glyf nor CFF table"
         end
       end
 
@@ -444,11 +450,13 @@ conv_options = nil)
       #
       # @param fonts [Array<Font>] Fonts
       # @param output_path [String] Output path (.woff2)
-      # @param options [Hash] Options (looks for :brotli_quality)
+      # @param options [Hash] Options (looks for :brotli_quality, :timestamp)
       # @return [void]
       def repack_woff2_collection(fonts, output_path, options)
         brotli_quality = options.fetch(:brotli_quality, 11)
-        encoder = Woff2::CollectionEncoder.new(brotli_quality:)
+        encoder = Woff2::CollectionEncoder.new(
+          brotli_quality:, timestamp: options[:timestamp],
+        )
         bytes = encoder.encode_fonts(fonts)
         File.binwrite(output_path, bytes)
       end

data/lib/fontisan/converters/format_converter.rb

@@ -515,7 +515,7 @@ _options)
           raise ArgumentError,
                 "Option(s) #{conflicts.map(&:inspect).join(', ')} do not apply " \
                 "to #{source_format}→#{target_format} " \
-                "(#{this_class.name.demodulize}). " \
+                "(#{this_class.name.split('::').last}). " \
                 "Accepted: #{accepted_list}"
         end
 

data/lib/fontisan/converters/woff2_encoder.rb

@@ -54,6 +54,11 @@ module Fontisan
                                 cli: "--[no-]transform-tables",
                                 desc: "apply glyf/loca and hmtx transformations"
 
+      option :timestamp, type: :integer, default: nil,
+                         cli: "--timestamp=SECONDS",
+                         desc: "fixed head.modified (Unix seconds) for " \
+                               "reproducible output; default is the clock"
+
       # Convert font to WOFF2 format.
       #
       # @param font [TrueTypeFont, OpenTypeFont] Source font
@@ -77,7 +82,8 @@ module Fontisan
 
         flavor = detect_flavor(font)
         table_data = collect_tables(font, options)
-        Woff2::EncoderRules.apply!(table_data)
+        Woff2::EncoderRules.apply!(table_data,
+                                   timestamp: resolved[:timestamp])
 
         glyf_transform = apply_glyf_loca_transform!(table_data, font)
 
@@ -266,11 +272,7 @@ module Fontisan
         # encoder does the same — short loca halves the loca table size
         # and Chrome's OTS accepts both formats.
         max_canonical_glyf_size = glyf_data.bytesize + 3 * maxp.num_glyphs
-        target_format = if max_canonical_glyf_size <= SHORT_LOCA_GLYF_MAX
-                          0
-                        else
-                          source_format
-                        end
+        target_format = max_canonical_glyf_size <= SHORT_LOCA_GLYF_MAX ? 0 : 1
 
         canonical = Woff2::GlyfCanonicalizer.new(
           glyf_data:,

data/lib/fontisan/converters/woff_writer.rb

@@ -164,13 +164,14 @@ module Fontisan
         options.select { |k, _| names.include?(k.to_sym) }
       end
 
-      # Collect all table data from font in input-font order (spec §6: tables
-      # MUST be stored in the same order as the well-formed input font).
+      # Collect all table data from font, sorted ascending by tag (WOFF 1.0
+      # §5: the table directory MUST be sorted by tag; data follows directory
+      # order). Input-font order is not preserved.
       #
       # @param font [TrueTypeFont, OpenTypeFont]
       # @return [Hash<String, String>]
       def collect_tables_data(font)
-        font.table_names.each_with_object({}) do |tag, h|
+        font.table_names.sort.each_with_object({}) do |tag, h|
           data = font.table_data[tag]
           h[tag] = data if data
         end
@@ -241,7 +242,7 @@ module Fontisan
       # emits header → directory → tables → optional metadata → optional
       # private data.
       #
-      # @param compressed_tables [Hash<String, Hash>] in input-font order
+      # @param compressed_tables [Hash<String, Hash>] sorted by tag
       # @param font [TrueTypeFont, OpenTypeFont]
       # @param compressed_metadata [Hash, nil]
       # @param private_data [String, nil]
@@ -252,7 +253,7 @@ module Fontisan
         num_tables = compressed_tables.length
         data_start = header_size + (num_tables * 20)
 
-        # Lay out tables in input-font order with 4-byte alignment padding.
+        # Lay out tables in directory (tag) order with 4-byte alignment padding.
         # Each entry: { tag:, info:, offset:, pad_bytes: }
         entries = []
         cursor = data_start

data/lib/fontisan/engine.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+module Fontisan
+  # Engine selection for the {Fontisan::Reference} operations.
+  #
+  #   FONTISAN_ENGINE=ruby|native|ffi|auto   (default auto)
+  #   FONTISAN_ENGINE_STRICT=1               (no fallback)
+  #
+  # `auto` resolves native, then ffi, then ruby: the first tier that is
+  # available and supports the operation wins. A forced tier that is unavailable
+  # falls back to Ruby silently, or raises {TierUnavailable} at setup when
+  # strict. An operation (or a path, e.g. dfont) a tier cannot serve always goes to
+  # Ruby, strict or not. FONTISAN_MODE and FONTISAN_LAZY are not read here.
+  #
+  # The Ruby tier is the unmodified Reference implementation; the gate is a
+  # module prepended to Reference's singleton, so Reference bodies are
+  # untouched. Its output is unchanged (no served_by key), so goldens stay
+  # tier-independent; {Engine.scan} and {Engine.audit_dir} return the same
+  # rows with a per-row "served_by".
+  module Engine
+    class Error < Fontisan::Error; end
+    class ConfigError < Error; end
+    class TierUnavailable < Error; end
+    # A WOFF2 operation fell to the Ruby tier on a platform with no `brotli`.
+    class Woff2Unavailable < TierUnavailable; end
+
+    SELECTIONS = %w[ruby native ffi auto].freeze
+    STRICT_ON = %w[1 true yes on].freeze
+    STRICT_OFF = ["", "0", "false", "no", "off"].freeze
+    AUTO_ORDER = %i[native ffi ruby].freeze
+    OPS = %i[read outline_hashes audit audit_dir scan convert extract
+             instance glyph_ids subset].freeze
+    REPLACEABLE_TIERS = %i[native ffi].freeze
+    TIER_CONTRACT = %i[available? supports? call].freeze
+    ROW_RECORDER = :fontisan_engine_rows
+    IN_OPERATION = :fontisan_engine_in_operation
+
+    Config = Struct.new(:selection, :strict)
+
+    # The Ruby tier: the original Reference methods, captured before the
+    # gate is prepended.
+    class RubyTier
+      def initialize(originals)
+        @originals = originals
+      end
+
+      def available?
+        true
+      end
+
+      def supports?(_operation, _path = nil)
+        true
+      end
+
+      def call(operation, ...)
+        @originals.fetch(operation).call(...)
+      end
+    end
+
+    # Prepended to Reference's singleton: one gate per Reference operation.
+    module Gate
+      OPS.each do |operation|
+        define_method(operation) do |*args, **kwargs, &block|
+          Engine.dispatch(operation, args, kwargs, &block)
+        end
+      end
+    end
+
+    @mutex = Mutex.new
+    @tiers = nil
+    @served = {}
+    @counters = nil
+    @availability = {}
+
+    class << self
+      # Prepend the gates onto +reference+ (once).
+      def install(reference)
+        return if reference.singleton_class.include?(Gate)
+
+        originals = OPS.to_h { |operation| [operation, reference.method(operation)] }
+        @tiers = { ruby: RubyTier.new(originals) }.freeze
+        reference.singleton_class.prepend(Gate)
+      end
+
+      # Current configuration from the environment; raises at setup for a
+      # bad value or a strict forced tier that is not available.
+      def setup!
+        # The gates are installed when Reference loads (autoload); a fresh
+        # process, e.g. the CLI, reaches the engine before anything touched it.
+        Fontisan::Reference unless @tiers
+        config = config_from_env
+        return config unless config.strict && forced?(config.selection)
+
+        tier = config.selection
+        unless available?(tier)
+          raise TierUnavailable,
+                "FONTISAN_ENGINE=#{tier} with FONTISAN_ENGINE_STRICT=1 " \
+                "but the #{tier} tier is not available"
+        end
+        config
+      end
+
+      # Tier (Symbol) that serves +operation+ for +path+ under the current config.
+      def resolve(operation, path = nil, options = nil)
+        config = setup!
+        tier = candidates(config).find do |name|
+          available?(name) && supports?(name, operation, path, options)
+        end || :ruby
+        require_woff2_support!(operation, path, options) if tier == :ruby
+        tier
+      end
+
+      # Tier that served the last call of +operation+ in this process; nil if none.
+      def served_by(operation)
+        @mutex.synchronize { @served[operation.to_sym] }
+      end
+
+      # { tier => { operation => calls } } since the last {reset!}.
+      def counters
+        @mutex.synchronize do
+          (@counters || {}).transform_values(&:dup)
+        end
+      end
+
+      # Scan rows with a "served_by" tier name per row.
+      def scan(paths)
+        scan_pairs(paths).flat_map do |tier, rows|
+          rows.map { |row| row.merge("served_by" => tier.to_s) }
+        end
+      end
+
+      # audit_dir entries with a "served_by" tier name per entry: the tier
+      # that audited that file. A file the serving tier hands back to Ruby
+      # (dfont, Type 1 inside a native audit_dir) is recorded as :ruby by the
+      # nested call; every other entry carries the tier that served the call.
+      def audit_dir(dir, validate: false)
+        dir_path = File.path(dir)
+        whole = resolve(:audit_dir, dir_path)
+        seen = {}
+        entries = with_recorder(seen) do
+          Reference.audit_dir(dir, validate: validate)
+        end
+        entries.map do |entry|
+          tier = seen[File.join(dir_path, entry["path"])] || whole
+          entry.merge("served_by" => tier.to_s)
+        end
+      end
+
+      # Run +operation+ on the Ruby tier, whatever is selected (a tier handing
+      # a file it cannot read back to Ruby).
+      def ruby_call(operation, ...)
+        tier_object(:ruby).call(operation, ...)
+      end
+
+      # Called by the gates.
+      def dispatch(operation, args, kwargs, &)
+        path = args.first
+        path = path.to_s if path.respond_to?(:to_path)
+        path = nil unless path.is_a?(String)
+        return scan_rows(args, kwargs) if operation == :scan && !args.empty?
+
+        tier = resolve(operation, path, kwargs)
+        run(tier, operation, path, args, kwargs, &)
+      end
+
+      # The object-based entry points (`Subset::Builder.new(font, ...)`,
+      # `Variable::Instancer.new(font)`) are never dispatched: a loaded font's
+      # state lives in cached parsed tables, so they always run on Ruby. They
+      # call this so that {served_by} reports it; inside a gated call (the
+      # Ruby tier's own Reference body) the gate has already recorded the tier.
+      def record_ruby(operation)
+        return if Thread.current[IN_OPERATION]
+
+        record(:ruby, operation, nil)
+      end
+
+      # Forget probes, counters, served state and registered tiers.
+      def reset!
+        @mutex.synchronize do
+          @served = {}
+          @counters = nil
+          @availability = {}
+          @tiers = @tiers.slice(:ruby) if @tiers
+        end
+        Native.reset!
+        Ffi.reset!
+      end
+
+      # Register a tier object (tests, or the extension itself). A bad
+      # registration raises here, at setup, never as a silent fallback later.
+      def register(name, tier)
+        validate_registration!(name, tier)
+        @mutex.synchronize do
+          @tiers = @tiers.merge(name.to_sym => tier).freeze
+          @availability.delete(name.to_sym)
+        end
+      end
+
+      private
+
+      def validate_registration!(name, tier)
+        unless REPLACEABLE_TIERS.include?(name.to_s.to_sym)
+          raise ConfigError,
+                "cannot register tier #{name.inspect}: only " \
+                "#{REPLACEABLE_TIERS.join(' and ')} can be registered"
+        end
+
+        missing = TIER_CONTRACT.reject { |method| tier.respond_to?(method) }
+        return if missing.empty?
+
+        raise ConfigError,
+              "tier #{name} does not implement #{missing.join(', ')}"
+      end
+
+      def config_from_env
+        selection = ENV.fetch("FONTISAN_ENGINE", "auto").strip.downcase
+        selection = "auto" if selection.empty?
+        unless SELECTIONS.include?(selection)
+          raise ConfigError,
+                "FONTISAN_ENGINE=#{selection.inspect} is not one of " \
+                "#{SELECTIONS.join(', ')}"
+        end
+
+        Config.new(selection.to_sym, strict_from_env)
+      end
+
+      # 1/true/yes/on is strict; unset, empty and 0/false/no/off is not. Any
+      # other value raises, as an unknown FONTISAN_ENGINE does: a typo must not
+      # silently leave a service non-strict.
+      def strict_from_env
+        value = ENV.fetch("FONTISAN_ENGINE_STRICT", "").strip.downcase
+        return true if STRICT_ON.include?(value)
+        return false if STRICT_OFF.include?(value)
+
+        raise ConfigError,
+              "FONTISAN_ENGINE_STRICT=#{value.inspect} is not one of " \
+              "#{(STRICT_ON + STRICT_OFF.reject(&:empty?)).join(', ')}"
+      end
+
+      # The java-platform gem has no `brotli`: a WOFF2 operation that no other
+      # tier took must fail here, at setup, not as a LoadError mid-parse.
+      def require_woff2_support!(operation, path, options)
+        return unless woff2_operation?(path, options)
+        return if Utilities::BrotliWrapper.available?
+
+        raise Woff2Unavailable,
+              "#{operation} on WOFF2 needs the ffi tier or the `brotli` gem; " \
+              "neither is available. #{Utilities::BrotliWrapper::MISSING_MESSAGE}"
+      end
+
+      def woff2_operation?(path, options)
+        File.extname(path.to_s).casecmp?(".woff2") ||
+          options&.dig(:to).to_s.casecmp?("woff2")
+      end
+
+      def forced?(selection)
+        %i[native ffi].include?(selection)
+      end
+
+      def candidates(config)
+        case config.selection
+        when :auto then AUTO_ORDER
+        when :ruby then [:ruby]
+        else [config.selection]
+        end
+      end
+
+      def tier_object(name)
+        case name
+        when :ruby then @tiers.fetch(:ruby)
+        else @tiers[name] || { native: Native, ffi: Ffi }.fetch(name)
+        end
+      end
+
+      def available?(name)
+        @mutex.synchronize do
+          return @availability[name] if @availability.key?(name)
+        end
+        result = probe(name)
+        @mutex.synchronize { @availability[name] = result }
+      end
+
+      # Any failure while probing is "not available"; never an exception.
+      def probe(name)
+        tier_object(name).available? || false
+      rescue StandardError, ScriptError
+        false
+      end
+
+      # A tier may also vet the call's keyword options (`supports_options?`).
+      def supports?(name, operation, path, options = nil)
+        tier = tier_object(name)
+        return false unless tier.supports?(operation, path)
+        return true unless options && tier.respond_to?(:supports_options?)
+
+        takes_path = tier.method(:supports_options?).arity.abs > 2
+        (takes_path ? tier.supports_options?(operation, options, path) : tier.supports_options?(operation, options)) || false
+      rescue StandardError, ScriptError
+        false
+      end
+
+      def run(tier, operation, path, args, kwargs, &)
+        record(tier, operation, path)
+        previous = Thread.current[IN_OPERATION]
+        Thread.current[IN_OPERATION] = true
+        begin
+          tier_object(tier).call(operation, *args, **kwargs, &)
+        ensure
+          Thread.current[IN_OPERATION] = previous
+        end
+      end
+
+      def record(tier, operation, path)
+        @mutex.synchronize do
+          @served[operation] = tier
+          table = (@counters ||= Hash.new { |h, k| h[k] = Hash.new(0) })
+          table[tier][operation] += 1
+        end
+        recorder = Thread.current[ROW_RECORDER]
+        recorder[path] = tier if recorder && path
+      end
+
+      def scan_rows(args, kwargs)
+        raise ArgumentError, "scan takes the paths only" unless kwargs.empty?
+
+        setup!
+
+        scan_pairs(*args).flat_map { |_tier, rows| rows }
+      end
+
+      # [[tier, rows], ...] one pair per path, in input order.
+      def scan_pairs(paths)
+        Array(paths).map do |path|
+          path_s = path.respond_to?(:to_path) ? path.to_path : path
+          tier = resolve(:scan, path_s.is_a?(String) ? path_s : nil)
+          record(tier, :scan, nil)
+          [tier, tier_object(tier).call(:scan, [path]).to_a]
+        end
+      end
+
+      def with_recorder(seen)
+        previous = Thread.current[ROW_RECORDER]
+        Thread.current[ROW_RECORDER] = seen
+        yield
+      ensure
+        Thread.current[ROW_RECORDER] = previous
+      end
+    end
+  end
+end

data/lib/fontisan/ffi/client.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Fontisan
+  module Ffi
+    # One loaded copy of the cdylib: the C structs of fontisan.h (ABI 1) and
+    # the three exported functions. Only this file requires the optional `ffi`
+    # gem, and only {Fontisan::Ffi} requires this file.
+    class Client
+      MAGIC = 0x4E415346 # "FSAN"
+      ABI_VERSION = 1
+
+      OK = 0
+      INVALID_ARG = 7
+      READ_FAILED = 9
+      UNSUPPORTED = 10
+
+      # The result block of one call; its pointers die with {#close}.
+      Reply = Struct.new(:status, :payload, :message)
+
+      class Header < FFI::Struct
+        layout :magic, :uint32, :abi_version, :uint32, :struct_size, :uint32,
+               :reserved, :uint32
+      end
+
+      class Request < FFI::Struct
+        layout :header, Header, :op, :uint32, :flags, :uint32,
+               :input, :pointer, :input_len, :size_t
+      end
+
+      class ErrorRow < FFI::Struct
+        layout :code, :int32, :message, :pointer, :message_len, :size_t
+      end
+
+      class Result < FFI::Struct
+        layout :header, Header, :status, :int32, :error, ErrorRow,
+               :payload, :pointer, :payload_len, :size_t
+      end
+
+      # Loads +path+ and binds its symbols.
+      #
+      # @return [Module] an FFI::Library with the exported functions attached
+      def self.bind(path)
+        Module.new do
+          extend FFI::Library
+
+          ffi_lib path
+          attach_function :fontisan_abi_version, [], :uint32
+          attach_function :fontisan_call, %i[pointer pointer], :int32
+          attach_function :fontisan_result_free, [:pointer], :void
+          attach_function :fontisan_cdylib_engine_rev, [], :string
+        end
+      end
+
+      # @raise [LoadError] when the library or one of its symbols is missing; a
+      #   library from before the engine-rev symbol existed is stale, so it too
+      # @raise [Fontisan::Ffi::AbiMismatch] when it speaks another ABI version
+      #   or was built from another engine rev than {Fontisan::Native::ENGINE_REV}
+      def initialize(path)
+        @binding = self.class.bind(path)
+        found = @binding.fontisan_abi_version
+        raise AbiMismatch, "#{path} speaks ABI #{found}, this gem expects #{ABI_VERSION}" unless found == ABI_VERSION
+
+        rev = @binding.fontisan_cdylib_engine_rev
+        return if rev == Fontisan::Native::ENGINE_REV
+
+        raise AbiMismatch, "#{path} was built from engine #{rev}, this gem expects #{Fontisan::Native::ENGINE_REV}"
+      rescue FFI::NotFoundError => e
+        raise LoadError, e.message
+      end
+
+      # Run one operation.
+      #
+      # @param operation [Integer] a FONTISAN_OP_* number
+      # @param input [String] the request bytes
+      # @param flags [Integer]
+      # @return [Reply]
+      def call(operation, input, flags = 0)
+        input = input.b
+        buffer = FFI::MemoryPointer.new(:uint8, [input.bytesize, 1].max)
+        buffer.put_bytes(0, input)
+        out = FFI::MemoryPointer.new(:pointer)
+        @binding.fontisan_call(request(operation, flags, buffer, input.bytesize), out)
+        read_result(out.read_pointer)
+      end
+
+      private
+
+      def request(operation, flags, buffer, length)
+        req = Request.new
+        req[:header][:magic] = MAGIC
+        req[:header][:abi_version] = ABI_VERSION
+        req[:header][:struct_size] = Request.size
+        req[:header][:reserved] = 0
+        req[:op] = operation
+        req[:flags] = flags
+        req[:input] = buffer
+        req[:input_len] = length
+        req
+      end
+
+      def read_result(pointer)
+        raise Fontisan::Error, "fontisan_call returned no result block" if pointer.null?
+
+        result = Result.new(pointer)
+        Reply.new(result[:status], bytes(result[:payload], result[:payload_len]),
+                  bytes(result[:error][:message], result[:error][:message_len])
+                    .force_encoding(Encoding::UTF_8))
+      ensure
+        @binding.fontisan_result_free(pointer) unless pointer.null?
+      end
+
+      def bytes(pointer, length)
+        return "".b if pointer.null? || length.zero?
+
+        pointer.read_bytes(length)
+      end
+    end
+  end
+end