zaniah 0.1.0

data/lib/zaniah/task.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "thread"
+require_relative "subscription"
+
+module Zaniah
+  class Task
+    def initialize
+      @mutex, @condition = Mutex.new, ConditionVariable.new
+      @done = false
+      @callbacks = []
+    end
+
+    def resolve(value = nil, error: nil)
+      callbacks = @mutex.synchronize do
+        return if @done
+        @value, @error, @done = value, error, true
+        @condition.broadcast
+        saved, @callbacks = @callbacks, []
+        saved
+      end
+      callbacks.each(&:call)
+    end
+
+    def await(timeout: nil)
+      return TaskExecutor.current.await(self, timeout: timeout) if TaskExecutor.current && !done?
+      deadline = timeout && Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      @mutex.synchronize do
+        until @done
+          remaining = deadline && deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          raise Timeout, "task timed out" if remaining && remaining <= 0
+          @condition.wait(@mutex, remaining)
+        end
+        raise @error if @error
+        @value
+      end
+    end
+
+    def cancel = resolve(error: Cancelled.new("task cancelled"))
+    def done? = @mutex.synchronize { @done }
+
+    def on_complete(&callback)
+      complete = @mutex.synchronize { @done || (@callbacks << callback; false) }
+      callback.call if complete
+      Subscription.new { @mutex.synchronize { @callbacks.delete(callback) } }
+    end
+  end
+end
+
+require_relative "task/cancelled"
+require_relative "task/timeout"

data/lib/zaniah/task_executor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "thread"
+require_relative "task"
+
+module Zaniah
+  class TaskExecutor
+    def self.current = Thread.current[:zaniah_executor]
+
+    def initialize(workers: 2)
+      @jobs, @foreground = Queue.new, Queue.new
+      @wake, @condition = Mutex.new, ConditionVariable.new
+      @timers = []
+      @threads = Array.new(workers) do
+        Thread.new do
+          while (job = @jobs.pop)
+            task, work = job
+            next if task.done?
+            begin
+              task.resolve(work.call)
+            rescue StandardError => error
+              task.resolve(error: error)
+            end
+          end
+        end
+      end
+    end
+
+    def background(&block)
+      raise Error, "executor is shut down" if @closed
+      task = Task.new
+      @jobs << [task, block]
+      task
+    end
+
+    def spawn(&block)
+      raise Error, "executor is shut down" if @closed
+      task = Task.new
+      fiber = Fiber.new do
+        Thread.current[:zaniah_executor] = self
+        Thread.current[:zaniah_task] = task
+        begin
+          task.resolve(block.call)
+        rescue StandardError => error
+          task.resolve(error: error)
+        end
+      end
+      post { fiber.resume unless task.done? }
+      task
+    end
+
+    def await(task, timeout: nil)
+      raise Error, "await must run in an executor fiber" unless self.class.current.equal?(self)
+      return task.await(timeout: timeout) if task.done?
+      fiber, owner = Fiber.current, Thread.current[:zaniah_task]
+      finished, error, deadline = false, nil, nil
+      finish = lambda do |failure = nil|
+        next if finished
+        finished, error = true, failure
+        fiber.resume if fiber.alive? && !owner.done?
+      end
+      subscription = task.on_complete { post { finish.call } }
+      cancellation = owner.on_complete { post { subscription.detach; @timers.delete(deadline) if deadline } }
+      if timeout
+        raise ArgumentError, "timeout must be nonnegative" unless timeout.is_a?(Numeric) && timeout >= 0
+        deadline = [Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout, -> { finish.call(Task::Timeout.new("task timed out")) }]
+        @timers << deadline
+      end
+      Fiber.yield
+      raise error if error
+      task.await(timeout: 0)
+    ensure
+      subscription&.detach
+      cancellation&.detach
+      @timers.delete(deadline) if deadline
+    end
+
+    def post(&block)
+      @foreground << block
+      @wake.synchronize { @condition.signal }
+    end
+
+    def drain
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      due, @timers = @timers.partition { |deadline, _| deadline <= now }
+      due.each { |_, callback| callback.call }
+      loop { @foreground.pop(true).call }
+    rescue ThreadError
+      nil
+    end
+
+    def wait(seconds)
+      deadline = @timers.map(&:first).min
+      seconds = [seconds, [deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC), 0].max].min if deadline
+      @wake.synchronize { @condition.wait(@wake, seconds) if @foreground.empty? }
+    end
+
+    def shutdown
+      return if @closed
+      @closed = true
+      @threads.length.times { @jobs << nil }
+      @threads.each(&:join)
+    end
+  end
+end

