zaniah 0.1.0

data/sig/input.rbs

@@ -0,0 +1,114 @@
+module Zaniah
+  module Input
+    type modifiers = Array[String]
+    type button = :left | :middle | :right | Integer
+    type context = Hash[String | Symbol, String | Symbol | Numeric | bool | nil]
+    type action = String | Symbol | Hash[String, untyped] | Array[untyped]
+    type event = KeyDown | KeyUp | TextInput | Composition | mouse_event | FileDrop
+    type mouse_event = MouseDown | MouseUp | MouseMove | ScrollWheel
+
+    class KeyDown < Data
+      attr_reader keystroke: String
+      attr_reader is_held: bool
+      def self.new: (String keystroke, bool is_held) -> KeyDown
+                  | (keystroke: String, is_held: bool) -> KeyDown
+    end
+    class KeyUp < Data
+      attr_reader keystroke: String
+      def self.new: (String keystroke) -> KeyUp
+                  | (keystroke: String) -> KeyUp
+    end
+    class TextInput < Data
+      attr_reader text: String
+      def self.new: (String text) -> TextInput
+                  | (text: String) -> TextInput
+    end
+    class MouseDown < Data
+      attr_reader position: Point
+      attr_reader button: button
+      attr_reader modifiers: modifiers
+      attr_reader click_count: Integer
+      def self.new: (Point position, button button, modifiers modifiers, Integer click_count) -> MouseDown
+                  | (position: Point, button: button, modifiers: modifiers, click_count: Integer) -> MouseDown
+    end
+    class MouseUp < Data
+      attr_reader position: Point
+      attr_reader button: button
+      attr_reader modifiers: modifiers
+      def self.new: (Point position, button button, modifiers modifiers) -> MouseUp
+                  | (position: Point, button: button, modifiers: modifiers) -> MouseUp
+    end
+    class MouseMove < Data
+      attr_reader position: Point
+      attr_reader modifiers: modifiers
+      def self.new: (Point position, modifiers modifiers) -> MouseMove
+                  | (position: Point, modifiers: modifiers) -> MouseMove
+    end
+    class ScrollWheel < Data
+      attr_reader position: Point
+      attr_reader delta: Point
+      attr_reader phase: Symbol
+      attr_reader modifiers: modifiers
+      def self.new: (Point position, Point delta, Symbol phase, modifiers modifiers) -> ScrollWheel
+                  | (position: Point, delta: Point, phase: Symbol, modifiers: modifiers) -> ScrollWheel
+    end
+    class Composition < Data
+      attr_reader text: String
+      attr_reader selection: [Integer, Integer]
+      def self.new: (String text, [Integer, Integer] selection) -> Composition
+                  | (text: String, selection: [Integer, Integer]) -> Composition
+    end
+    class FileDrop < Data
+      attr_reader paths: Array[String]
+      attr_reader position: Point
+      def self.new: (Array[String] paths, Point position) -> FileDrop
+                  | (paths: Array[String], position: Point) -> FileDrop
+    end
+    module Keystroke
+      def self.normalize: (String value) -> String
+    end
+    class ContextPredicate
+      def initialize: (String? source) -> void
+      def call: (context values) -> bool
+    end
+    class Keymap
+      class Binding < Data
+        attr_reader keys: Array[String]
+        attr_reader predicate: ContextPredicate
+        attr_reader action: action
+        def self.new: (Array[String] keys, ContextPredicate predicate, action action) -> Binding
+                    | (keys: Array[String], predicate: ContextPredicate, action: action) -> Binding
+      end
+      def initialize: (?timeout: Numeric) -> void
+      def bind: (String keys, action action, ?context: String) -> self
+      def load_json: (String text) -> self
+      def dispatch: (String key, ?context: context, ?now: Numeric) -> (action | :pending | nil)
+      def bindings: () -> Array[Binding]
+    end
+    class FocusHandle
+      attr_reader parent: FocusHandle?
+      attr_reader children: Array[FocusHandle]
+      attr_reader context: context
+      attr_accessor on_action: (^(action) -> bool)?
+      attr_accessor on_focus: (^(bool) -> void)?
+      def initialize: (?parent: FocusHandle?, ?context: context) -> void
+      def ancestors: () -> Array[FocusHandle]
+    end
+    class Dispatcher
+      attr_reader focused: FocusHandle?
+      def initialize: (?keymap: Keymap) -> void
+      def focus: (FocusHandle? handle) -> void
+      def key: (String key) -> (action | :pending | nil)
+      def clear_hits: () -> void
+      def hit: (Bounds bounds, ?clip: Bounds?) { (mouse_event | FileDrop) -> (bool | :capture | nil) } -> void
+      def clip: [T] (Bounds bounds) { () -> T } -> T
+      def mouse: (mouse_event | FileDrop event) -> bool
+    end
+    class ActionRegistry
+      def initialize: () -> void
+      def register: (String | Symbol name, ?description: String | Symbol) { (*untyped) -> untyped } -> void
+      def call: (String | Symbol name, *untyped args) -> untyped
+      def entries: () -> Hash[String, String | Symbol]
+    end
+  end
+end

