zaniah 0.1.0

data/lib/zaniah/platform/mac/watcher.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "../../ffi/library"
+require_relative "../file_event"
+
+module Zaniah
+  module Platform
+    module Mac
+      class Watcher
+        P, I, L, D, V = Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_DOUBLE, Fiddle::TYPE_VOID
+        def initialize(paths, latency: 0.05)
+          @cf = FFI::Library.new("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation")
+          @fs = FFI::Library.new("/System/Library/Frameworks/CoreServices.framework/CoreServices")
+          @events, @closed = [], false
+          @thread = Thread.current
+          paths = Array(paths).map { |path| File.expand_path(path) }
+          raise ArgumentError, "watch paths required" if paths.empty?
+          strings = paths.map do |path|
+            @cf.fn(:CFStringCreateWithCString, [P, P, I], P).call(0, path, 0x08000100)
+          end
+          pointers = strings.map(&:to_i).pack("J*")
+          array = @cf.fn(:CFArrayCreate, [P, P, Fiddle::TYPE_LONG, P], P).call(0, pointers, strings.length, @cf.handle["kCFTypeArrayCallBacks"])
+          @callback = Fiddle::Closure::BlockCaller.new(V, [P, P, Fiddle::TYPE_SIZE_T, P, P, P]) do |_stream, _info, count, native_paths, flags, _ids|
+            count.times do |index|
+              address = Fiddle::Pointer.new(native_paths)[index * Fiddle::SIZEOF_VOIDP, Fiddle::SIZEOF_VOIDP].unpack1("J")
+              path = Fiddle::Pointer.new(address).to_s.force_encoding("UTF-8")
+              mask = Fiddle::Pointer.new(flags)[index * 4, 4].unpack1("I")
+              kind = if (mask & 0x7) != 0 then :overflow
+              elsif (mask & 0x200) != 0 then :deleted
+              elsif (mask & 0x100) != 0 then :created
+              else :modified
+              end
+              @events << FileEvent.new(kind, path, nil)
+            end
+          end
+          @stream = @fs.fn(:FSEventStreamCreate, [P, P, P, P, L, D, I], P).call(0, @callback, 0, array, -1, latency, 0x16)
+          raise Error, "FSEventStreamCreate failed" if @stream.null?
+          @loop = @cf.fn(:CFRunLoopGetCurrent, [], P).call
+          @mode = Fiddle::Pointer.new(@cf.handle["kCFRunLoopDefaultMode"])[0, Fiddle::SIZEOF_VOIDP].unpack1("J")
+          @fs.fn(:FSEventStreamScheduleWithRunLoop, [P, P, P], V).call(@stream, @loop, @mode)
+          raise Error, "FSEventStreamStart failed" if @fs.fn(:FSEventStreamStart, [P], Fiddle::TYPE_BOOL).call(@stream) == 0
+        ensure
+          strings&.each { |string| @cf.fn(:CFRelease, [P], V).call(string) }
+          @cf.fn(:CFRelease, [P], V).call(array) if array
+        end
+        def poll(timeout: 0)
+          return [] if @closed
+          raise Error, "FSEvents must be polled on its creating thread" unless Thread.current == @thread
+          @cf.fn(:CFRunLoopRunInMode, [P, D, Fiddle::TYPE_BOOL], I).call(@mode, timeout, 1)
+          events, @events = @events, []
+          events
+        end
+        def close
+          return if @closed
+          @closed = true
+          @fs.fn(:FSEventStreamStop, [P], V).call(@stream)
+          @fs.fn(:FSEventStreamInvalidate, [P], V).call(@stream)
+          @fs.fn(:FSEventStreamRelease, [P], V).call(@stream)
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/mac/window.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    module Mac
+      class Window < Headless::Window
+        def displays = Mac.displays
+        attr_reader :handle, :view, :layer
+
+        def initialize(gpu: :metal, **options)
+          super(**options)
+          App.instance
+          self.class.install_classes
+          @handle = O.send(O.alloc("NSWindow"), "initWithContentRect:styleMask:backing:defer:",
+                           [0, 0, content_size.width, content_size.height], 15, 2, 0,
+                           args: [:rect, :ulong, :ulong, :bool])
+          raise Error, "NSWindow creation failed" if @handle.zero?
+          O.send(@handle, "setReleasedWhenClosed:", 0, args: [:bool], result: :void)
+          @view = O.send(O.alloc("ZaniahNativeView"), "initWithFrame:", [0, 0, content_size.width, content_size.height], args: [:rect])
+          @delegate = O.new("ZaniahWindowDelegate")
+          WINDOWS[@handle] = WINDOWS[@view] = WINDOWS[@delegate] = self
+          O.send(@view, "setAutoresizingMask:", 18, args: [:ulong], result: :void)
+          O.send(@handle, "setContentView:", @view, args: [:pointer], result: :void)
+          O.send(@handle, "setDelegate:", @delegate, args: [:pointer], result: :void)
+          O.send(@handle, "setAcceptsMouseMovedEvents:", 1, args: [:bool], result: :void)
+          O.send(@handle, "makeFirstResponder:", @view, args: [:pointer], result: :bool)
+          types = [O.string("NSFilenamesPboardType"), O.string("public.file-url")].pack("J2")
+          list = O.send(O.klass("NSArray"), "arrayWithObjects:count:", Fiddle::Pointer[types], 2, args: [:pointer, :ulong])
+          O.send(@view, "registerForDraggedTypes:", list, args: [:pointer], result: :void)
+          self.title = @title
+          O.send(@handle, "center", result: :void)
+          @scale_factor = O.send(@handle, "backingScaleFactor", result: :double)
+          @device.release
+          @device = create_device(gpu)
+          O.send(@handle, "makeKeyAndOrderFront:", 0, args: [:pointer], result: :void)
+        end
+
+        def self.install_classes
+          O.subclass("ZaniahNativeView", "NSView", protocols: ["NSTextInputClient"]) do |klass|
+            O.method(klass, "acceptsFirstResponder", result: :bool, encoding: "B@:") { 1 }
+            O.method(klass, "isFlipped", result: :bool, encoding: "B@:") { 1 }
+            O.method(klass, "viewDidChangeEffectiveAppearance", encoding: "v@:") do |receiver, _|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].appearance_changed }
+            end
+            %w[draggingEntered: draggingUpdated:].each do |name|
+              O.method(klass, name, args: [:pointer], result: :ulong, encoding: "Q@:@") { 1 }
+            end
+            O.method(klass, "performDragOperation:", args: [:pointer], result: :bool, encoding: "B@:@") do |receiver, _, dragging|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].file_drop(dragging) } ? 1 : 0
+            end
+            %w[keyDown: keyUp: flagsChanged: mouseDown: mouseUp: rightMouseDown: rightMouseUp: otherMouseDown: otherMouseUp: mouseMoved: mouseDragged: rightMouseDragged: otherMouseDragged: scrollWheel:].each do |name|
+              O.method(klass, name, args: [:pointer], encoding: "v@:@") do |receiver, _, event|
+                WINDOWS[receiver]&.native_callback { WINDOWS[receiver].native_input(name, event) }
+              end
+            end
+            O.method(klass, "insertText:replacementRange:", args: [:pointer, :range], encoding: "v@:@{_NSRange=QQ}") do |receiver, _, value, _range|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].commit_text(value) }
+            end
+            O.method(klass, "setMarkedText:selectedRange:replacementRange:", args: [:pointer, :range, :range], encoding: "v@:@{_NSRange=QQ}{_NSRange=QQ}") do |receiver, _, value, selection, _replacement|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].marked_text(value, selection) }
+            end
+            O.method(klass, "unmarkText", encoding: "v@:") { |receiver, _| WINDOWS[receiver]&.marked_text(0, [0, 0]) }
+            O.method(klass, "hasMarkedText", result: :bool, encoding: "B@:") { |receiver, _| WINDOWS[receiver]&.composing? ? 1 : 0 }
+            O.method(klass, "markedRange", result: :range, encoding: "{_NSRange=QQ}@:") { |receiver, _| WINDOWS[receiver]&.marked_range || [NS_NOT_FOUND, 0] }
+            O.method(klass, "selectedRange", result: :range, encoding: "{_NSRange=QQ}@:") { |receiver, _| WINDOWS[receiver]&.selected_range || [0, 0] }
+            O.method(klass, "validAttributesForMarkedText", result: :pointer, encoding: "@@:") { O.send(O.klass("NSArray"), "array") }
+            O.method(klass, "attributedSubstringForProposedRange:actualRange:", args: [:range, :pointer], result: :pointer, encoding: "@@:{_NSRange=QQ}^{_NSRange=QQ}") { 0 }
+            O.method(klass, "characterIndexForPoint:", args: [:point], result: :ulong, encoding: "Q@:{CGPoint=dd}") { 0 }
+            O.method(klass, "firstRectForCharacterRange:actualRange:", args: [:range, :pointer], result: :rect, encoding: "{CGRect={CGPoint=dd}{CGSize=dd}}@:{_NSRange=QQ}^{_NSRange=QQ}") do |receiver, _, range, actual|
+              Fiddle::Pointer.new(actual)[0, 16] = range.pack("Q2") unless actual.zero?
+              WINDOWS[receiver]&.candidate_rect || [0, 0, 0, 0]
+            end
+            O.method(klass, "doCommandBySelector:", args: [:pointer], encoding: "v@::") { nil }
+          end
+          O.subclass("ZaniahWindowDelegate", "NSObject", protocols: ["NSWindowDelegate"]) do |klass|
+            O.method(klass, "contextMenuAction:", args: [:pointer], encoding: "v@:@") do |receiver, _, item|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].context_action(O.send(item, "tag", result: :long)) }
+            end
+            %w[windowDidResize: windowDidChangeBackingProperties: windowDidMove:].each do |name|
+              O.method(klass, name, args: [:pointer], encoding: "v@:@") do |receiver, _, _notification|
+                WINDOWS[receiver]&.native_callback { WINDOWS[receiver].native_resize(moved: name == "windowDidMove:") }
+              end
+            end
+            O.method(klass, "windowShouldClose:", args: [:pointer], result: :bool, encoding: "B@:@") do |receiver, _, _window|
+              WINDOWS[receiver]&.native_callback { WINDOWS[receiver].close }
+              0
+            end
+          end
+        end
+
+        def create_device(backend)
+          case backend
+          when :metal
+            require_relative "../../gpu/metal"
+            @layer ||= O.new("CAMetalLayer")
+            O.send(@view, "setWantsLayer:", 1, args: [:bool], result: :void)
+            O.send(@view, "setLayer:", @layer, args: [:pointer], result: :void)
+            GPU::Metal.new(self)
+          when :opengl, :gl
+            require_relative "../../gpu/open_gl"
+            O.send(@view, "setWantsBestResolutionOpenGLSurface:", 1, args: [:bool], result: :void)
+            attributes = [99, 0x4100, 5, 8, 24, 11, 8, 0].pack("I*")
+            format = O.send(O.alloc("NSOpenGLPixelFormat"), "initWithAttributes:", Fiddle::Pointer[attributes], args: [:pointer])
+            raise Error, "OpenGL 4.1 core pixel format unavailable" if format.zero?
+            @gl_context = O.send(O.alloc("NSOpenGLContext"), "initWithFormat:shareContext:", format, 0, args: [:pointer, :pointer])
+            O.release(format)
+            O.send(@gl_context, "setView:", @view, args: [:pointer], result: :void)
+            interval = [1].pack("i")
+            O.send(@gl_context, "setValues:forParameter:", Fiddle::Pointer[interval], 222, args: [:pointer, :int], result: :void)
+            GPU::OpenGL.new(self, library: FFI::Library.new("/System/Library/Frameworks/OpenGL.framework/OpenGL"))
+          else raise ArgumentError, "unsupported Cocoa GPU backend #{backend}"
+          end
+        end
+        def make_current = O.send(@gl_context, "makeCurrentContext", result: :void)
+        def swap_buffers = O.send(@gl_context, "flushBuffer", result: :void)
+        def title=(title)
+          super
+          O.send(@handle, "setTitle:", O.string(title), args: [:pointer], result: :void) if @handle
+        end
+        def tick(poll_events: true)
+          App.instance.poll if poll_events
+          raise @native_error if @native_error
+          super()
+        end
+        def run
+          until closed?
+            App.instance.poll(wait: dirty? ? 0 : 0.05)
+            tick(poll_events: false)
+          end
+        end
+        def close
+          return false unless super
+          WINDOWS.delete_if { |_, window| window.equal?(self) }
+          O.send(@handle, "setDelegate:", 0, args: [:pointer], result: :void)
+          O.send(@handle, "close", result: :void)
+          [@gl_context, @layer, @delegate, @view, @handle].compact.each { |object| O.release(object) }
+          true
+        end
+        def native_callback
+          yield
+        rescue StandardError => error
+          @native_error = error
+        end
+        def native_resize(moved: false)
+          return if closed?
+          bounds = O.send(@view, "bounds", result: :rect)
+          @scale_factor = O.send(@handle, "backingScaleFactor", result: :double)
+          resize(bounds[2], bounds[3]) if bounds[2].positive? && bounds[3].positive?
+          O.send(@gl_context, "update", result: :void) if @gl_context
+          @on_moved&.call(O.send(@handle, "frame", result: :rect).first(2)) if moved
+        end
+        def toggle_fullscreen = O.send(@handle, "toggleFullScreen:", 0, args: [:pointer], result: :void)
+
+        KEYS = {36 => "enter", 48 => "tab", 49 => "space", 51 => "backspace", 53 => "esc", 117 => "delete", 115 => "home", 119 => "end", 116 => "pageup", 121 => "pagedown", 123 => "left", 124 => "right", 125 => "down", 126 => "up"}.freeze
+        def native_input(name, event)
+          flags = O.send(event, "modifierFlags", result: :ulong)
+          modifiers = [[18, "ctrl"], [19, "alt"], [17, "shift"], [20, "cmd"]].filter_map { |bit, key| key unless (flags & (1 << bit)).zero? }
+          if name.start_with?("key")
+            code = O.send(event, "keyCode", result: :uint)
+            character = O.text(O.send(event, "charactersIgnoringModifiers")).downcase
+            key = KEYS.fetch(code, character)
+            unless key.empty? || (name == "keyDown:" && composing? && (modifiers & %w[cmd ctrl]).empty?)
+              stroke = (modifiers + [key]).join("-")
+              input(name == "keyDown:" ? Input::KeyDown.new(stroke, O.send(event, "isARepeat", result: :bool) != 0) : Input::KeyUp.new(stroke))
+            end
+            if name == "keyDown:" && (modifiers & %w[cmd ctrl]).empty?
+              context = O.send(@view, "inputContext")
+              O.send(context, "handleEvent:", event, args: [:pointer], result: :bool)
+            end
+          elsif name != "flagsChanged:"
+            x, y = O.send(event, "locationInWindow", result: :point)
+            position = Point.new(x, content_size.height - y)
+            button = [:left, :right, :middle].fetch(O.send(event, "buttonNumber", result: :long), :other)
+            input(case name
+            when /Down:/ then Input::MouseDown.new(position, button, modifiers, O.send(event, "clickCount", result: :long))
+            when /Up:/ then Input::MouseUp.new(position, button, modifiers)
+            when "scrollWheel:"
+              Input::ScrollWheel.new(position, Point.new(-O.send(event, "scrollingDeltaX", result: :double), -O.send(event, "scrollingDeltaY", result: :double)), O.send(event, "phase", result: :ulong), modifiers)
+            else Input::MouseMove.new(position, modifiers)
+            end)
+          end
+        end
+
+        def cocoa_text(value)
+          value = O.send(value, "string") if O.send(value, "isKindOfClass:", O.klass("NSAttributedString"), args: [:pointer], result: :bool) != 0
+          O.text(value)
+        end
+        def commit_text(value)
+          text = cocoa_text(value)
+          @marked, @marked_selection = "", [0, 0]
+          input(Input::Composition.new("", [0, 0]))
+          input(Input::TextInput.new(text)) unless text.empty?
+        end
+        def marked_text(value, selection)
+          @marked, @marked_selection = cocoa_text(value), selection
+          input(Input::Composition.new(@marked, selection))
+        end
+        def composing? = @marked && !@marked.empty?
+        def marked_range = composing? ? [0, @marked.encode("UTF-16LE").bytesize / 2] : [NS_NOT_FOUND, 0]
+        def selected_range = @marked_selection || [0, 0]
+        def candidate_rect
+          bounds = @ime_state.respond_to?(:bounds) ? @ime_state.bounds : @ime_state
+          bounds = Bounds.new(0, 0, 1, 20) unless bounds.is_a?(Bounds)
+          O.send(@handle, "convertRectToScreen:", [bounds.x, content_size.height - bounds.bottom, bounds.width, bounds.height], args: [:rect], result: :rect)
+        end
+        def ime_state=(value)
+          @ime_state = value
+          O.send(O.send(@view, "inputContext"), "invalidateCharacterCoordinates", result: :void) if @view
+        end
+        def clipboard
+          board = O.send(O.klass("NSPasteboard"), "generalPasteboard")
+          O.text(O.send(board, "stringForType:", O.string("public.utf8-plain-text"), args: [:pointer]))
+        end
+        def clipboard=(text)
+          board = O.send(O.klass("NSPasteboard"), "generalPasteboard")
+          O.send(board, "clearContents", result: :long)
+          O.send(board, "setString:forType:", O.string(text), O.string("public.utf8-plain-text"), args: [:pointer, :pointer], result: :bool)
+        end
+        def clipboard_paths
+          board = O.send(O.klass("NSPasteboard"), "generalPasteboard")
+          pasteboard_paths(board)
+        end
+        def pasteboard_paths(board)
+          list = O.send(board, "propertyListForType:", O.string("NSFilenamesPboardType"), args: [:pointer])
+          paths = Array.new(O.send(list, "count", result: :ulong)) { |i| O.text(O.send(list, "objectAtIndex:", i, args: [:ulong])) }
+          return paths unless paths.empty?
+          items = O.send(board, "pasteboardItems")
+          Array.new(O.send(items, "count", result: :ulong)) do |i|
+            item = O.send(items, "objectAtIndex:", i, args: [:ulong])
+            value = O.send(item, "stringForType:", O.string("public.file-url"), args: [:pointer])
+            next if value.zero?
+            url = O.send(O.klass("NSURL"), "URLWithString:", value, args: [:pointer])
+            O.text(O.send(url, "path")) if O.send(url, "isFileURL", result: :bool) != 0
+          end.compact
+        end
+        def file_drop(dragging)
+          paths = pasteboard_paths(O.send(dragging, "draggingPasteboard"))
+          return false if paths.empty?
+          x, y = O.send(dragging, "draggingLocation", result: :point)
+          input(Input::FileDrop.new(paths.freeze, Point.new(x, content_size.height - y)))
+          true
+        end
+        def appearance
+          name = O.text(O.send(O.send(@view, "effectiveAppearance"), "name"))
+          name.include?("Dark") ? :dark : :light
+        end
+        def on_appearance(&block) = @on_appearance = block
+        def appearance_changed
+          @on_appearance&.call(appearance)
+          request_frame
+        end
+        def tooltip=(text)
+          O.send(@view, "setToolTip:", O.string(text), args: [:pointer], result: :void)
+        end
+        def context_action(index) = @context_actions&.fetch(index)&.call
+        def context_menu(items, position: Point.new(0, 0))
+          menu = O.new("NSMenu")
+          O.send(menu, "setAutoenablesItems:", 0, args: [:bool], result: :void)
+          @context_actions = []
+          items.each do |label, action|
+            item = O.send(O.alloc("NSMenuItem"), "initWithTitle:action:keyEquivalent:", O.string(label), O.selector("contextMenuAction:"), O.string(""), args: [:pointer] * 3)
+            O.send(item, "setTarget:", @delegate, args: [:pointer], result: :void)
+            O.send(item, "setTag:", @context_actions.length, args: [:long], result: :void)
+            O.send(item, "setEnabled:", action ? 1 : 0, args: [:bool], result: :void)
+            O.send(menu, "addItem:", item, args: [:pointer], result: :void)
+            @context_actions << action
+            O.release(item)
+          end
+          O.send(menu, "popUpMenuPositioningItem:atLocation:inView:", 0, [position.x, position.y], @view, args: [:pointer, :point, :pointer], result: :bool)
+        ensure
+          @context_actions = nil
+          O.release(menu) if menu
+        end
+        def prompt_for_paths(multiple: false, directories: false, save: false)
+          panel = O.send(O.klass(save ? "NSSavePanel" : "NSOpenPanel"), save ? "savePanel" : "openPanel")
+          unless save
+            O.send(panel, "setAllowsMultipleSelection:", multiple ? 1 : 0, args: [:bool], result: :void)
+            O.send(panel, "setCanChooseDirectories:", directories ? 1 : 0, args: [:bool], result: :void)
+          end
+          return [] unless O.send(panel, "runModal", result: :long) == 1
+          urls = save ? [O.send(panel, "URL")] : begin
+            list = O.send(panel, "URLs")
+            Array.new(O.send(list, "count", result: :ulong)) { |i| O.send(list, "objectAtIndex:", i, args: [:ulong]) }
+          end
+          urls.map { |url| O.text(O.send(url, "path")) }
+        end
+        def cursor_style=(style)
+          selector = {arrow: "arrowCursor", text: "IBeamCursor", pointer: "pointingHandCursor", crosshair: "crosshairCursor", resize_horizontal: "resizeLeftRightCursor", resize_vertical: "resizeUpDownCursor"}.fetch(style)
+          O.send(O.send(O.klass("NSCursor"), selector), "set", result: :void)
+        end
+        def open_url(url)
+          object = O.send(O.klass("NSURL"), "URLWithString:", O.string(url), args: [:pointer])
+          O.send(O.send(O.klass("NSWorkspace"), "sharedWorkspace"), "openURL:", object, args: [:pointer], result: :bool) != 0
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/mac.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../ffi/objc"
+
+module Zaniah
+  module Platform
+    module Mac
+      O = FFI::ObjC
+      APPKIT = FFI::Library.new("/System/Library/Frameworks/AppKit.framework/AppKit")
+      QUARTZ = FFI::Library.new("/System/Library/Frameworks/QuartzCore.framework/QuartzCore")
+      WINDOWS = {}
+      NS_NOT_FOUND = (1 << 63) - 1
+    end
+  end
+end
+
+require_relative "mac/displays"
+require_relative "mac/app"
+require_relative "mac/window"

