zaniah 0.1.0

data/examples/linux_smoke.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "rbconfig"
+
+Dir.mktmpdir("zaniah-linux-") do |directory|
+  log = File.open(File.join(directory, "display.log"), "w")
+  ENV["LIBGL_ALWAYS_SOFTWARE"] = "1"
+  wayland = ARGV.include?("--wayland")
+  if wayland
+    ENV["XDG_RUNTIME_DIR"] = directory
+    ENV["WAYLAND_DISPLAY"] = "wayland-zaniah"
+    ENV.delete("DISPLAY")
+    pid = Process.spawn("weston", "--backend=headless-backend.so", "--renderer=gl", "--socket=wayland-zaniah", "--idle-time=0", out: log, err: log)
+    socket = File.join(directory, "wayland-zaniah")
+  else
+    ENV["ZANIAH_CHECK_INPUT"] = "1"
+    ENV["ZANIAH_CHECK_DPI"] = "1"
+    ENV.delete("WAYLAND_DISPLAY")
+    number = 90 + Process.pid % 100
+    ENV["DISPLAY"] = ":#{number}"
+    pid = Process.spawn("Xvfb", ENV["DISPLAY"], "-screen", "0", "1280x800x24", "+extension", "GLX", out: log, err: log)
+    socket = "/tmp/.X11-unix/X#{number}"
+  end
+  begin
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 10
+    until File.socket?(socket)
+      raise File.read(log.path) if Process.waitpid(pid, Process::WNOHANG)
+      raise "display startup timeout: #{File.read(log.path)}" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+      sleep 0.05
+    end
+    if ARGV.include?("--ibus")
+      raise "IBus check requires dbus-run-session and X11" if wayland || !ENV["DBUS_SESSION_BUS_ADDRESS"]
+      ENV["XMODIFIERS"] = "@im=ibus"
+      ENV["LANG"] = "C.UTF-8"
+      system("ibus-daemon", "--daemonize", "--xim", "--panel=disable") or raise "IBus startup failed"
+      sleep 1
+      raise "native Japanese IME failed" unless system(RbConfig.ruby, File.join(__dir__, "native_ime.rb"))
+      ENV["XMODIFIERS"] = "@im=none"
+    end
+    success = system(RbConfig.ruby, File.join(__dir__, "native_smoke.rb"), "--gl", "--check")
+    raise "native rendering failed\n#{File.read(log.path)}" unless success
+    raise "native XDND transfer failed" unless wayland || system(RbConfig.ruby, File.join(__dir__, "native_drop.rb"))
+    raise "native watcher failed" unless system(RbConfig.ruby, File.join(__dir__, "native_watch.rb"))
+    if ARGV.include?("--editor")
+      raise "native editor integration failed" unless system(RbConfig.ruby, "--yjit", File.expand_path("../../canopus/tools/native_check.rb", __dir__), "--idle")
+    end
+  ensure
+    Process.kill("TERM", pid) rescue Errno::ESRCH
+    Process.wait(pid) rescue Errno::ECHILD
+    log.close
+  end
+end