data/lib/zaniah/text.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Text < Element
+    def initialize(text, size: 14, color: "#ddd", font: nil)
+      super()
+      @text, @font_size, @color, @font = text, size, color, font
+    end
+
+    def measured(&block) = (@measure = block; self)
+
+    def request_layout(cx)
+      @line = cx.text_system&.layout_line(@text, font: @font, size: @font_size)
+      measurement = @measure || ->(_width, _height) { [@line ? @line.width : @text.length * @font_size * 0.6, @font_size * 1.4, @font_size] }
+      @layout_node = Layout::Node.new(style: @style, measure: measurement)
+    end
+
+    def paint(bounds, state, prepaint, cx)
+      super
+      cx.text_system&.paint_line(cx.scene, @line, x: bounds.x, y: bounds.y + @line.ascent, color: @color) if @line
+      cx.window.text_runs << [bounds.x, bounds.y, @text, @color] if cx.window.respond_to?(:text_runs)
+    end
+  end
+end

data/lib/zaniah/text_system/atlas/entry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module TextSystem
+    class Atlas
+      Entry = Data.define(:texture, :x, :y, :width, :height, :left, :top)
+    end
+  end
+end

data/lib/zaniah/text_system/atlas.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module TextSystem
+    class Atlas
+      attr_reader :generation, :texture
+
+      def initialize(width: 2048, height: 2048, format: :r8)
+        @width, @height, @format = width, height, format
+        @generation, @cache, @retired = 0, {}, []
+        reset
+      end
+
+      def fetch(key)
+        return @cache[key] if @cache.key?(key)
+        bitmap = yield
+        raise Error, "glyph exceeds atlas dimensions" if bitmap.width + 2 > @width || bitmap.height + 2 > @height
+        position = allocate(bitmap.width + 2, bitmap.height + 2)
+        unless position
+          @retired << @texture
+          reset
+          position = allocate(bitmap.width + 2, bitmap.height + 2)
+        end
+        x, y = position.map { |value| value + 1 }
+        @texture.upload(x, y, bitmap.width, bitmap.height, @format == :rgba8 ? bitmap.rgba : bitmap.coverage)
+        @cache[key] = Entry.new(@texture, x, y, bitmap.width, bitmap.height, bitmap.left, bitmap.top)
+      end
+
+      def lookup(key) = @cache[key]
+      def end_frame = @retired.clear
+
+      def save_cache(path, key:)
+        require_relative "atlas_cache"
+        AtlasCache.save(path, key: key, texture: @texture, skyline: @skyline, entries: @cache)
+      end
+
+      def load_cache(path, key:, preserve: false)
+        require_relative "atlas_cache"
+        loaded = AtlasCache.load(path, key: key, width: @width, height: @height, format: @format)
+        return false unless loaded
+        return false if preserve && @cache.any? { |id, _| !loaded.last.key?(id) }
+        @retired << @texture
+        @texture, @skyline, @cache = loaded
+        @generation += 1
+        true
+      end
+
+      private
+
+      def reset
+        @texture = GPU::Texture.new(@width, @height, format: @format)
+        @skyline = [[0, 0, @width]]
+        @cache.clear
+        @generation += 1
+      end
+
+      def allocate(width, height)
+        choice = nil
+        @skyline.each_index do |index|
+          x, y, = @skyline[index]
+          next if x + width > @width
+          remaining, cursor = width, index
+          while remaining.positive? && cursor < @skyline.length
+            y = [y, @skyline[cursor][1]].max
+            break if y + height > @height
+            remaining -= @skyline[cursor][2]
+            cursor += 1
+          end
+          next if remaining.positive? || y + height > @height
+          choice = [x, y, index] if choice.nil? || y < choice[1] || (y == choice[1] && x < choice[0])
+        end
+        return unless choice
+        x, y, index = choice
+        @skyline.insert(index, [x, y + height, width])
+        cursor = index + 1
+        while cursor < @skyline.length
+          previous, current = @skyline[cursor - 1], @skyline[cursor]
+          overlap = previous[0] + previous[2] - current[0]
+          break if overlap <= 0
+          if current[2] <= overlap
+            @skyline.delete_at(cursor)
+          else
+            current[0] += overlap
+            current[2] -= overlap
+            break
+          end
+        end
+        cursor = 0
+        while cursor + 1 < @skyline.length
+          if @skyline[cursor][1] == @skyline[cursor + 1][1]
+            @skyline[cursor][2] += @skyline.delete_at(cursor + 1)[2]
+          else
+            cursor += 1
+          end
+        end
+        [x, y]
+      end
+    end
+  end
+end
+
+require_relative "atlas/entry"