data/sig/layout.rbs

@@ -0,0 +1,53 @@
+module Zaniah
+  module Layout
+    type style_value = dimension | Edges | Array[dimension] | Symbol | bool | nil
+    type properties = Hash[Symbol, style_value]
+    type measurement = [Numeric, Numeric] | [Numeric, Numeric, Numeric]
+    type measure = ^(Numeric width, Numeric height) -> measurement
+
+    class AvailableSpace < Data
+      attr_reader kind: :definite | :min_content | :max_content
+      attr_reader value: Numeric?
+      def self.new: (:definite | :min_content | :max_content kind, Numeric? value) -> AvailableSpace
+                  | (kind: :definite | :min_content | :max_content, value: Numeric?) -> AvailableSpace
+      def self.definite: (Numeric value) -> AvailableSpace
+      def self.min_content: () -> AvailableSpace
+      def self.max_content: () -> AvailableSpace
+    end
+    class Style
+      DEFAULTS: properties
+      def initialize: (**style_value properties) -> void
+      def []: (Symbol name) -> style_value
+      def merge: (**style_value properties) -> Style
+      def to_h: () -> properties
+    end
+    class Node
+      attr_reader style: Style
+      attr_reader children: Array[Node]
+      attr_reader generation: Integer
+      attr_accessor bounds: Bounds
+      attr_accessor parent: Node?
+      attr_accessor measure: measure?
+      attr_accessor baseline: Numeric
+      def initialize: (?style: Style | properties, ?children: Array[Node], ?measure: measure?) -> void
+      def add: (Node child) -> Node
+      def style=: (Style | properties style) -> void
+      def touch: () -> void
+    end
+    class Engine
+      def initialize: (?rem: Numeric) -> void
+      def compute: (Node root, width: Numeric, height: Numeric, ?x: Numeric, ?y: Numeric) -> Bounds
+      def measure: (Node node, width: Numeric, height: Numeric) -> [Numeric, Numeric]
+    end
+    class Tree
+      attr_reader nodes: Array[Node]
+      def initialize: () -> void
+      def new_node: (?style: Style | properties, ?children: Array[Node], ?measure: measure?) -> Integer
+      def add_child: (Integer parent, Integer child) -> Node
+      def set_style: (Integer id, **style_value style) -> Style
+      def compute: (Integer id, width: Numeric, height: Numeric) -> Bounds
+      def bounds: (Integer id) -> Bounds
+    end
+  end
+  class LayoutTree = Layout::Tree
+end

data/sig/native.rbs