data/examples/mac_event_check.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+abort "Cocoa requires macOS" unless RUBY_PLATFORM.include?("darwin")
+
+window = Zaniah::Platform.open_window(backend: :mac, width: 320, height: 200, title: "Cocoa input and resize check")
+objc = Zaniah::FFI::ObjC
+app = Zaniah::Platform::Mac::App.instance
+events = []
+window.on_input { |event| events << event }
+window.tick
+
+# Exercise the actual NSTextInputClient callbacks without changing the user's
+# selected keyboard input source. Interactive IME conversion remains separate.
+window.ime_state = Zaniah::Bounds.new(20, 30, 1, 18)
+objc.send(window.view, "setMarkedText:selectedRange:replacementRange:", objc.string("にほん"),
+  [3, 0], [Zaniah::Platform::Mac::NS_NOT_FOUND, 0], args: [:pointer, :range, :range], result: :void)
+raise "preedit callback missing" unless events.last.is_a?(Zaniah::Input::Composition) && events.last.text == "にほん"
+candidate = -> { objc.send(window.view, "firstRectForCharacterRange:actualRange:", [0, 1], 0, args: [:range, :pointer], result: :rect) }
+before = candidate.call
+frame = objc.send(window.handle, "frame", result: :rect)
+objc.send(window.handle, "setFrameOrigin:", [frame[0] + 25, frame[1] + 30], args: [:point], result: :void)
+window.tick
+moved = candidate.call
+raise "IME candidate did not follow window move" unless (moved[0] - before[0] - 25).abs < 0.01 && (moved[1] - before[1] - 30).abs < 0.01
+frame = objc.send(window.handle, "frame", result: :rect)
+objc.send(window.handle, "setContentSize:", [400, 260], args: [:size], result: :void)
+window.tick
+raise "native resize was not delivered" unless window.content_size == Zaniah::Size.new(400, 260)
+after_frame = objc.send(window.handle, "frame", result: :rect)
+resized = candidate.call
+raise "IME candidate did not follow resize" unless (resized[1] - moved[1] - (after_frame[1] - frame[1]) - 60).abs < 0.01 && resized.last(2) == [1, 18]
+objc.send(window.view, "insertText:replacementRange:", objc.string("日本"),
+  [Zaniah::Platform::Mac::NS_NOT_FOUND, 0], args: [:pointer, :range], result: :void)
+raise "commit callback missing" unless events.last.is_a?(Zaniah::Input::TextInput) && events.last.text == "日本"
+
+number = objc.send(window.handle, "windowNumber", result: :long)
+post_key = lambda do |type|
+  event = objc.send(objc.klass("NSEvent"), "keyEventWithType:location:modifierFlags:timestamp:windowNumber:context:characters:charactersIgnoringModifiers:isARepeat:keyCode:",
+    type, [0, 0], 0, Process.clock_gettime(Process::CLOCK_MONOTONIC), number, 0,
+    objc.string("a"), objc.string("a"), 0, 0,
+    args: [:ulong, :point, :ulong, :double, :long, :pointer, :pointer, :pointer, :bool, :uint])
+  objc.send(app.handle, "postEvent:atStart:", event, 0, args: [:pointer, :bool], result: :void)
+end
+
+# A standalone tick still drains events. The run loop also drains the entire
+# queue before its tick callback, with no second blocking/nonblocking poll.
+post_key.call(10)
+window.tick
+raise "standalone tick did not deliver key down" unless events.grep(Zaniah::Input::KeyDown).any? { |event| event.keystroke == "a" }
+post_key.call(11)
+post_key.call(10)
+post_key.call(11)
+window.on_tick do
+  raise "queued key events were delayed" unless events.grep(Zaniah::Input::KeyUp).count { |event| event.keystroke == "a" } == 2
+  raise "queued key down duplicated" unless events.grep(Zaniah::Input::KeyDown).count { |event| event.keystroke == "a" } == 2
+  window.close
+end
+window.run
+puts "Cocoa: queued key down/up, standalone tick, run, Japanese composition/commit and moved/resized IME rectangles passed"

data/examples/mac_poll_bench.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Measures native event retrieval only, not whole-application idle CPU.
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+require "json"
+abort "Cocoa requires macOS" unless RUBY_PLATFORM.include?("darwin")
+
+window = Zaniah::Platform.open_window(backend: :mac, width: 320, height: 200, title: "Cocoa event retrieval benchmark")
+app = Zaniah::Platform::Mac::App.instance
+100.times { app.poll }
+samples = Array.new(15) do
+  GC.start
+  allocations = GC.stat(:total_allocated_objects)
+  cpu = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
+  200.times { app.poll }
+  elapsed = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - cpu
+  [(GC.stat(:total_allocated_objects) - allocations) / 200.0, elapsed * 1_000_000 / 200]
+end
+puts JSON.generate(ruby: RUBY_DESCRIPTION, yjit: defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?,
+  samples: samples.length, polls_per_sample: 200,
+  median_objects_per_poll: samples.map(&:first).sort[samples.length / 2],
+  median_cpu_microseconds_per_poll: samples.map(&:last).sort[samples.length / 2])
+window.close