data/lib/zaniah/text_system/atlas_cache.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "tempfile"
+require "fileutils"
+
+module Zaniah
+  module TextSystem
+    # A bounded JSON manifest plus raw occupied texture rows. No Ruby objects are
+    # deserialized, and no texture allocation happens until every bound is checked.
+    module AtlasCache
+      MAGIC = "TSATLAS\0".b.freeze
+      VERSION = 1
+      HEADER_BYTES = 52
+      MAX_METADATA = 2 << 20
+      MAX_PIXELS = 32 << 20
+      MAX_ENTRIES = 16_384
+      WINDOWS = RUBY_PLATFORM.match?(/mingw|mswin/)
+
+      def self.save(path, key:, texture:, skyline:, entries:)
+        path = safe_path(path, create: true)
+        return false unless path
+        rows = skyline.map { |_, y, _| y }.max || 0
+        records = entries.map { |id, entry| [id, entry.x, entry.y, entry.width, entry.height, entry.left, entry.top] }
+        metadata = {"key" => key, "width" => texture.width, "height" => texture.height,
+          "format" => texture.format.to_s, "rows" => rows, "skyline" => skyline, "entries" => records}
+        return false unless valid_metadata?(metadata, key: key, width: texture.width, height: texture.height, format: texture.format)
+        json = JSON.generate(metadata)
+        return false if json.bytesize > MAX_METADATA
+        pixels = texture.data.byteslice(0, texture.width * rows * (texture.format == :r8 ? 1 : 4))
+        digest = Digest::SHA256.new.update(json).update(pixels).digest
+        header = MAGIC + [VERSION, json.bytesize, pixels.bytesize].pack("N3") + digest
+        Tempfile.create([".zaniah-atlas-", ".tmp"], File.dirname(path)) do |file|
+          file.binmode
+          file.write(header)
+          file.write(json)
+          file.write(pixels)
+          file.flush
+          file.fsync
+          file.close
+          attempts = 0
+          begin
+            File.rename(file.path, path)
+          rescue Errno::EACCES, Errno::EEXIST
+            raise unless WINDOWS && (attempts += 1) <= 10
+            sleep(0.001 * attempts)
+            retry
+          end
+        end
+        true
+      rescue SystemCallError, IOError, JSON::GeneratorError
+        false
+      end
+
+      def self.load(path, key:, width:, height:, format:)
+        path = safe_path(path, create: false)
+        return unless path
+        flags = File::RDONLY
+        flags |= File::NOFOLLOW if defined?(File::NOFOLLOW) && !WINDOWS
+        File.open(path, flags) do |file|
+          file.binmode
+          stat, location = file.stat, File.lstat(path)
+          return unless stat.file? && location.file?
+          return unless WINDOWS || (stat.ino == location.ino && stat.dev == location.dev)
+          return unless stat.size.between?(HEADER_BYTES, HEADER_BYTES + MAX_METADATA + MAX_PIXELS)
+          header = file.read(HEADER_BYTES)
+          return unless header&.bytesize == HEADER_BYTES && header.byteslice(0, 8) == MAGIC
+          version, json_size, pixel_size = header.byteslice(8, 12).unpack("N3")
+          return unless version == VERSION && json_size.between?(2, MAX_METADATA) && pixel_size <= MAX_PIXELS
+          return unless stat.size == HEADER_BYTES + json_size + pixel_size
+          json, pixels = file.read(json_size), file.read(pixel_size)
+          return unless json&.bytesize == json_size && pixels&.bytesize == pixel_size
+          return unless Digest::SHA256.new.update(json).update(pixels).digest == header.byteslice(20, 32)
+          metadata = JSON.parse(json, max_nesting: 8, create_additions: false)
+          return unless valid_metadata?(metadata, key: key, width: width, height: height, format: format)
+          return unless pixels.bytesize == width * metadata["rows"] * (format == :r8 ? 1 : 4)
+          texture = GPU::Texture.new(width, height, format: format)
+          texture.upload(0, 0, width, metadata["rows"], pixels)
+          entries = metadata["entries"].to_h do |id, x, y, w, h, left, top|
+            [id.freeze, Atlas::Entry.new(texture, x, y, w, h, left, top)]
+          end
+          [texture, metadata["skyline"], entries]
+        end
+      rescue SystemCallError, IOError, JSON::ParserError, EncodingError
+        nil
+      end
+
+      def self.safe_path(path, create:)
+        raise ArgumentError, "atlas cache path must be a nonempty string" unless path.is_a?(String) && !path.empty? && !path.include?("\0")
+        path = File.expand_path(path)
+        directory = File.dirname(path)
+        return if File.symlink?(directory) || File.symlink?(path)
+        FileUtils.mkdir_p(directory, mode: 0o700) if create && !File.exist?(directory)
+        return unless File.directory?(directory)
+        File.join(File.realpath(directory), File.basename(path))
+      end
+
+      def self.valid_metadata?(data, key:, width:, height:, format:)
+        return false unless data.is_a?(Hash) && data["key"] == key && key.is_a?(String) && key.bytesize.between?(1, 4096)
+        return false unless data["width"] == width && data["height"] == height && data["format"] == format.to_s
+        return false unless width.is_a?(Integer) && height.is_a?(Integer) && width.between?(1, 8192) && height.between?(1, 8192)
+        return false unless [:r8, :rgba8].include?(format) && width * height * (format == :r8 ? 1 : 4) <= MAX_PIXELS
+        rows, skyline, entries = data.values_at("rows", "skyline", "entries")
+        return false unless rows.is_a?(Integer) && rows.between?(0, height) && skyline.is_a?(Array) && skyline.length.between?(1, width)
+        return false unless entries.is_a?(Array) && entries.length <= MAX_ENTRIES
+        cursor, highest = 0, 0
+        skyline.each do |segment|
+          return false unless segment.is_a?(Array) && segment.length == 3 && segment.all? { |value| value.is_a?(Integer) }
+          x, y, span = segment
+          return false unless x == cursor && y.between?(0, rows) && span.positive? && x + span <= width
+          cursor += span
+          highest = y if y > highest
+        end
+        return false unless cursor == width && highest == rows
+        seen, area = {}, 0
+        entries.each do |record|
+          return false unless record.is_a?(Array) && record.length == 7
+          id, x, y, w, h, left, top = record
+          return false unless valid_id?(id) && !seen.key?(id)
+          seen[id] = true
+          return false unless [x, y, w, h, left, top].all? { |value| value.is_a?(Integer) }
+          return false unless x >= 1 && y >= 1 && w >= 0 && h >= 0 && x + w + 1 <= width && y + h + 1 <= rows
+          return false unless left.abs <= 1_000_000 && top.abs <= 1_000_000
+          area += (w + 2) * (h + 2)
+          return false if area > width * rows
+          # Restored skyline allocation must not overwrite an existing glyph.
+          cursor = skyline.bsearch_index { |sx, _, sw| sx + sw > x - 1 }
+          while cursor && cursor < skyline.length && skyline[cursor][0] < x + w + 1
+            return false if skyline[cursor][1] < y + h + 1
+            cursor += 1
+          end
+        end
+        true
+      end
+
+      def self.valid_id?(id)
+        return false unless id.is_a?(Array) && id.length == 4
+        font, glyph, size, bucket = id
+        font.is_a?(String) && font.match?(/\A[0-9a-f]{64}\z/) && glyph.is_a?(Integer) && glyph.between?(0, 0xffffffff) &&
+          size.is_a?(Numeric) && size.finite? && size.positive? && size <= 16_384 && bucket.is_a?(Integer) && bucket.between?(0, 3)
+      end
+      private_class_method :safe_path, :valid_metadata?, :valid_id?
+    end
+  end
+end