@@ -0,0 +1,88 @@
+module Zaniah
+  module Platform
+    module Mac
+      class Window < Headless::Window
+        attr_reader handle: Integer
+        attr_reader view: Integer
+        attr_reader layer: Integer?
+        def initialize: (?gpu: :metal | :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def create_device: (:metal | :opengl | :gl backend) -> GPU::_Device
+        def tick: (?poll_events: bool) -> void
+        def run: () -> void
+        def clipboard: () -> String
+        def clipboard=: (String text) -> void
+        def clipboard_paths: () -> Array[String]
+        def appearance: () -> (:light | :dark)
+        def on_appearance: () { (:light | :dark) -> void } -> void
+        def tooltip=: (String text) -> void
+        def prompt_for_paths: (?multiple: bool, ?directories: bool, ?save: bool) -> Array[String]
+        def cursor_style=: (cursor style) -> void
+        def open_url: (String url) -> void
+        def toggle_fullscreen: () -> void
+      end
+    end
+    module Linux
+      class Window < Headless::Window
+        attr_reader handle: Integer
+        def self.new: (?display_server: :auto | :x11 | :wayland, ?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> (Window | WaylandWindow)
+        def initialize: (?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def create_device: (:opengl | :gl backend) -> GPU::OpenGL
+        def run: () -> void
+        def clipboard: () -> String?
+        def clipboard=: (String text) -> void
+        def clipboard_paths: () -> Array[String]
+        def appearance: () -> (:light | :dark)
+        def on_appearance: () { (:light | :dark) -> void } -> void
+        def prompt_for_paths: (?multiple: bool, ?directories: bool, ?save: bool) -> Array[String]
+        def cursor_style=: (cursor style) -> void
+        def open_url: (String url) -> bool
+        def toggle_fullscreen: () -> void
+      end
+      class WaylandWindow < Headless::Window
+        def initialize: (?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def create_device: (:opengl | :gl backend) -> GPU::OpenGL
+        def run: () -> void
+        def clipboard: () -> String?
+        def clipboard=: (String text) -> void
+        def clipboard_paths: () -> Array[String]
+        def appearance: () -> (:light | :dark)
+        def on_appearance: () { (:light | :dark) -> void } -> void
+        def on_delete_surrounding: () { (Integer before, Integer after) -> void } -> void
+        def surrounding_text: (String text, cursor: Integer, ?anchor: Integer) -> void
+        def prompt_for_paths: (?multiple: bool, ?directories: bool, ?save: bool) -> Array[String]
+        def cursor_style=: (cursor style) -> void
+        def open_url: (String url) -> bool
+        def toggle_fullscreen: () -> void
+      end
+    end
+    module Windows
+      class Window < Headless::Window
+        # Opaque native pointer; only integer conversion is portable.
+        attr_reader handle: _ToI
+        def initialize: (?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def create_device: (:opengl | :gl backend) -> GPU::OpenGL
+        def run: () -> void
+        def clipboard: () -> String?
+        def clipboard=: (String text) -> void
+        def clipboard_paths: () -> Array[String]
+        def appearance: () -> (:light | :dark)
+        def on_appearance: () { (:light | :dark) -> void } -> void
+        def context_menu: (menu items, ?position: Point?) -> void
+        def prompt_for_paths: (?multiple: bool, ?directories: bool, ?save: bool) -> Array[String]
+        def cursor_style=: (cursor style) -> void
+        def open_url: (String url) -> void
+        def toggle_fullscreen: () -> void
+      end
+      class Terminal
+        attr_reader pid: Integer
+        def initialize: (?command: String | Array[String] | nil, ?columns: Integer, ?rows: Integer, ?cwd: String?, ?env: Hash[String | Symbol, String | Numeric]) -> void
+        def self.quote_argument: (String value) -> String
+        def read_available: (?limit: Integer) -> String?
+        def write: (String bytes) -> Integer
+        def resize: (Integer columns, Integer rows) -> void
+        def alive?: () -> bool
+        def close: () -> void
+      end
+    end
+  end
+end

data/sig/platform.rbs

@@ -0,0 +1,94 @@
+module Zaniah
+  module Platform
+    type backend = :headless | :tui | :mac | :linux | :windows
+    type cursor = :arrow | :text | :pointer | :crosshair | :resize_horizontal | :resize_vertical
+    type text_run = [Numeric, Numeric, String, color]
+    type native_window = Mac::Window | Linux::Window | Linux::WaylandWindow | Windows::Window
+    class Display < Data
+      attr_reader id: Integer
+      attr_reader name: String
+      attr_reader bounds: Bounds
+      attr_reader scale_factor: Numeric
+      attr_reader primary: bool
+      def self.new: (Integer id, String name, Bounds bounds, Numeric scale_factor, bool primary) -> Display
+                  | (id: Integer, name: String, bounds: Bounds, scale_factor: Numeric, primary: bool) -> Display
+    end
+    def self.displays: (?backend: backend | :auto, ?display_server: :auto | :x11 | :wayland) -> Array[Display]
+
+    def self.open_window: (?backend: :headless, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> Headless::Window
+                        | (backend: :tui, ?input: IO, ?output: IO, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> TUI::Window
+                        | (backend: :mac, ?gpu: :metal | :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> Mac::Window
+                        | (backend: :linux, ?display_server: :auto | :x11 | :wayland, ?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> (Linux::Window | Linux::WaylandWindow)
+                        | (backend: :windows, ?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> Windows::Window
+
+    interface _Watcher
+      def poll: (?timeout: Numeric) -> Array[FileEvent]
+      def close: () -> void
+    end
+    class FileEvent < Data
+      attr_reader kind: :created | :modified | :deleted | :renamed | :overflow
+      attr_reader path: String?
+      attr_reader old_path: String?
+      def self.new: (:created | :modified | :deleted | :renamed | :overflow kind, String? path, String? old_path) -> FileEvent
+                  | (kind: :created | :modified | :deleted | :renamed | :overflow, path: String?, old_path: String?) -> FileEvent
+    end
+    def self.watch: (String | Array[String] paths, ?latency: Numeric) -> _Watcher
+
+    module Headless
+      class Window
+        attr_reader content_size: Size
+        attr_reader scene: Scene
+        attr_reader device: GPU::_Device
+        attr_reader dispatcher: Input::Dispatcher
+        attr_reader scale_factor: Numeric
+        attr_reader text_runs: Array[text_run]
+        attr_accessor text_system: TextSystem::_System?
+        attr_accessor ime_state: Bounds?
+        attr_accessor title: String
+        def initialize: (?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def on_input: () { (Input::event) -> void } -> void
+        def on_resize: () { (Size) -> void } -> void
+        def on_close: () { () -> (bool | nil) } -> void
+        def on_moved: () { ([Numeric, Numeric]) -> void } -> void
+        def on_tick: () { () -> void } -> void
+        def draw: () { (Window) -> (Element | Scene | nil) } -> void
+        def request_frame: () -> bool
+        def dirty?: () -> bool
+        def closed?: () -> bool
+        def displays: () -> Array[Display]
+        def resize: (Numeric width, Numeric height) -> void
+        def input: (Input::event event) -> void
+        def offer_tooltip: (String text, position: Point, ?delay: Numeric) -> void
+        def context_menu: (menu items, ?position: Point) -> void
+        def close: () -> bool?
+        def tick: () -> void
+        def render: (Element element, ?clear: color, ?present: bool) -> void
+        def element_state: [T] (Object key) { () -> T } -> T
+        def write_png: (String path) -> Integer
+      end
+    end
+    module TUI
+      class InputDecoder
+        attr_reader buffer: String
+        def initialize: () { (Input::event) -> untyped } -> void
+        def feed: (String bytes) -> self
+        def flush_escape: () -> bool
+      end
+      class Window < Headless::Window
+        def initialize: (?input: IO, ?output: IO, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
+        def run: () -> void
+        def feed_input: (String bytes) -> void
+      end
+      class TextRenderer
+        attr_reader runs: Array[[Numeric, Numeric, String?, color, Bounds?]]
+        attr_accessor scale_factor: Numeric?
+        def initialize: () -> void
+        def start_frame: () -> void
+        def end_frame: () -> void
+        def close: () -> void
+        def layout_line: (String text, ?font: TextSystem::_Font?, ?size: Numeric) -> TextSystem::LineLayout
+        def paint_line: (Scene scene, TextSystem::LineLayout line, x: Numeric, y: Numeric, ?color: color, ?spans: TextSystem::spans?) -> void
+      end
+    end
+  end
+end

data/sig/scene.rbs

@@ -0,0 +1,52 @@
+module Zaniah
+  interface _Rectangle
+    def x: () -> Numeric
+    def y: () -> Numeric
+    def width: () -> Numeric
+    def height: () -> Numeric
+  end
+
+  class Scene
+    QUAD_STRIDE: Integer
+    SPRITE_INSTANCE_BYTES: Integer
+    type primitive = :quad | :sprite | :sprite_batch | :triangle
+    class SpriteBatch < Data
+      attr_reader bytes: String
+      attr_reader texture: GPU::Texture
+      def self.new: (String bytes, GPU::Texture texture) -> SpriteBatch
+                  | (bytes: String, texture: GPU::Texture) -> SpriteBatch
+    end
+    attr_reader quads: Array[Numeric]
+    attr_reader sprites: Array[Numeric]
+    attr_reader sprite_batches: Array[SpriteBatch]
+    attr_reader paths: Array[Numeric]
+    attr_reader textures: Array[GPU::Texture]
+    attr_reader commands: Array[primitive | Numeric | Bounds | nil]
+    def initialize: () -> void
+    def clear: () -> self
+    def quad: (Numeric x, Numeric y, Numeric width, Numeric height, color: color, ?radius: radius, ?border_width: Numeric, ?border_color: color) -> self
+    def push_quad: (Numeric x, Numeric y, Numeric width, Numeric height, color bg, radius radius, Numeric border_width, color border_color, ?Numeric order) -> self
+    def sprite: (Numeric x, Numeric y, Numeric width, Numeric height, texture: GPU::Texture, ?color: color, ?source: _Rectangle?) -> self
+    def sprite_batch: (String bytes, texture: GPU::Texture) -> self
+                    | (SpriteBatch batch) -> self
+    def sprite_data: () -> Array[Numeric]
+    def expand_sprite_batch: (Integer index) -> [Integer, Integer]
+    def triangle: ([Numeric, Numeric, Numeric, Numeric, Numeric, Numeric] points, color: color) -> self
+    def shadow: (Numeric x, Numeric y, Numeric width, Numeric height, ?color: color, ?blur: Numeric, ?radius: Numeric) -> self
+    def underline: (Numeric x, Numeric y, Numeric width, color: color, ?thickness: Numeric, ?wave: bool) -> self
+    def clip: [T] (Bounds bounds) { () -> T } -> T
+    def current_clip: () -> Bounds?
+    def layer: [T] (Numeric order) { () -> T } -> T
+    def each_command: () { (primitive, Integer, Bounds?) -> void } -> void
+                    | () -> Enumerator[[primitive, Integer, Bounds?], void]
+  end
+  class QuadPacker
+    attr_reader bytes: String
+    def initialize: () -> void
+    def pack: (Scene scene) -> String
+  end
+  class SceneRenderer
+    def initialize: (GPU::_Device device) -> void
+    def render: (Scene scene, ?clear: color) -> void
+  end
+end

data/sig/shaper.rbs

@@ -0,0 +1,8 @@
+module Zaniah
+  module TextSystem
+    class Shaper
+      def initialize: () -> void
+      def shape: (Array[Glyph] glyphs, size: Numeric, ?text: String?, ?script: String?, ?language: String?) -> Array[Glyph]
+    end
+  end
+end

data/sig/text.rbs

@@ -0,0 +1,137 @@
+module Zaniah
+  module TextSystem
+    type spans = Array[[Integer, Integer, color]]
+    # Structural font contracts keep signatures independent of a separately
+    # installed Alhena gem.
+    interface _Font
+      def units_per_em: () -> Integer
+      def ascent: () -> Integer
+      def descent: () -> Integer
+      def family: () -> String?
+      def glyph_id: (String | Integer character, ?variation_selector: String | Integer | nil) -> Integer
+      def advance: (Integer glyph, ?size: Numeric, ?vertical: bool) -> Float
+      def tables: () -> Hash[String, [Integer, Integer]]
+    end
+    interface _Bitmap
+      def width: () -> Integer
+      def height: () -> Integer
+      def left: () -> Integer
+      def top: () -> Integer
+    end
+    interface _Rasterizer
+      def rasterize: (_Font font, Integer glyph, size: Numeric, ?subpixel_x: Numeric) -> _Bitmap
+    end
+    interface _FontDB
+      def find: (?family: String?, ?weight: Integer, ?width: Integer, ?style: :normal | :italic | :oblique) -> _Font
+      def fallback: (Integer codepoint, _Font primary) -> _Font
+    end
+    interface _Shaper
+      def shape: (Array[Glyph] glyphs, size: Numeric, text: String) -> Array[Glyph]
+    end
+    interface _Segmenter
+      def grapheme_clusters: (String text) -> Array[String]
+    end
+    interface _System
+      def scale_factor=: (Numeric scale) -> Numeric
+      def layout_line: (String text, ?font: _Font?, ?size: Numeric) -> LineLayout
+      def paint_line: (Scene scene, LineLayout line, x: Numeric, y: Numeric, ?color: color, ?spans: spans?) -> void
+      def end_frame: () -> void
+      def close: () -> void
+    end
+    class FontDB
+      class Face < Data
+        attr_reader path: String
+        attr_reader index: Integer
+        attr_reader family: String
+        attr_reader families: Array[String]
+        attr_reader weight: Integer
+        attr_reader width: Integer
+        attr_reader style: :normal | :italic | :oblique
+        attr_reader fixed_pitch: bool
+        attr_reader tables: Hash[String, [Integer, Integer]]
+        def self.new: (String path, Integer index, String family, Array[String] families, Integer weight, Integer width, :normal | :italic | :oblique style, bool fixed_pitch, Hash[String, [Integer, Integer]] tables) -> Face
+                    | (path: String, index: Integer, family: String, families: Array[String], weight: Integer, width: Integer, style: :normal | :italic | :oblique, fixed_pitch: bool, tables: Hash[String, [Integer, Integer]]) -> Face
+      end
+      attr_reader paths: Array[String]
+      def initialize: (?paths: Array[String]?) -> void
+      def open: (String path, ?index: Integer) -> _Font
+      def find: (?family: String?, ?weight: Integer, ?width: Integer, ?style: :normal | :italic | :oblique) -> _Font
+      def faces: () -> Array[Face]
+      def refresh: () -> self
+      def fallback: (Integer codepoint, _Font primary) -> _Font
+    end
+    class Atlas
+      class Entry < Data
+        attr_reader texture: GPU::Texture
+        attr_reader x: Integer
+        attr_reader y: Integer
+        attr_reader width: Integer
+        attr_reader height: Integer
+        attr_reader left: Integer
+        attr_reader top: Integer
+        def self.new: (GPU::Texture texture, Integer x, Integer y, Integer width, Integer height, Integer left, Integer top) -> Entry
+                    | (texture: GPU::Texture, x: Integer, y: Integer, width: Integer, height: Integer, left: Integer, top: Integer) -> Entry
+      end
+      attr_reader generation: Integer
+      attr_reader texture: GPU::Texture
+      def initialize: (?width: Integer, ?height: Integer, ?format: GPU::format) -> void
+      def fetch: (Object key) { () -> _Bitmap } -> Entry
+      def lookup: (Object key) -> Entry?
+      def load_cache: (String path, key: String, ?preserve: bool) -> bool
+      def save_cache: (String path, key: String) -> bool
+      def end_frame: () -> void
+    end
+    class Glyph < Data
+      attr_reader font: _Font
+      attr_reader id: Integer
+      attr_reader start: Integer
+      attr_reader finish: Integer
+      attr_reader x: Numeric
+      attr_reader advance: Numeric
+      def self.new: (_Font font, Integer id, Integer start, Integer finish, Numeric x, Numeric advance) -> Glyph
+                  | (font: _Font, id: Integer, start: Integer, finish: Integer, x: Numeric, advance: Numeric) -> Glyph
+    end
+    class LineLayout < Data
+      attr_reader text: String
+      attr_reader glyphs: Array[Glyph]
+      attr_reader width: Numeric
+      attr_reader ascent: Numeric
+      attr_reader descent: Numeric
+      attr_reader size: Numeric
+      attr_reader carets: Array[[Integer, Numeric]]
+      def self.new: (String text, Array[Glyph] glyphs, Numeric width, Numeric ascent, Numeric descent, Numeric size, Array[[Integer, Numeric]] carets) -> LineLayout
+                  | (text: String, glyphs: Array[Glyph], width: Numeric, ascent: Numeric, descent: Numeric, size: Numeric, carets: Array[[Integer, Numeric]]) -> LineLayout
+      def index_for_x: (Numeric x) -> Integer
+      def x_for_index: (Integer index) -> Numeric
+    end
+    class Typesetter
+      class CopyError < Error
+      end
+      attr_reader font_db: _FontDB
+      attr_reader font: _Font
+      attr_reader shaper: _Shaper
+      attr_reader segmenter: _Segmenter
+      def initialize: (?font: _Font?, ?font_db: :native | _FontDB, ?capacity: Integer, ?shaper: :native | _Shaper, ?segmenter: :native | _Segmenter) -> void
+      def layout_line: (String text, ?font: _Font?, ?size: Numeric) -> LineLayout
+      def fork: (?capacity: Integer) -> Typesetter
+      def close: () -> void
+    end
+    class Renderer < Typesetter
+      MAX_PAINT_BYTES: Integer
+      attr_reader font_db: _FontDB
+      attr_reader shaper: _Shaper
+      attr_reader segmenter: _Segmenter
+      attr_reader atlas: Atlas
+      attr_reader color_atlas: Atlas
+      attr_reader font: _Font
+      attr_reader cache_dir: String?
+      attr_accessor scale_factor: Numeric
+      def initialize: (?font: _Font?, ?font_db: :native | _FontDB, ?capacity: Integer, ?font_raster: :native | :alhena | :core_text | :coretext | :freetype | _Rasterizer, ?shaper: :native | _Shaper, ?segmenter: :native | _Segmenter, ?cache_dir: String?) -> void
+      def layout_line: (String text, ?font: _Font?, ?size: Numeric) -> LineLayout
+      def paint_line: (Scene scene, LineLayout line, x: Numeric, y: Numeric, ?color: color, ?spans: spans?) -> void
+      def end_frame: () -> void
+      def prewarm: (?String text, ?size: Numeric) -> self
+      def close: () -> void
+    end
+  end
+end

data/sig/zaniah.rbs

@@ -0,0 +1,120 @@
+module Zaniah
+  VERSION: String
+  type color = Color | String | [Numeric, Numeric, Numeric] | [Numeric, Numeric, Numeric, Numeric]
+  type dimension = Numeric | Length | :auto
+  type radius = Numeric | [Numeric, Numeric, Numeric, Numeric]
+  type menu = Array[[String, (^( ) -> void)?]]
+
+  class Error < StandardError
+  end
+
+  class Configuration < Struct[Symbol | TextSystem::_Rasterizer | TextSystem::_FontDB | TextSystem::_Shaper | TextSystem::_Segmenter]
+    attr_accessor font_raster: Symbol | TextSystem::_Rasterizer
+    attr_accessor shaper: Symbol | TextSystem::_Shaper
+    attr_accessor font_db: Symbol | TextSystem::_FontDB
+    attr_accessor segmenter: Symbol | TextSystem::_Segmenter
+    def self.new: (?font_raster: Symbol | TextSystem::_Rasterizer, ?shaper: Symbol | TextSystem::_Shaper, ?font_db: Symbol | TextSystem::_FontDB, ?segmenter: Symbol | TextSystem::_Segmenter) -> Configuration
+  end
+  def self.configuration: () -> Configuration
+  def self.configure: [T] () { (Configuration) -> T } -> T
+
+  class Point < Data
+    attr_reader x: Numeric
+    attr_reader y: Numeric
+    def self.new: (Numeric x, Numeric y) -> Point
+                | (x: Numeric, y: Numeric) -> Point
+    def +: (Point other) -> Point
+    def -: (Point other) -> Point
+  end
+  class Size < Data
+    attr_reader width: Numeric
+    attr_reader height: Numeric
+    def self.new: (Numeric width, Numeric height) -> Size
+                | (width: Numeric, height: Numeric) -> Size
+  end
+  class Edges < Data
+    attr_reader top: Numeric
+    attr_reader right: Numeric
+    attr_reader bottom: Numeric
+    attr_reader left: Numeric
+    def self.new: (Numeric top, Numeric right, Numeric bottom, Numeric left) -> Edges
+                | (top: Numeric, right: Numeric, bottom: Numeric, left: Numeric) -> Edges
+    def self.all: (Numeric value) -> Edges
+  end
+  class Corners < Data
+    attr_reader top_left: Numeric
+    attr_reader top_right: Numeric
+    attr_reader bottom_right: Numeric
+    attr_reader bottom_left: Numeric
+    def self.new: (Numeric top_left, Numeric top_right, Numeric bottom_right, Numeric bottom_left) -> Corners
+                | (top_left: Numeric, top_right: Numeric, bottom_right: Numeric, bottom_left: Numeric) -> Corners
+    def self.all: (Numeric value) -> Corners
+  end
+  class Bounds < Data
+    attr_reader x: Numeric
+    attr_reader y: Numeric
+    attr_reader width: Numeric
+    attr_reader height: Numeric
+    def self.new: (Numeric x, Numeric y, Numeric width, Numeric height) -> Bounds
+                | (x: Numeric, y: Numeric, width: Numeric, height: Numeric) -> Bounds
+    def right: () -> Numeric
+    def bottom: () -> Numeric
+    def contains?: (Point point) -> bool
+    def intersect: (Bounds other) -> Bounds
+    def inset: (Numeric | Edges edges) -> Bounds
+  end
+  class Length < Data
+    attr_reader value: Numeric
+    attr_reader unit: :px | :rem | :percent
+    def self.new: (Numeric value, :px | :rem | :percent unit) -> Length
+                | (value: Numeric, unit: :px | :rem | :percent) -> Length
+    def resolve: (Numeric available, ?rem: Numeric) -> Numeric
+  end
+  class DevicePixels < Data
+    attr_reader value: Numeric
+    def self.new: (Numeric value) -> DevicePixels
+                | (value: Numeric) -> DevicePixels
+    def logical: (Numeric scale) -> Numeric
+  end
+  module LengthUnits
+    def px: (Numeric value) -> Length
+    def rems: (Numeric value) -> Length
+    def percent: (Numeric value) -> Length
+  end
+  extend LengthUnits
+
+  class Color < Data
+    attr_reader r: Numeric
+    attr_reader g: Numeric
+    attr_reader b: Numeric
+    attr_reader a: Numeric
+    def self.new: (Numeric r, Numeric g, Numeric b, Numeric a) -> Color
+                | (r: Numeric, g: Numeric, b: Numeric, a: Numeric) -> Color
+    def self.parse: (color value) -> Color
+    def opacity: (Numeric value) -> Color
+    def premultiplied: () -> [Numeric, Numeric, Numeric, Numeric]
+    def to_a: () -> [Numeric, Numeric, Numeric, Numeric]
+    def mix: (color other, Numeric amount) -> Color
+    def to_hsla: () -> HSLA
+  end
+  class HSLA < Data
+    attr_reader h: Numeric
+    attr_reader s: Numeric
+    attr_reader l: Numeric
+    attr_reader a: Numeric
+    def self.new: (Numeric h, Numeric s, Numeric l, Numeric a) -> HSLA
+                | (h: Numeric, s: Numeric, l: Numeric, a: Numeric) -> HSLA
+    def to_rgba: () -> Color
+  end
+
+  module Unicode
+    def self.grapheme_clusters: (String text) -> Array[String]
+    def self.width: (String text, ?ambiguous: 1 | 2) -> Integer
+  end
+  module PNG
+    SIGNATURE: String
+    def self.encode: (Integer width, Integer height, String rgba) -> String
+    def self.decode: (String bytes, ?max_pixels: Integer) -> [Integer, Integer, String]
+    def self.write: (String path, Integer width, Integer height, String rgba) -> Integer
+  end
+end