data/examples/metal_state_check.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+abort "This check needs macOS and a graphical login" unless RUBY_PLATFORM.include?("darwin")
+
+window = Zaniah::Platform.open_window(backend: :mac, gpu: :metal, width: 96, height: 72, title: "Metal state reuse check")
+begin
+  device, scene, checks = window.device, Zaniah::Scene.new, 0
+  descriptor = device.instance_variable_get(:@render_pass)
+  check = lambda do |pixels, x, y, expected|
+    scale = window.scale_factor
+    width = (device.width * scale).round
+    actual = pixels.byteslice(((y * scale).to_i * width + (x * scale).to_i) * 4, 4).unpack("C4")
+    raise "pixel (#{x}, #{y}): #{actual.inspect}, expected #{expected.inspect}" unless actual.zip(expected).all? { |a, b| (a - b).abs <= 2 }
+    checks += 1
+  end
+  render = lambda do |clear|
+    device.render(scene, clear: clear)
+    raise "render-pass descriptor was not reused" unless descriptor == device.instance_variable_get(:@render_pass)
+    device.pixels
+  end
+
+  clear = +"#ff000080"
+  check.call(render.call(clear), 4, 4, [255, 0, 0, 128])
+  clear.replace("#00ff0080")
+  check.call(render.call(clear), 4, 4, [0, 255, 0, 128])
+  clear = [0.0, 0.0, 1.0, 1.0]
+  check.call(render.call(clear), 4, 4, [0, 0, 255, 255])
+  clear[0], clear[2] = 1.0, 0.0
+  check.call(render.call(clear), 4, 4, [255, 0, 0, 255])
+  begin
+    render.call(nil)
+    raise "nil clear color was accepted"
+  rescue ArgumentError
+    checks += 1
+  end
+
+  scene.clip(Zaniah::Bounds.new(-5, -5, 15, 15)) { scene.quad(0, 0, 96, 72, color: "#f00") }
+  scene.clip(Zaniah::Bounds.new(999, 999, 10, 10)) { scene.quad(0, 0, 96, 72, color: "#0f0") }
+  scene.quad(20, 20, 12, 12, color: "#00f")
+  scene.clip(Zaniah::Bounds.new(40, 4, 20, 12)) do
+    scene.clip(Zaniah::Bounds.new(48, 0, 6, 16)) { scene.quad(0, 0, 96, 72, color: "#0f0") }
+  end
+  pixels = render.call("#000")
+  check.call(pixels, 2, 2, [255, 0, 0, 255])
+  check.call(pixels, 11, 11, [0, 0, 0, 255])
+  check.call(pixels, 24, 24, [0, 0, 255, 255])
+  check.call(pixels, 50, 8, [0, 255, 0, 255])
+  check.call(pixels, 42, 8, [0, 0, 0, 255])
+  check.call(pixels, 55, 8, [0, 0, 0, 255])
+
+  texture = device.create_texture(1, 1, data: [255, 0, 0, 255].pack("C4"))
+  scene.clear.sprite(36, 28, 8, 8, texture: texture)
+  check.call(render.call("#000"), 40, 32, [255, 0, 0, 255])
+  texture.upload(0, 0, 1, 1, [0, 255, 0, 255].pack("C4"))
+  check.call(render.call("#000"), 40, 32, [0, 255, 0, 255])
+  scene.clear.quad(8, 8, 32, 32, color: "#00f")
+  scene.quad(8, 8, 32, 32, color: "#ff000080")
+  check.call(render.call("#000"), 16, 16, [128, 0, 127, 255])
+
+  [[120, 80], [64, 48]].each do |width, height|
+    device.resize(width, height)
+    scene.clear.quad(0, 0, width, height, color: "#123")
+    pixels = render.call("#000")
+    check.call(pixels, 2, 2, [17, 34, 51, 255])
+    check.call(pixels, width - 2, height - 2, [17, 34, 51, 255])
+  end
+  puts "Metal state reuse: #{checks} checks passed, scale=#{window.scale_factor}"
+ensure
+  window.close
+end