data/lib/zaniah/text_system/font_db/face.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module TextSystem
+    class FontDB
+      Face = Data.define(:path, :index, :family, :families, :weight, :width, :style, :fixed_pitch, :tables)
+    end
+  end
+end

data/lib/zaniah/text_system/font_db.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "alhena"
+
+module Zaniah
+  module TextSystem
+    # Reads directories and small metadata tables, never outlines during discovery.
+    class FontDB
+      PREFERRED = %w[Menlo DejaVu\ Sans\ Mono Consolas Liberation\ Mono Noto\ Sans\ Mono].freeze
+      MAX_TABLE = 8 << 20
+      attr_reader :paths
+
+      def initialize(paths: nil)
+        roots = if RUBY_PLATFORM.include?("darwin")
+          ["/System/Library/Fonts", "/Library/Fonts", File.expand_path("~/Library/Fonts")]
+        elsif RUBY_PLATFORM.match?(/mswin|mingw/)
+          [File.join(ENV.fetch("WINDIR", "C:/Windows"), "Fonts")]
+        else
+          ["/usr/share/fonts", "/usr/local/share/fonts", File.expand_path("~/.local/share/fonts"), File.expand_path("~/.fonts")]
+        end
+        paths ||= roots.flat_map { |root| Dir[File.join(root, "**", "*.{ttf,otf,ttc,otc,TTF,OTF,TTC,OTC}")] }
+        raise ArgumentError, "font paths must be an array" unless paths.is_a?(Array) && paths.all? { |path| path.is_a?(String) && !path.include?("\0") }
+        @paths = paths.map { |path| File.expand_path(path) }.uniq.freeze
+        refresh
+      end
+
+      def refresh
+        @faces, @fonts, @data, @fallback, @probes, @matches, @normalized = nil, {}, {}, {}, {}, {}, {}
+        self
+      end
+
+      def faces
+        @faces ||= @paths.flat_map do |path|
+          File.open(path, "rb") do |io|
+            header = read(io, 0, 12)
+            offsets = if header.bytes(0, 4) == "ttcf"
+              raise Error, "unsupported font collection version" unless [0x10000, 0x20000].include?(header.u32(4))
+              count = header.u32(8)
+              raise Error, "font collection exceeds face limit" unless count.between?(1, 4096)
+              read(io, 12, count * 4).data.unpack("N*")
+            else
+              [0]
+            end
+            offsets.each_with_index.filter_map do |offset, index|
+              metadata(io, path, offset, index)
+            rescue Error, Alhena::Error, EncodingError, ArgumentError
+              nil
+            end
+          end
+        rescue SystemCallError, IOError, Error, Alhena::Error
+          []
+        end.freeze
+      end
+
+      def open(path, index: 0)
+        path = File.expand_path(path)
+        @fonts[[path, index]] ||= Alhena::Font.new(@data[path] ||= File.binread(path).freeze, index: index)
+      end
+
+      def find(family: nil, weight: 400, width: 5, style: :normal)
+        raise ArgumentError, "family must be a string" unless family.nil? || family.is_a?(String)
+        raise ArgumentError, "weight must be in 1..1000" unless weight.is_a?(Integer) && weight.between?(1, 1000)
+        raise ArgumentError, "width must be an OS/2 class in 1..9" unless width.is_a?(Integer) && width.between?(1, 9)
+        raise ArgumentError, "style must be normal, italic or oblique" unless %i[normal italic oblique].include?(style)
+        key = [family && normalize(family), weight, width, style]
+        @matches[key] ||= begin
+          requested = key[0]
+          candidates = requested ? faces.select { |face| face.families.any? { |name| normalize(name) == requested } } : []
+          candidates = faces if candidates.empty?
+          candidates.sort_by do |face|
+            family_rank = if requested && face.families.any? { |name| normalize(name) == requested }
+              0
+            else
+              PREFERRED.index { |name| face.families.any? { |alias_name| normalize(alias_name) == normalize(name) } } || (face.fixed_pitch ? PREFERRED.length : PREFERRED.length + 1)
+            end
+            [family_rank, width_rank(face.width, width), style_rank(face.style, style), weight_rank(face.weight, weight), face.path, face.index]
+          end.each do |face|
+            begin
+              font = open(face.path, index: face.index)
+              # Reject incomplete/corrupt sfnts here, before handing one to layout.
+              font.units_per_em
+              font.ascent
+              font.glyph_id(32)
+              break font
+            rescue Alhena::Error, SystemCallError, IOError
+              next
+            end
+          end.then do |found|
+            found.is_a?(Alhena::Font) ? found : bundled_font
+          end
+        end
+      end
+
+      def fallback(codepoint, primary)
+        return primary unless primary.glyph_id(codepoint).zero?
+        @fallback[[primary, codepoint]] ||= begin
+          found = faces.find do |face|
+            probe = @probes[[face.path, face.index]] ||= probe_font(face)
+            !probe.glyph_id(codepoint).zero?
+          rescue Error, Alhena::Error, SystemCallError, IOError
+            false
+          end
+          found ? open(found.path, index: found.index) : primary
+        end
+      end
+
+      private
+
+      def normalize(name) = @normalized[name] ||= name.unicode_normalize(:nfkc).downcase(:fold).gsub(/\s+/, " ").strip.freeze
+      def width_rank(actual, wanted)
+        wanted <= 5 ? [actual > wanted ? 1 : 0, (actual - wanted).abs] : [actual < wanted ? 1 : 0, (actual - wanted).abs]
+      end
+      def style_rank(actual, wanted)
+        {normal: %i[normal oblique italic], italic: %i[italic oblique normal], oblique: %i[oblique italic normal]}.fetch(wanted).index(actual)
+      end
+      def weight_rank(actual, wanted)
+        if wanted.between?(400, 500)
+          actual.between?(wanted, 500) ? [0, actual - wanted] : actual < wanted ? [1, wanted - actual] : [2, actual - 500]
+        else
+          preferred = wanted < 400 ? actual <= wanted : actual >= wanted
+          [preferred ? 0 : 1, (actual - wanted).abs]
+        end
+      end
+      def bundled_font
+        path = File.expand_path("../../../assets/fonts/Abel-Regular.ttf", __dir__)
+        raise Error, "no readable TrueType/OpenType font found" unless File.file?(path)
+        open(path)
+      end
+      def read(io, offset, length)
+        raise Error, "font metadata outside size limit" unless offset >= 0 && length >= 0 && length <= MAX_TABLE
+        io.seek(offset)
+        bytes = io.read(length)
+        raise Error, "truncated font metadata" unless bytes && bytes.bytesize == length
+        Alhena::Binary.new(bytes)
+      end
+      def metadata(io, path, offset, index)
+        header = read(io, offset, 12)
+        raise Error, "not an sfnt font" unless ["\x00\x01\x00\x00".b, "OTTO", "true"].include?(header.bytes(0, 4))
+        count = header.u16(4)
+        raise Error, "invalid sfnt table count" unless count.between?(1, 4096)
+        directory = read(io, offset + 12, count * 16)
+        size = io.stat.size
+        tables = count.times.to_h do |i|
+          at = i * 16
+          tag, start, length = directory.bytes(at, 4), directory.u32(at + 8), directory.u32(at + 12)
+          raise Error, "sfnt table outside file" if start > size - length
+          [tag, [start, length].freeze]
+        end
+        raise Error, "duplicate sfnt tables" unless tables.length == count
+        names = family_names(read(io, *tables.fetch("name")))
+        raise Error, "font has no family name" if names.empty?
+        os2 = tables["OS/2"] && read(io, tables["OS/2"][0], [tables["OS/2"][1], 64].min)
+        weight, width = os2 ? [os2.u16(4), os2.u16(6)] : [400, 5]
+        weight, width = 400, 5 unless weight.between?(1, 1000) && width.between?(1, 9)
+        post = tables["post"] && read(io, tables["post"][0], [tables["post"][1], 16].min)
+        flags = os2 && os2.size >= 64 ? os2.u16(62) : 0
+        style = flags & 512 != 0 ? :oblique : flags & 1 != 0 || (post && post.i32(4) != 0) ? :italic : :normal
+        Face.new(path, index, names.first, names.freeze, weight, width, style, !!(post && post.u32(12) != 0), tables.freeze)
+      rescue KeyError
+        raise Error, "missing font metadata table"
+      end
+      def family_names(data)
+        count, storage = data.u16(2), data.u16(4)
+        data.check(6, count * 12)
+        count.times.filter_map do |i|
+          platform, encoding, language, id, length, offset = data.bytes(6 + i * 12, 12).unpack("n6")
+          next unless [1, 16, 21].include?(id) && ([0, 3].include?(platform) || (platform == 1 && encoding.zero?))
+          text = data.bytes(storage + offset, length).force_encoding(platform == 1 ? "macRoman" : "UTF-16BE").encode("UTF-8")
+          next if text.empty?
+          [id == 16 ? 0 : id == 1 ? 1 : 2, platform == 3 && language == 0x409 ? 0 : 1, text.freeze]
+        end.sort_by { |priority, language, _| [priority, language] }.map(&:last).uniq
+      end
+      def probe_font(face)
+        tables = File.open(face.path, "rb") do |io|
+          %w[cmap maxp].to_h { |tag| [tag, read(io, *face.tables.fetch(tag)).data] }
+        end
+        # Reuse Alhena's checked cmap 0/4/6/12/13 parser on a tiny sfnt;
+        # no glyph outlines or full collection blobs are loaded for misses.
+        offset, directory, payload = 12 + tables.length * 16, "".b, "".b
+        tables.each do |tag, bytes|
+          directory << [tag, 0, offset, bytes.bytesize].pack("a4N3")
+          payload << bytes
+          offset += bytes.bytesize
+        end
+        Alhena::Font.new([0x10000, tables.length, 0, 0, 0].pack("Nn4") + directory + payload)
+      rescue KeyError
+        raise Error, "font has no Unicode cmap"
+      end
+    end
+  end
+end
+
+require_relative "font_db/face"

data/lib/zaniah/text_system/glyph.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module TextSystem
+    Glyph = Data.define(:font, :id, :start, :finish, :x, :advance)
+  end
+end

data/lib/zaniah/text_system/line_layout.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module TextSystem
+    LineLayout = Data.define(:text, :glyphs, :width, :ascent, :descent, :size, :carets) do
+      def index_for_x(x)
+        index = carets.bsearch_index { |_, position| position >= x }
+        return text.bytesize unless index
+        return carets.first.first if index.zero?
+        previous, following = carets[index - 1], carets[index]
+        x - previous.last <= following.last - x ? previous.first : following.first
+      end
+
+      def x_for_index(index)
+        caret = carets.bsearch { |byte, _| byte >= index }
+        caret ? caret.last : width
+      end
+    end
+  end
+end