data/lib/zaniah/platform/tui/input_decoder.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    module TUI
+      # Decode terminal input bytes, never executable terminal output strings.
+      class InputDecoder
+        KEYS = {"A" => "up", "B" => "down", "C" => "right", "D" => "left", "H" => "home", "F" => "end",
+                "P" => "f1", "Q" => "f2", "R" => "f3", "S" => "f4", "Z" => "tab"}.freeze
+        TILDE_KEYS = {1 => "home", 2 => "insert", 3 => "delete", 4 => "end", 5 => "pageup", 6 => "pagedown", 7 => "home", 8 => "end",
+                      11 => "f1", 12 => "f2", 13 => "f3", 14 => "f4", 15 => "f5", 17 => "f6", 18 => "f7", 19 => "f8", 20 => "f9", 21 => "f10", 23 => "f11", 24 => "f12"}.freeze
+        attr_reader :buffer
+
+        def initialize(&emit)
+          @buffer, @emit = +"".b, emit
+        end
+
+        def feed(bytes)
+          @buffer << bytes.b
+          loop do
+            break if @buffer.empty?
+            if @buffer.start_with?("\e[200~")
+              ending = @buffer.index("\e[201~", @paste_scan || 6)
+              raise Error, "terminal paste exceeds 16 MiB" if @buffer.bytesize > 16_777_216
+              unless ending
+                @paste_scan = [@buffer.bytesize - 5, 6].max
+                break
+              end
+              @paste_scan = nil
+              value = @buffer.byteslice(6, ending - 6).force_encoding("UTF-8").scrub
+              @buffer.slice!(0, ending + 6)
+              @emit.call(Input::TextInput.new(value))
+            elsif @buffer.start_with?("\e[", "\eO")
+              sequence = @buffer.match(/\A\e[\[O]([\x30-\x3f]*)([\x20-\x2f]*)([\x40-\x7e])/n)
+              raise Error, "terminal control sequence exceeds 1024 bytes" if !sequence && @buffer.bytesize > 1024
+              break unless sequence
+              if sequence[0] == "\e[M"
+                break if @buffer.bytesize < 6
+                button, x, y = @buffer.byteslice(3, 3).bytes.map { |value| value - 32 }
+                @buffer.slice!(0, 6)
+                mouse(button, x, y, (button & 3) == 3 ? "m" : "M")
+              else
+                @buffer.slice!(0, sequence[0].bytesize)
+                control(sequence[1], sequence[2], sequence[3])
+              end
+            elsif @buffer.start_with?("\e]", "\eP", "\e_", "\e^")
+              ending = @buffer.match(/(?:\a|\e\\)/n)
+              raise Error, "terminal control string exceeds 64 KiB" if !ending && @buffer.bytesize > 65_536
+              break unless ending
+              @buffer.slice!(0, ending.end(0))
+            else
+              alt = @buffer.getbyte(0) == 27
+              break if alt && @buffer.bytesize == 1
+              start = alt ? 1 : 0
+              byte = @buffer.getbyte(start)
+              length = byte.between?(0xc2, 0xdf) ? 2 : byte.between?(0xe0, 0xef) ? 3 : byte.between?(0xf0, 0xf4) ? 4 : 1
+              break if @buffer.bytesize < start + length
+              value = @buffer.byteslice(start, length).force_encoding("UTF-8").scrub
+              @buffer.slice!(0, start + length)
+              character(value, alt ? ["alt"] : [])
+            end
+          end
+          self
+        end
+
+        def flush_escape
+          return false unless @buffer == "\e".b
+          @buffer.clear
+          key("esc")
+          true
+        end
+
+        private
+
+        def character(value, modifiers = [], held: false, released: false)
+          byte = value.length == 1 ? value.ord : nil
+          name = {0 => "ctrl-space", 8 => "backspace", 9 => "tab", 10 => "enter", 13 => "enter", 27 => "esc", 127 => "backspace"}[byte]
+          name ||= "ctrl-#{(96 + byte).chr}" if byte && byte.between?(1, 26)
+          name ||= {28 => "ctrl-\\", 29 => "ctrl-]", 30 => "ctrl-^", 31 => "ctrl-_"}[byte]
+          if name || !modifiers.empty? || released
+            key(name || value, modifiers, held: held, released: released)
+          else
+            @emit.call(Input::TextInput.new(value))
+          end
+        end
+
+        def key(name, modifiers = [], held: false, released: false)
+          stroke = (modifiers + [name]).join("-")
+          stroke = Input::Keystroke.normalize(stroke) unless name == "-"
+          @emit.call(released ? Input::KeyUp.new(stroke) : Input::KeyDown.new(stroke, held))
+        end
+
+        def modifiers(number)
+          flags = [number - 1, 0].max
+          [[4, "ctrl"], [2, "alt"], [1, "shift"], [8, "cmd"]].filter_map { |mask, name| name unless (flags & mask).zero? }
+        end
+
+        def control(parameters, intermediate, final)
+          return unless intermediate.empty?
+          if parameters.start_with?("<") && ["M", "m"].include?(final)
+            numbers = parameters.delete_prefix("<").split(";")
+            mouse(*numbers.map(&:to_i), final) if numbers.length == 3 && numbers.all? { |value| value.match?(/\A\d+\z/) }
+            return
+          end
+          return unless parameters.match?(/\A[\d;:]*\z/)
+          values = parameters.split(";")
+          modifier, event = values.fetch(1, "1").split(":").map(&:to_i)
+          mods = modifiers(modifier)
+          if final == "u"
+            codepoint = values.first.to_i
+            return unless codepoint.between?(0, 0x10ffff) && !codepoint.between?(0xd800, 0xdfff)
+            character(codepoint.chr("UTF-8"), mods, held: event == 2, released: event == 3)
+          elsif final == "~" && values[0].to_i == 27 && values[2]
+            codepoint = values[2].to_i
+            character(codepoint.chr("UTF-8"), mods) if codepoint.between?(0, 0x10ffff) && !codepoint.between?(0xd800, 0xdfff)
+          elsif (name = final == "~" ? TILDE_KEYS[values[0].to_i] : KEYS[final])
+            mods |= ["shift"] if final == "Z"
+            key(name, mods)
+          end
+        end
+
+        def mouse(code, x, y, final)
+          return unless code.between?(0, 255) && x.between?(1, 1_000_000) && y.between?(1, 1_000_000)
+          position = Point.new((x - 0.5) * 8, (y - 0.5) * 20)
+          mods = [[16, "ctrl"], [8, "alt"], [4, "shift"]].filter_map { |mask, name| name unless (code & mask).zero? }
+          button = {0 => :left, 1 => :middle, 2 => :right}.fetch(code & 3, @pressed_button || :other)
+          if (code & 64) != 0
+            delta = [Point.new(0, -40), Point.new(0, 40), Point.new(-40, 0), Point.new(40, 0)][code & 3]
+            @emit.call(Input::ScrollWheel.new(position, delta, :changed, mods))
+          elsif final == "m"
+            @emit.call(Input::MouseUp.new(position, button, mods))
+            @pressed_button = nil
+          elsif (code & 32) != 0
+            @emit.call(Input::MouseMove.new(position, mods))
+          else
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            clicks = @last_click && @last_click[0] == button && @last_click[1] == position && now - @last_click[2] < 0.4 ? 2 : 1
+            @pressed_button, @last_click = button, [button, position, now]
+            @emit.call(Input::MouseDown.new(position, button, mods, clicks))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/tui/text_renderer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Platform
+    module TUI
+      # Terminal cells have fixed metrics; no font loading or rasterization.
+      class TextRenderer
+        attr_reader :runs
+        attr_accessor :scale_factor
+        def initialize
+          @cache, @runs = {}, []
+        end
+        def start_frame = @runs.clear
+        def end_frame; end
+        def close; end
+        def layout_line(text, font: nil, size: 14)
+          @cache.shift if @cache.length >= 2000
+          @cache[text] ||= begin
+            value, byte, width, carets = text.dup.freeze, 0, 0.0, [[0, 0.0]]
+            value.each_grapheme_cluster do |character|
+              byte += character.bytesize
+              width += Unicode.width(character) * 8
+              carets << [byte, width]
+            end
+            TextSystem::LineLayout.new(value, [].freeze, width, 14, 6, size, carets.freeze)
+          end
+        end
+        def paint_line(scene, line, x:, y:, color: "#ddd", spans: nil)
+          cursor = 0
+          spans.to_a.each do |first, last, tint|
+            @runs << [x + line.x_for_index(cursor), y - line.ascent, line.text.byteslice(cursor...first), color, scene.current_clip] if first > cursor
+            @runs << [x + line.x_for_index(first), y - line.ascent, line.text.byteslice(first...last), tint, scene.current_clip]
+            cursor = last
+          end
+          @runs << [x + line.x_for_index(cursor), y - line.ascent, line.text.byteslice(cursor..), color, scene.current_clip] if cursor < line.text.bytesize
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/platform/tui/window.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "text_renderer"
+require_relative "input_decoder"
+
+module Zaniah
+  module Platform
+    module TUI
+      class Window < Headless::Window
+        def initialize(input: $stdin, output: $stdout, **options)
+          @input, @output = input, output
+          super(**options)
+          @text_system = TextRenderer.new
+          @input_decoder = InputDecoder.new { |event| self.input(event) }
+        end
+
+        def run
+          require "io/console"
+          raise Error, "TUI requires a terminal" unless @input.tty? && @output.tty?
+          begin
+            @output.write("\e[?1049h\e[?25l\e[?2004h\e[?1002h\e[?1006h")
+            @output.flush
+            @input.raw do
+              until closed?
+                tick
+                if IO.select([@input], nil, nil, 0.05)
+                  data = @input.readpartial(4096)
+                  feed_input(data)
+                else
+                  @input_decoder.flush_escape
+                end
+              end
+            end
+          ensure
+            @output.write("\e[?1006l\e[?1002l\e[?2004l\e[?25h\e[?1049l")
+            @output.flush
+          end
+        end
+
+        def feed_input(bytes) = @input_decoder.feed(bytes)
+
+        def render(element, **options)
+          super(element, **options, present: false)
+          rows = Array.new((content_size.height / 20).ceil) { Array.new((content_size.width / 8).ceil, " ") }
+          colors = Array.new(rows.length) { Array.new(rows.first.length) }
+          (@text_system.runs.empty? ? @text_runs : @text_system.runs).each do |x, y, text, color, clip|
+            row, col = (y / 20).floor, (x / 8).floor
+            next if row.negative? || !rows[row] || !text
+            next if clip && (y < clip.y || y >= clip.bottom)
+            first = clip ? [0, (clip.x / 8.0).ceil].max : 0
+            last = clip ? [rows[row].length, (clip.right / 8).floor].min : rows[row].length
+            text.each_grapheme_cluster do |char|
+              break if col >= rows[row].length
+              char = char.gsub(/[\x00-\x1f\x7f]/) { |control| control == "\x7f" ? "␡" : (0x2400 + control.ord).chr(Encoding::UTF_8) }
+              width = Unicode.width(char)
+              next if width.zero?
+              break if col + width > last
+              if col < first
+                col += width
+                next
+              end
+              rows[row][col - 1] = " " if col.positive? && rows[row][col].empty?
+              rows[row][col + 1] = " " if rows[row][col + 1] == ""
+              rows[row][col] = char if col >= 0
+              colors[row][col] = color
+              (1...width).each { |offset| rows[row][col + offset] = "" if col + offset >= 0 }
+              col += width
+            end
+          end
+          palette = {}
+          lines = rows.each_with_index.map do |cells, row|
+            current, line = nil, +""
+            cells.each_with_index do |char, col|
+              next if char.empty?
+              color = colors[row][col] || "#ddd"
+              if color != current
+                line << (palette[color] ||= "\e[38;2;#{Color.parse(color).to_a.first(3).map { |value| (value * 255).round }.join(';')}m")
+                current = color
+              end
+              line << char
+            end
+            line
+          end
+          @output.write("\e[H" + lines.join("\r\n") + "\e[0m")
+          @output.write("\e[#{(@ime_state.y / 20).floor + 1};#{(@ime_state.x / 8).floor + 1}H\e[?25h") if @ime_state && @output.tty?
+          @output.flush
+        end
+      end
+    end
+  end
+end