data/examples/native_bench.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+
+backend = RUBY_PLATFORM.include?("darwin") ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux
+window = Zaniah::Platform.open_window(backend: backend, gpu: ARGV.include?("--gl") ? :opengl : backend == :mac ? :metal : :opengl, width: 800, height: 600)
+scene = Zaniah::Scene.new
+10_000.times { |i| scene.quad((i % 100) * 8, (i / 100) * 6, 7, 5, color: "#49c", radius: 1) }
+window.draw { scene }
+samples = 40.times.map do
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  window.request_frame
+  window.tick
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+end.drop(5).sort
+puts "10,000 quads: median=#{samples[samples.length / 2].round(2)}ms, p95=#{samples[(samples.length * 0.95).floor].round(2)}ms, draw_calls=#{window.device.draw_calls}"
+window.close

data/examples/native_drop.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+
+backend = RUBY_PLATFORM.include?("darwin") ? :mac : :linux
+window = Zaniah::Platform.open_window(backend: backend, width: 320, height: 180, title: "Native file drop check")
+events = []
+window.on_input { |event| events << event }
+expected = "/tmp/zaniah 日本.txt"
+if backend == :mac
+  objc = Zaniah::FFI::ObjC
+  board = objc.send(objc.klass("NSPasteboard"), "pasteboardWithUniqueName")
+  objc.send(board, "setString:forType:", objc.string("file:///tmp/zaniah%20%E6%97%A5%E6%9C%AC.txt"), objc.string("public.file-url"), args: [:pointer, :pointer], result: :bool)
+  objc.subclass("ZaniahDropFixture", "NSObject") do |klass|
+    objc.method(klass, "draggingPasteboard", result: :pointer, encoding: "@@:") { board }
+    objc.method(klass, "draggingLocation", result: :point, encoding: "{CGPoint=dd}@:") { [40.0, 40.0] }
+  end
+  dragging = objc.new("ZaniahDropFixture")
+  accepted = objc.send(window.view, "performDragOperation:", dragging, args: [:pointer], result: :bool)
+  raise "Cocoa rejected file drop" if accepted.zero?
+  window.tooltip = "Native tooltip"
+  raise "tooltip not installed" unless objc.text(objc.send(window.view, "toolTip")) == "Native tooltip"
+  changes = []
+  window.on_appearance { |value| changes << value }
+  %w[NSAppearanceNameDarkAqua NSAppearanceNameAqua].each do |name|
+    # Exported symbol names are not their string values (DarkAqua/Aqua).
+    native = objc.send(objc.klass("NSAppearance"), "appearanceNamed:", objc.string(name.delete_prefix("NSAppearanceName")), args: [:pointer])
+    objc.send(window.view, "setAppearance:", native, args: [:pointer], result: :void)
+    window.tick
+  end
+  raise "appearance notification missing: #{changes.inspect}" unless changes.include?(:dark) && changes.include?(:light)
+  objc.send(window.view, "setAppearance:", 0, args: [:pointer], result: :void)
+  objc.release(dragging)
+  objc.send(board, "releaseGlobally", result: :void)
+else
+  raise "run this protocol check under X11" unless window.is_a?(Zaniah::Platform::Linux::Window)
+  klass = Zaniah::Platform::Linux::Window
+  ptype, long, int = klass::P, klass::L, klass::I
+  source = klass.allocate
+  source.instance_variable_set(:@x, Zaniah::FFI::Library.new("libX11.so.6"))
+  source.instance_variable_set(:@atoms, {})
+  display = source.x(:XOpenDisplay, [ptype], ptype, 0)
+  source.instance_variable_set(:@display, display)
+  root = source.x(:XDefaultRootWindow, [ptype], long, display)
+  handle = source.x(:XCreateSimpleWindow, [ptype, long, int, int, int, int, int, long, long], long, display, root, 0, 0, 40, 40, 0, 0, 0)
+  source.instance_variable_set(:@handle, handle)
+  source.x(:XSetSelectionOwner, [ptype, long, long, long], int, display, source.atom("XdndSelection"), handle, 0)
+  source.send_client_message(window.handle, "XdndEnter", [handle, 5 << 24, source.atom("text/uri-list"), 0, 0])
+  source.send_client_message(window.handle, "XdndPosition", [handle, 0, (20 << 16) | 30, 0, source.atom("XdndActionCopy")])
+  source.send_client_message(window.handle, "XdndDrop", [handle, 0, 0, 0, 0])
+  finished, deadline = false, Process.clock_gettime(Process::CLOCK_MONOTONIC) + 3
+  until finished || Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+    window.tick
+    while source.x(:XPending, [ptype], int, display).positive?
+      event = "\0".b * 192
+      source.x(:XNextEvent, [ptype, ptype], int, display, event)
+      if event.unpack1("i") == 30
+        requestor, selection, target, property, time = event[40, 40].unpack("L!5")
+        warn "XDND request #{[requestor, selection, target, property, time].inspect}; target=#{window.handle}, source=#{handle}" if ENV["ZANIAH_DROP_DEBUG"]
+        source.property(requestor, property, target, "# file offer\r\nfile:///tmp/zaniah%20%E6%97%A5%E6%9C%AC.txt\r\n")
+        reply = "\0".b * 192
+        reply[0, 4] = [31].pack("i")
+        reply[24, 8] = [display.to_i].pack("J")
+        reply[32, 40] = [requestor, selection, target, property, time].pack("L!5")
+        source.x(:XSendEvent, [ptype, long, int, long, ptype], int, display, requestor, 0, 0, reply)
+        source.x(:XFlush, [ptype], int, display)
+      elsif event.unpack1("i") == 33 && event[40, 8].unpack1("L!") == source.atom("XdndFinished")
+        raise "XDND source did not receive success" unless event[64, 8].unpack1("L!") == 1
+        finished = true
+      end
+    end
+    sleep 0.005 unless finished
+  end
+  raise "XDND handshake timed out" unless finished
+  source.x(:XDestroyWindow, [ptype, long], int, display, handle)
+  source.x(:XCloseDisplay, [ptype], int, display)
+end
+drop = events.find { |event| event.is_a?(Zaniah::Input::FileDrop) }
+raise "file drop missing or corrupted: #{events.inspect}" unless drop&.paths == [expected]
+puts "#{window.class}: #{drop.inspect}"
+window.close

data/examples/native_font.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+require "alhena"
+
+provider_name = ARGV.delete("--freetype") ? :freetype : :coretext
+require "zaniah/platform/#{provider_name == :freetype ? 'linux/free_type' : 'mac/core_text'}"
+provider = provider_name == :freetype ? Zaniah::Platform::Linux::FreeType.new : Zaniah::Platform::Mac::CoreText.new
+font = Alhena::Font.open(ARGV.fetch(0))
+bitmap = provider.rasterize(font, font.glyph_id("A"), size: 32)
+raise "empty native font bitmap" unless bitmap.width.positive? && bitmap.height.positive? && bitmap.coverage.bytes.any?(&:positive?)
+puts "#{provider_name}: #{bitmap.width}x#{bitmap.height}, bearing=#{bitmap.left},#{bitmap.top}"
+puts bitmap.to_ascii
+provider.close

data/examples/native_ime.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Run inside a disposable D-Bus/X11 session with IBus and Mozc installed.
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+require "open3"
+
+window = Zaniah::Platform.open_window(backend: :linux, display_server: :x11, width: 400, height: 240, title: "IBus Japanese input check")
+events = []
+window.on_input { |event| events << event }
+window.ime_state = Zaniah::Bounds.new(20, 30, 1, 20)
+system("xdotool", "windowfocus", window.handle.to_s) or raise "focus failed"
+ic = window.instance_variable_get(:@ic)
+raise "XIM input context unavailable" unless ic
+deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1
+while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
+  window.tick
+  sleep 0.01
+end
+selector = Process.spawn("ibus", "engine", "mozc-on")
+deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+until (result = Process.waitpid2(selector, Process::WNOHANG))
+  raise "IBus engine selection timed out" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+  window.tick
+  sleep 0.01
+end
+current, = Open3.capture2e("ibus", "engine")
+# IBus CLI may return 1 after success when Mozc's layout is "default".
+# Its active engine, not setxkbmap's exit status, determines readiness.
+raise "Mozc engine selection failed: #{result.last.inspect}, current=#{current.inspect}" unless current.strip == "mozc-on"
+sender = Process.spawn("xdotool", "type", "--delay", "100", "nihon")
+deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 3
+until Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+  window.tick
+  sleep 0.01
+end
+Process.wait(sender)
+sender = Process.spawn("xdotool", "key", "space", "Return")
+deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 2
+until Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+  window.tick
+  sleep 0.01
+end
+Process.wait(sender)
+preedit = events.grep(Zaniah::Input::Composition).map(&:text)
+committed = events.grep(Zaniah::Input::TextInput).map(&:text).join
+raise "Japanese preedit missing: #{events.inspect}" unless preedit.any? { |text| text.match?(/[にほ日]/) }
+raise "Japanese commit missing or duplicated: #{events.inspect}" unless ["日本", "にほん"].include?(committed)
+puts "IBus/Mozc: preedit=#{preedit.inspect}, committed=#{committed.inspect}"
+window.close

data/examples/native_smoke.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+
+backend = RUBY_PLATFORM.include?("darwin") ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux
+gpu = ARGV.include?("--gl") ? :opengl : backend == :mac ? :metal : :opengl
+window = Zaniah::Platform.open_window(backend: backend, gpu: gpu, width: 640, height: 400, title: "Zaniah UI native rendering")
+scene = Zaniah::Scene.new
+scene.quad(0, 0, 640, 400, color: "#18202b")
+scene.quad(24, 24, 280, 130, color: "#46a0d8", radius: [20, 8, 20, 8], border_width: 3, border_color: "#fff")
+scene.quad(180, 80, 260, 130, color: "#d35b7790", radius: 24)
+texture = window.device.create_texture(2, 2, data: [255, 255, 255, 255, 80, 140, 255, 255, 80, 220, 160, 255, 0, 0, 0, 255].pack("C*"))
+scene.sprite(28, 210, 120, 120, texture: texture)
+scene.triangle([330, 260, 450, 340, 530, 220], color: "#f8ca72")
+window.draw { scene }
+window.on_input do |event|
+  puts event.inspect
+  window.close if event.is_a?(Zaniah::Input::KeyDown) && event.keystroke == "esc"
+end
+if ARGV.include?("--check")
+  screens = window.displays
+  raise "native display enumeration failed: #{screens.inspect}" unless screens.any? { |screen| screen.bounds.width.positive? && screen.scale_factor.positive? }
+  puts "Displays: #{screens.inspect}"
+  events = []
+  window.on_input { |event| events << event }
+  if backend == :mac
+    objc = Zaniah::FFI::ObjC
+    objc.send(window.view, "setMarkedText:selectedRange:replacementRange:", objc.string("にほん"), [3, 0], [(1 << 63) - 1, 0], args: [:pointer, :range, :range], result: :void)
+    raise "marked text callback failed" unless events.last.is_a?(Zaniah::Input::Composition) && events.last.text == "にほん"
+    objc.send(window.view, "insertText:replacementRange:", objc.string("日本"), [(1 << 63) - 1, 0], args: [:pointer, :range], result: :void)
+    raise "committed text callback failed" unless events.last.is_a?(Zaniah::Input::TextInput) && events.last.text == "日本"
+    window.ime_state = Zaniah::Bounds.new(20, 30, 1, 18)
+    candidate = objc.send(window.view, "firstRectForCharacterRange:actualRange:", [0, 1], 0, args: [:range, :pointer], result: :rect)
+    raise "IME candidate rectangle failed" unless candidate.last(2) == [1, 18]
+  elsif backend == :linux && window.is_a?(Zaniah::Platform::Linux::Window) && ENV["ZANIAH_CHECK_INPUT"]
+    system("xdotool", "windowfocus", window.handle.to_s, "key", "a", "mousemove", "--window", window.handle.to_s, "40", "40", "click", "1", "click", "5") or raise "xdotool input failed"
+    3.times { window.tick }
+    raise "X11 keyboard text missing: #{events.inspect}" unless events.any? { |event| event.is_a?(Zaniah::Input::TextInput) && event.text == "a" }
+    raise "X11 mouse button missing" unless events.any? { |event| event.is_a?(Zaniah::Input::MouseDown) }
+    raise "X11 scroll-down direction reversed" unless events.any? { |event| event.is_a?(Zaniah::Input::ScrollWheel) && event.delta.y.positive? }
+  end
+  3.times { window.request_frame; window.tick }
+  output = ARGV.find { |argument| argument.end_with?(".png") }
+  window.write_png(output) if output
+  scale = window.scale_factor
+  pixels = window.device.pixels
+  pixel_width = (window.content_size.width * scale).round
+  actual = pixels.byteslice(((40 * scale).to_i * pixel_width + (40 * scale).to_i) * 4, 4).unpack("C4")
+  expected = [70, 160, 216, 255]
+  raise "GPU pixel mismatch: #{actual.inspect}" unless actual.zip(expected).all? { |a, b| (a - b).abs <= 2 }
+  puts "#{window.class}/#{gpu}: pixel=#{actual.inspect}, draw_calls=#{window.device.draw_calls}, scale=#{scale}"
+  if backend == :linux && window.is_a?(Zaniah::Platform::Linux::Window) && ENV["ZANIAH_CHECK_DPI"]
+    # linux_smoke owns this disposable X server. Restore its resource property.
+    root, property = window.instance_variable_get(:@root), window.atom("RESOURCE_MANAGER")
+    previous = window.read_property(root, property, delete: false)
+    begin
+      changed = previous.gsub(/^Xft\.dpi:.*$/, "") + "\nXft.dpi: 192\n"
+      window.property(root, property, window.atom("STRING"), changed)
+      window.x(:XFlush, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT, window.display)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1
+      until window.scale_factor == 2
+        raise "X11 DPI change was not delivered" if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+        window.tick
+      end
+      puts "X11 live DPI: #{scale} -> #{window.scale_factor}"
+    ensure
+      window.property(root, property, window.atom("STRING"), previous)
+      window.x(:XFlush, [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT, window.display)
+    end
+  end
+  window.close
+else
+  window.run
+end

data/examples/native_text_bench.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+require "zaniah/gpu/instance_packing"
+
+backend = RUBY_PLATFORM.include?("darwin") ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux
+gpu = ARGV.include?("--gl") ? :opengl : backend == :mac ? :metal : :opengl
+font_path = File.expand_path("../assets/fonts/Abel-Regular.ttf", __dir__)
+database = Zaniah::TextSystem::FontDB.new(paths: [font_path])
+system = Zaniah::TextSystem::Renderer.new(font_db: database)
+window = Zaniah::Platform.open_window(backend: backend, gpu: gpu, width: 800, height: 640, title: "Cached 10,000-glyph text check")
+system.scale_factor = window.scale_factor
+texts = Array.new(100) { |i| (format("%03d", i) + "Abcdefghij" * 10).byteslice(0, 100).freeze }
+scene = Zaniah::Scene.new
+window.draw do
+  scene.clear
+  texts.each_with_index do |text, i|
+    system.paint_line(scene, system.layout_line(text, size: 7), x: 4, y: 8 + i * 6, color: "#fff")
+  end
+  scene
+end
+
+samples, allocations = [], []
+40.times do |i|
+  before = GC.stat(:total_allocated_objects)
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  window.request_frame
+  window.tick
+  elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+  objects = GC.stat(:total_allocated_objects) - before
+  if i >= 5
+    samples << elapsed
+    allocations << objects
+  end
+end
+bytes, batches = Zaniah::GPU::InstancePacking.pack(scene)
+raise "expected 10,000 packed glyphs" unless bytes.bytesize == 10_000 * 96
+pixels = window.device.pixels
+ink, offset = 0, 0
+while offset < pixels.bytesize
+  ink += 1 if pixels.getbyte(offset) > 20
+  offset += 4
+end
+raise "native packed text readback was empty" unless ink > 1000
+output = ARGV.find { |argument| argument.end_with?(".png") }
+window.write_png(output) if output
+calls = 0
+trace = TracePoint.new(:c_call) { |event| calls += 1 if event.method_id == :call && event.defined_class == Fiddle::Function }
+trace.enable { window.request_frame; window.tick }
+puts "#{gpu}: 10,000 glyphs, present median=#{samples.sort[samples.length / 2].round(3)}ms p95=#{samples.sort[(samples.length * 0.95).floor].round(3)}ms allocations=#{allocations.sort[allocations.length / 2]} Fiddle calls=#{calls}"
+puts "readback=#{ink} ink pixels, #{bytes.bytesize} instance bytes, batches=#{batches.length}, draw_calls=#{window.device.draw_calls}, scale=#{window.scale_factor}"
+require "digest"
+puts "rgba_sha256=#{Digest::SHA256.hexdigest(pixels)}"
+if ARGV.include?("--allocations")
+  require "objspace"
+  GC.start
+  generation = GC.count
+  previously_disabled = GC.disable
+  begin
+    ObjectSpace.trace_object_allocations_start
+    window.request_frame
+    window.tick
+    ObjectSpace.trace_object_allocations_stop
+    sites = Hash.new(0)
+    ObjectSpace.each_object do |object|
+      file = ObjectSpace.allocation_sourcefile(object)
+      next unless file && ObjectSpace.allocation_generation(object) == generation
+      sites[[file, ObjectSpace.allocation_sourceline(object), object.class]] += 1
+    end
+    sites.sort_by { |_, count| -count }.first(25).each { |(file, line, type), count| puts "#{count} #{type} #{file}:#{line}" }
+  ensure
+    ObjectSpace.trace_object_allocations_stop
+    ObjectSpace.trace_object_allocations_clear
+    GC.enable unless previously_disabled
+  end
+end
+system.close
+window.close
+if ARGV.include?("--budget")
+  raise "native cached text frame exceeds 8ms median" if samples.sort[samples.length / 2] > 8
+  raise "native cached text frame exceeds 200 objects" if allocations.sort[allocations.length / 2] >= 200
+end

data/examples/native_watch.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "zaniah"
+require "tmpdir"
+
+platform = RUBY_PLATFORM.include?("darwin") ? :mac : RUBY_PLATFORM.match?(/mingw|mswin/) ? :windows : :linux
+require "zaniah/platform/#{platform}/watcher"
+Dir.mktmpdir("zaniah-watch-") do |directory|
+  watcher = Zaniah::Platform.const_get(platform.to_s.capitalize)::Watcher.new(directory)
+  begin
+    path = File.join(directory, "native-event.txt")
+    File.write(path, "filesystem notification")
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+    events = []
+    loop do
+      events.concat(watcher.poll(timeout: 0.05))
+      break if events.any? { |event| event.path&.end_with?("native-event.txt") }
+      raise "native watcher received no file event: #{events.inspect}" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+    end
+    puts events.inspect
+  ensure
+    watcher.close
+  end
+end

data/examples/vulkan_triangle.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../../electra/lib", __dir__))
+require "zaniah"
+require "zaniah/gpu/vulkan"
+require_relative "../../electra/examples/shaders"
+
+device = Zaniah::GPU::Vulkan.new(width: 128, height: 128)
+begin
+  pixels = device.render_triangle(vertex_spirv: ExampleShaders.triangle_vertex, fragment_spirv: ExampleShaders.triangle_fragment)
+  center = pixels.byteslice((64 * 128 + 64) * 4, 4).unpack("C4")
+  outside = pixels.byteslice(0, 4).unpack("C4")
+  raise "Vulkan triangle pixel mismatch: #{center.inspect}" unless center.zip([255, 64, 0, 255]).all? { |actual, expected| (actual - expected).abs <= 1 }
+  raise "Vulkan clear pixel mismatch: #{outside.inspect}" unless outside == [0, 0, 0, 255]
+  device.write_png(ARGV.first) if ARGV.first
+  puts "Vulkan #{device.device_name}: triangle=#{center.inspect}, clear=#{outside.inspect}"
+ensure
+  device.release
+end

data/examples/word_count_worker.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Standalone, fixed entrypoint loaded by ProcessPool in each spawned Ruby.
+module WordCountWorker
+  def self.call(data)
+    {"words" => data.fetch("text").split.length, "pid" => Process.pid}
+  end
+end

data/lib/zaniah/anchored.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Anchored < Div
+    def initialize(anchor:, offset: Point.new(0, 0))
+      super()
+      style(position: :absolute, left: anchor.x + offset.x, top: anchor.y + offset.y)
+    end
+  end
+end