zaniah 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 985d3d62a8ffa112effba1aed1976c2b7403a7e6ef2a49dca9b817c80d49b3da
-  data.tar.gz: 8e641aad423d506fcbf18fe5c6c22afa8beff2ae5b321ae73559cbec8ed26181
+  metadata.gz: 74d3240032d7ae845a8a1f8f3208cb102ef0b68637cc184ba0f8860ac57b05ee
+  data.tar.gz: 4166002c76247745610218aed5d9090459889b9b383b97b669b199adac46761b
 SHA512:
-  metadata.gz: e71ed6d538a8ba9f48d3521def68d05957c637d631116dbf5676a47672d750b1128d361b7b8af48cd5231c01742db7ca88b6846961fc30c58339d4bf696e05a0
-  data.tar.gz: d6d48b77d5a4793d0e4aa2c4a5e23ccd34f4d5d690c858ecba51ad3585571275a12fa3b5ec882c1a03abdc2db174f757e6002d642d9b13b42aafe46b53f1ca23
+  metadata.gz: d3e80aba0a90f7e946ce916e63e3eed342cac2b1c0eda9cb9dd14112f1c1a9affd4d0ee13bc2cfc81769bcbd12afa4288849825fe1a093396b6ee43893f68a7d
+  data.tar.gz: a1bd580a3da60ac7705f4329d7f7a4b435bdd85638e074710a84b2339a40744e5b1e82d7df243ac9eff439a29ca359e6737e7fa731cb86b6dbedd62b585e5db3

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.7.0 — 2026-09-24
+
+- Add a stable frame inspection API with accessibility queries and DevTools integration.
+- Unify focused and application commands with validation, availability, and checked state.
+- Add headless and TUI clipboard support, including OSC 52 output.
+- Add desktop editing shortcuts and copy, cut, paste, undo, and redo for plain and rich text while leaving conflicting TUI shortcuts unbound.
+- Add configurable matching and accessible, highlighted results to the command palette and combobox.
+
 ## 0.6.4 — 2026-09-24
 
 - Share Cartesian chart scales, axes, grid lines, ticks, and color-keyed legends across chart types.

data/docs/adr/013-public-inspection-api.md

@@ -0,0 +1,16 @@
+# ADR 013: Expose a stable inspection boundary
+
+- Status: Accepted
+- Date: 2026-09-24
+
+## Context
+
+External test drivers and DevTools currently read render state through internal instance variables or maintain duplicate tree walkers. Internal layout and platform state can change without notice, which makes downstream tooling fragile. One option is to expose each underlying object directly; another is to publish a read-only view of the latest frame.
+
+## Decision
+
+Publish `Zaniah::Inspection.snapshot(window)` as the external read boundary, backed by small, explicit read accessors on the existing objects. DevTools uses the same boundary. Snapshot values are frozen; the `Entry#element` reference remains live only until the next frame. During the 0.x series, a breaking change to this public API requires at least one minor release of deprecation before removal.
+
+## Consequences
+
+Inspection is constructed only when requested, avoiding per-frame traversal cost. The small accessors and compatibility period constrain internal refactors, but test drivers no longer depend on private instance variables. Native accessibility actions still require a current node and window.

data/docs/adr/014-unified-command-dispatch.md

@@ -0,0 +1,40 @@
+# ADR 014: Route UI commands through focused handlers before app actions
+
+- Status: Proposed
+- Date: 2026-09-24
+
+## Context
+
+Keyboard actions currently reach only focused handlers. Menus, palettes, context
+menus, and accessibility actions need the same behavior, including a way to ask
+whether an item is enabled without executing it. Routing each source separately
+would make focus precedence and disabled states diverge.
+
+Native menu accelerators introduce a separate risk: macOS can process a
+`keyEquivalent` in addition to the framework keymap. Keeping both active could
+execute one command twice.
+
+## Decision
+
+Use `Dispatcher#perform` for all command sources. Focused handlers take precedence
+from leaf to root, followed by `App#actions`. A focused handle can provide a
+side-effect-free `validate` callback: `false` blocks the command, `true` enables
+it, and `nil` defers to the next handle. `available?` asks validators and the app
+registry without invoking action handlers. Legacy focused handlers without a
+validator remain executable but cannot advertise availability by themselves.
+
+An unvalidated legacy focus handler still executes before a disabled app
+command, even though `available?` can only report the app command as disabled.
+Such focused actions need `validate` to advertise their own availability.
+
+Keyboard focus movement remains a dispatcher concern. Native menu shortcuts
+must be routed through the Zaniah keymap exactly once; platform adapters must
+verify that native `keyEquivalent` processing does not also invoke the command.
+
+## Consequences
+
+Menus and palettes can share dispatch and validation with keyboard input, and
+app-wide commands remain available when no focus handler consumes them. Focused
+actions intended for menus must provide `validate`; an opaque handler alone
+cannot safely report support without being run. Native shortcut behavior needs
+platform verification before this ADR can be accepted.

data/docs/components.md

@@ -59,7 +59,7 @@ Zaniah::UI::Button.variants[:variant][:brand] = ->(theme) {
 | L2 | `NumberInput` | TextField plus `min:`, `max:`, `step:`; `increment`, `decrement` | numeric | textbox |
 | L2 | `TagInput` | `(tags, separator:, ...)`; `on_tags_change` | badge list + editor | textbox |
 | L2 | `Select` | `(items, label:, value:, disabled:)`; `on_change` | single choice | combobox |
-| L2 | `Combobox` | `(items, value:, label:, placeholder:, disabled:)`; `on_change` | editable, filtered choices | combobox |
+| L2 | `Combobox` | `(items, value:, label:, placeholder:, disabled:, matcher:)`; `on_change` | editable, filtered choices with highlighted matches | combobox |
 | L2 | `MultiSelect` | `(items, value:, label:, disabled:)`; `on_change` | multiple selected badges | listbox |
 | L2 | `DatePicker` | `(value, min:, max:, label:, disabled:)`; `on_change` | ISO date, day/week keyboard steps | combobox |
 | L2 | `TimePicker` | `(value, step:, label:, disabled:)`; `on_change` | 24-hour time, minute/hour keyboard steps | combobox |
@@ -77,7 +77,7 @@ Zaniah::UI::Button.variants[:variant][:brand] = ->(theme) {
 | L3 | `Modal`, `Dialog` | `(content, title:, open:, close_on_scrim:, width:)` | focus trap, scrim, Esc | dialog/modal |
 | L3 | `Drawer` | Modal plus `side:` | left/right | dialog/modal |
 | L3 | `Toast` | `(message, variant:, queue:)`; `dismiss` | info/success/warning/danger | live status |
-| L3 | `CommandPalette` | `(commands, open:, placeholder:)` | searchable modal | dialog/list |
+| L3 | `CommandPalette` | `(commands, open:, placeholder:, matcher:)`; `.from(app.actions)` | searchable modal, Up/Down/Enter | dialog/list |
 | L3 | `SplitPane` | `(first, second, orientation:, ratio:, min:, max:)`; `on_change` | horizontal/vertical, draggable separator | group/separator |
 | L3 | `PaneGrid` | `(panes, columns:, rows:, divider_size:, minimum:, keyboard_step:)`; `replace`, `on_resize` | arbitrary resizable grid, stable pane IDs | group/separator |
 | L3 | `Resizable` | `(content, width:, height:, min_width:, min_height:, max_width:, max_height:)`; `on_resize` | drag or keyboard resize | group/separator |
@@ -100,6 +100,15 @@ All input components are keyboard operable. Disabled controls remain visible but
 removed from focus traversal. Overlay components close on Esc; modal overlays restore
 the previous focus. See [TUI](tui.md) for terminal representations.
 
+`Combobox` and `CommandPalette` default to case-insensitive substring matching in
+input order. Pass `matcher:` to either component, or set a default with
+`Zaniah.configure { |config| config.matcher = matcher }`. A matcher implements
+`match(query, labels)` and returns `UI::Matcher::Match` values with an original
+label `index`, descending `score`, and half-open UTF-8 byte `ranges` for highlighting.
+It may also implement `refine(previous_matches, query)` for incremental queries.
+`CommandPalette.from(app.actions)` uses registered action titles and disables
+unavailable actions; shortcuts will be added with `UI::Kbd` in the menu phase.
+
 `UI::RichText` accepts UTF-8 byte ranges at grapheme boundaries. Inline styles are
 `bold`, `italic`, `size`, `color`, `font`, and `link`; paragraphs support start,
 center, end, and non-final-line justification, plus bullet/ordered lists and levels.

data/docs/inspection.md

@@ -0,0 +1,19 @@
+# Frame inspection
+
+`Zaniah::Inspection` gives test drivers and DevTools a public, read-only view of the latest rendered frame. It works with headless and native windows.
+
+```ruby
+window.render(root)
+snapshot = Zaniah::Inspection.snapshot(window)
+save = snapshot.find(test_id: "save")
+buttons = snapshot.where(type: Zaniah::UI::Button)
+frontmost = snapshot.at(Zaniah::Point.new(120, 40))
+node, path = snapshot.accessibility.query(role: :button, label: /save/i).first
+Zaniah::Inspection.perform(window, node, :press)
+```
+
+`snapshot.root` and its children expose type, key, test ID, window-space bounds, resolved style, tooltip, context menu, handlers, and focus state. `snapshot.overlays` exposes tooltip, popup, and menu state; `snapshot.text_runs` contains rendered text; `snapshot.frame` contains a monotonically increasing frame number and timing statistics. `snapshot.find` returns the first match, `where` returns all matches, and `at` uses the frontmost registered hit region. A newly opened window has no root until its first render.
+
+The snapshot containers and copied collections are frozen. `entry.element` is deliberately a live element reference: use it only in the same frame, because the next render may replace it. Accessibility nodes are copied for inspection; pass one to `Inspection.perform` to invoke an action on its current source node. Actions require a node from the current frame. To wait for a settled UI, call `Zaniah::Inspection.idle?(app)` after draining queued work and rendering dirty windows.
+
+The public API is declared in [`sig/inspection.rbs`](../sig/inspection.rbs), and its independently runnable contract test is [`test/inspection_contract_test.rb`](../test/inspection_contract_test.rb). Breaking changes receive at least one minor version of deprecation during 0.x, as recorded in [ADR 013](adr/013-public-inspection-api.md).

data/docs/text.md

@@ -164,6 +164,25 @@ Supported inline styles are `bold`, `italic`, `size`, `color`, `font`, and
 receives `(text, rich_text)`; selection changes are reported by `on_select`.
 IME composition uses the existing `TextBuffer` composition path.
 
+## Editing shortcuts
+
+Editable text fields and rich text share the same actions from keyboard, menu,
+and command dispatch. The default desktop keys are:
+
+| Action | macOS | Windows | Linux |
+| --- | --- | --- | --- |
+| Undo / redo | Cmd+Z / Cmd+Shift+Z | Ctrl+Z / Ctrl+Y or Ctrl+Shift+Z | Ctrl+Z / Ctrl+Shift+Z |
+| Cut / copy / paste / select all | Cmd+X/C/V/A | Ctrl+X/C/V/A | Ctrl+X/C/V/A |
+| Previous / next word | Option+Left/Right | Ctrl+Left/Right | Ctrl+Left/Right |
+| Document start / end | Cmd+Up/Down | Ctrl+Home/End | Ctrl+Home/End |
+
+Shift with a word arrow extends the selection. Up/Down moves between logical
+lines in multiline fields; Home/End moves to the current line's edges. Copy
+requires a selection, and password fields never copy or cut. Paste and undo
+are disabled during IME composition. The TUI does not assign these desktop
+editing shortcuts by default because terminal control keys can conflict;
+applications may provide a custom keymap.
+
 ## Inline and block overlays
 
 Attach non-editable UI elements to text without inserting bytes into the source:

data/docs/tui.md

@@ -20,7 +20,7 @@ tests and non-window integrations.
 | Tabs, Accordion, Collapsible | selected tab in brackets and `[+]`/`[-]` disclosure markers |
 | ScrollView, Scrollbar | clipped child content and `│`/`─` track |
 | Breadcrumb, Pagination, bars | slash-separated path, page status, space-separated content |
-| Modal, Dialog, Drawer, CommandPalette | box-drawing overlay; focus stays inside until dismissed |
+| Modal, Dialog, Drawer, CommandPalette | box-drawing overlay; palette filters results and supports Up/Down/Enter; focus stays inside until dismissed |
 | SplitPane, PaneGrid, Resizable, DockPanel | `│`/`─` separators, resize corner, or ordered dock regions |
 | ListView | visible rows with `>` on the selected item |
 | Toast | live status text |

data/lib/zaniah/accessibility/tree.rb

@@ -36,6 +36,15 @@ module Zaniah
 
       def find(&predicate) = each.find { |node, _path| predicate.call(node) }&.first
 
+      def query(role: nil, label: nil, states: {})
+        raise ArgumentError, "label must be a String or Regexp" unless label.nil? || label.is_a?(String) || label.is_a?(Regexp)
+        each.select do |node, _path|
+          (role.nil? || node.role == role) &&
+            (label.nil? || (node.label && (label.is_a?(Regexp) ? label.match?(node.label) : node.label == label))) &&
+            states.all? { |key, value| node.states.key?(key) && node.states[key] == value }
+        end
+      end
+
       def perform(node, action)
         owner = @action_owners&.[](node.object_id)
         owner&.accessibility_action(node, action)

data/lib/zaniah/app.rb

@@ -7,13 +7,14 @@ require_relative "task_executor"
 
 module Zaniah
   class App
-    attr_reader :windows, :executor
+    attr_reader :windows, :executor, :actions
 
     def initialize(clock: MONOTONIC_CLOCK)
       @slots, @generations, @free, @windows, @globals = [], [], [], [], {theme: Theme.dark}
       @listeners, @effects, @updating, @flushing = {}, [], 0, false
       @clock = clock
       @executor = TaskExecutor.new(clock: clock)
+      @actions = Input::ActionRegistry.new
     end
 
     def new_entity
@@ -107,6 +108,7 @@ module Zaniah
       options[:clock] ||= @clock
       window = Platform.open_window(**options)
       window.app = self
+      window.dispatcher.window = window
       @windows << window
       @globals[:theme] = platform_theme(window)
       window.on_appearance do |appearance|

data/lib/zaniah/configuration.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zaniah
-  Configuration = Struct.new(:font_raster, :shaper, :font_db, :segmenter, keyword_init: true)
+  Configuration = Struct.new(:font_raster, :shaper, :font_db, :segmenter, :matcher, keyword_init: true)
 end

data/lib/zaniah/devtools/inspector.rb

@@ -2,7 +2,7 @@
 
 module Zaniah
   module DevTools
-    Entry = Data.define(:object, :name, :key, :test_id, :bounds, :style, :children)
+    Entry = Inspection::Entry
 
     class Inspector
       attr_reader :window, :snapshot, :selected
@@ -32,8 +32,9 @@ module Zaniah
         true
       end
 
-      def frame(element)
-        @snapshot = collect(element)
+      def frame(_element)
+        @inspection = Inspection.snapshot(window)
+        @snapshot = @inspection.root
         return unless visible?
         @selected = hovered
         paint_highlight(@selected.bounds) if @selected&.bounds
@@ -42,33 +43,8 @@ module Zaniah
 
       private
 
-      def collect(object, seen = {})
-        return if !object || seen[object.object_id]
-        seen[object.object_id] = true
-        node = object.respond_to?(:layout_node) ? object.layout_node : nil
-        style = if object.respond_to?(:resolved_style) && object.resolved_style
-          object.resolved_style.to_h
-        elsif object.respond_to?(:root) && object.root&.respond_to?(:resolved_style) && object.root.resolved_style
-          object.root.resolved_style.to_h
-        else {}
-        end
-        children = object.respond_to?(:children) ? object.children.filter_map { |child| collect(child, seen) } : []
-        Entry.new(object: object, name: object.class.name.sub("Zaniah::", ""),
-          key: object.respond_to?(:identity_key) ? object.identity_key : nil,
-          test_id: object.respond_to?(:test_id) ? object.test_id : nil,
-          bounds: node&.bounds, style: style.freeze, children: children.freeze)
-      end
-
       def hovered
-        owner = window.dispatcher.hits.reverse.find { |hit| window.pointer_position && hit.bounds.contains?(window.pointer_position) }&.owner
-        find_entry(@snapshot, owner) || @snapshot
-      end
-
-      def find_entry(entry, object)
-        return unless entry && object
-        return entry if entry.object.equal?(object)
-        entry.children.each { |child| return found if (found = find_entry(child, object)) }
-        nil
+        @inspection.at(window.pointer_position) || @snapshot
       end
 
       def paint_highlight(bounds)

data/lib/zaniah/element.rb

@@ -52,16 +52,19 @@ module Zaniah
     def opacity(value) = style(opacity: value)
     def ring(width, color = nil, offset = 0) = style(ring: Ring.new(width, color, offset))
     def cursor(value) = style(cursor: value)
-    def focusable(tab_index: 0, context: {}, &on_action)
+    def focusable(tab_index: 0, context: {}, validate: (validate_omitted = true), &on_action)
       @focus_handle ||= Input::FocusHandle.new(owner: self)
       @focus_handle.tab_index, @focus_handle.focusable = Integer(tab_index), true
       @focus_handle.context.merge!(context)
+      @focus_handle.validate = validate unless validate_omitted
       @focus_handle.on_action = on_action if on_action
       self
     end
     def focus_handle = @focus_handle
     def tooltip(text) = (@tooltip = text.to_s; self)
+    def tooltip_text = @tooltip
     def context_menu(items) = (@context_menu = items; self)
+    def context_menu_items = @context_menu
     def flex = style(display: :flex)
     def flex_row = style(flex_direction: :row)
     def flex_col = style(flex_direction: :column)

data/lib/zaniah/input/action_registry.rb

@@ -2,11 +2,20 @@
 
 module Zaniah
   module Input
+    Command = Data.define(:name, :title, :category, :enabled, :checked, :handler)
+
     class ActionRegistry
       def initialize = @actions = {}
-      def register(name, description: name, &block) = @actions[name.to_s] = [description, block]
-      def call(name, *args) = @actions.fetch(name.to_s)[1].call(*args)
-      def entries = @actions.transform_values(&:first).freeze
+
+      def register(name, description: nil, title: nil, category: nil, enabled: nil, checked: nil, &block)
+        title ||= description || name
+        @actions[name.to_s] = Command.new(name, title, category, enabled, checked, block)
+        [title, block]
+      end
+
+      def command(name) = @actions[name.to_s]
+      def call(name, *args) = @actions.fetch(name.to_s).handler.call(*args)
+      def entries = @actions.transform_values(&:title).freeze
     end
   end
 end

data/lib/zaniah/input/dispatcher.rb

@@ -3,9 +3,18 @@
 module Zaniah
   module Input
     Hit = Data.define(:bounds, :owner)
+    HitRegion = Data.define(:bounds, :owner, :transform, :clip) do
+      def contains?(point)
+        return false if clip && !clip.contains?(point)
+        bounds.contains?(transform.inverse.apply(point))
+      rescue ArgumentError
+        false
+      end
+    end
 
     class Dispatcher
       attr_reader :focused, :focus_origin, :focus_tree
+      attr_accessor :window
 
       def initialize(keymap: Keymap.default_ui)
         @keymap, @hits = keymap, []
@@ -45,10 +54,46 @@ module Zaniah
           focus(target, origin: :keyboard)
           return action
         end
-        chain.each { |handle| break if handle.on_action&.call(action) }
+        perform(action, source: :keyboard)
         action
       end
 
+      def perform(action, source: :keyboard)
+        chain = @focused ? @focused.ancestors : []
+        chain.each do |handle|
+          if handle.validate
+            state = handle.validate.call(action)
+            return false if state == false
+            next if state.nil?
+          end
+          return true if handle.on_action&.call(action)
+        end
+        command = @window&.app&.actions&.command(action)
+        return false unless command&.handler
+        context = FrameContext.new(@window)
+        return false if command.enabled&.call(context) == false
+        command.handler.call(context)
+        true
+      end
+
+      def available?(action)
+        chain = @focused ? @focused.ancestors : []
+        chain.each do |handle|
+          next unless handle.validate
+          state = handle.validate.call(action)
+          return state ? :enabled : :disabled unless state.nil?
+        end
+        command = @window&.app&.actions&.command(action)
+        return :unhandled unless command
+        return :disabled unless command.handler
+        command.enabled&.call(FrameContext.new(@window)) == false ? :disabled : :enabled
+      end
+
+      def checked?(action)
+        command = @window&.app&.actions&.command(action)
+        command&.checked&.call(FrameContext.new(@window))
+      end
+
       def register_focus(handle)
         owner = handle.owner&.respond_to?(:parent) ? handle.owner.parent : nil
         while owner
@@ -75,6 +120,7 @@ module Zaniah
         @transforms.replace([Transform.identity])
       end
       def hits = @hits.map { |bounds, _, owner, _, clip| Hit.new(clip ? bounds.intersect(clip) : bounds, owner) }.freeze
+      def hit_regions = @hits.map { |bounds, _, owner, transform, clip| HitRegion.new(bounds, owner, transform, clip) }.freeze
 
       def hover_chain(position)
         return [] unless position

data/lib/zaniah/input/focus_handle.rb

@@ -4,11 +4,12 @@ module Zaniah
   module Input
     class FocusHandle
       attr_reader :parent, :children, :context, :owner
-      attr_accessor :on_action, :on_focus, :on_input, :tab_index, :focusable, :bounds
+      attr_accessor :on_action, :on_focus, :on_input, :validate, :tab_index, :focusable, :bounds
 
-      def initialize(parent: nil, context: {}, owner: nil, tab_index: nil, focusable: true, bounds: nil)
+      def initialize(parent: nil, context: {}, owner: nil, tab_index: nil, focusable: true, bounds: nil, validate: nil)
         @parent, @context, @owner, @children = parent, context, owner, []
         @tab_index, @focusable, @bounds = tab_index, focusable, bounds
+        @validate = validate
         parent&.children&.push(self)
       end
 

data/lib/zaniah/input/keymap.rb

@@ -6,6 +6,10 @@ require_relative "context_predicate"
 
 module Zaniah
   module Input
+    module StandardActions
+      EDIT = %i[undo redo cut copy paste select_all].freeze
+    end
+
     class Keymap
       class << self
         def default_ui(platform: RUBY_PLATFORM, **options)
@@ -13,8 +17,11 @@ module Zaniah
         end
 
         def platform_defaults(platform, **options)
-          primary = platform.to_s.match?(/darwin|mac/) ? "cmd" : "ctrl"
-          new(**options)
+          mac = platform.to_s.match?(/darwin|mac/)
+          windows = platform.to_s.match?(/mingw|mswin|windows/)
+          tui = platform.to_s == "tui"
+          primary = mac ? "cmd" : "ctrl"
+          map = new(**options)
             .bind("tab", :focus_next)
             .bind("shift-tab", :focus_previous)
             .bind("left", :focus_left, context: "!in_text_field && !in_list")
@@ -30,7 +37,6 @@ module Zaniah
             .bind("pagedown", :page_down, context: "in_list")
             .bind("up", :previous_option, context: "in_list")
             .bind("down", :next_option, context: "in_list")
-            .bind("#{primary}-a", :select_all, context: "in_text_field || in_list")
             .bind("left", :move_left, context: "in_text_field")
             .bind("right", :move_right, context: "in_text_field")
             .bind("shift-left", :select_left, context: "in_text_field")
@@ -73,7 +79,6 @@ module Zaniah
             .bind("end", :last, context: "in_table")
             .bind("pageup", :page_up, context: "in_table")
             .bind("pagedown", :page_down, context: "in_table")
-            .bind("#{primary}-a", :select_all, context: "in_table")
             .bind("up", :previous_option, context: "in_grid")
             .bind("down", :next_option, context: "in_grid")
             .bind("left", :previous_column, context: "in_grid")
@@ -85,17 +90,38 @@ module Zaniah
             .bind("home", :first, context: "in_grid")
             .bind("end", :last, context: "in_grid")
             .bind("enter", :activate, context: "in_grid")
-            .bind("#{primary}-a", :select_all, context: "in_grid")
             .bind("up", :previous_option, context: "in_combobox")
             .bind("down", :next_option, context: "in_combobox")
             .bind("home", :first, context: "in_combobox")
             .bind("end", :last, context: "in_combobox")
             .bind("enter", :choose_option, context: "in_combobox")
             .bind("esc", :dismiss, context: "in_combobox")
+            .bind("up", :previous_option, context: "in_palette")
+            .bind("down", :next_option, context: "in_palette")
+            .bind("enter", :choose_option, context: "in_palette")
             .bind("left", :previous_option, context: "in_chart")
             .bind("right", :next_option, context: "in_chart")
             .bind("home", :first, context: "in_chart")
             .bind("end", :last, context: "in_chart")
+            .bind("up", :line_up, context: "in_text_field && multiline")
+            .bind("down", :line_down, context: "in_text_field && multiline")
+          return map if tui
+
+          word = mac ? "alt" : "ctrl"
+          map.bind("#{primary}-a", :select_all)
+            .bind("#{primary}-z", :undo)
+            .bind("#{primary}-shift-z", :redo)
+            .bind("#{primary}-x", :cut)
+            .bind("#{primary}-c", :copy)
+            .bind("#{primary}-v", :paste)
+            .bind("#{word}-left", :word_left, context: "in_text_field")
+            .bind("#{word}-right", :word_right, context: "in_text_field")
+            .bind("#{word}-shift-left", :select_word_left, context: "in_text_field")
+            .bind("#{word}-shift-right", :select_word_right, context: "in_text_field")
+            .bind(mac ? "cmd-up" : "ctrl-home", :document_start, context: "in_text_field")
+            .bind(mac ? "cmd-down" : "ctrl-end", :document_end, context: "in_text_field")
+          map.bind("ctrl-y", :redo) if windows
+          map
         end
       end
 

data/lib/zaniah/inspection.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Inspection
+    SOURCE_NODES = ObjectSpace::WeakMap.new
+
+    Entry = Data.define(:element, :type, :key, :test_id, :bounds, :style, :tooltip,
+      :context_menu, :handlers, :focusable, :focused, :children) do
+      def name = type
+      def object = element
+      def focusable? = focusable
+      def focused? = focused
+    end
+
+    Overlays = Data.define(:tooltip, :popup, :menu)
+    FrameInfo = Data.define(:number, :stats)
+
+    AccessibilitySnapshot = Data.define(:root) do
+      def query(role: nil, label: nil, states: {})
+        raise ArgumentError, "label must be a String or Regexp" unless label.nil? || label.is_a?(String) || label.is_a?(Regexp)
+        return [].freeze unless root
+
+        found = []
+        pending = [[root, []]]
+        until pending.empty?
+          node, path = pending.pop
+          if (!role || node.role == role) &&
+              (!label || (node.label && (label.is_a?(Regexp) ? label.match?(node.label) : node.label == label))) &&
+              states.all? { |key, value| node.states.key?(key) && node.states[key] == value }
+            found << [node, path.freeze].freeze
+          end
+          node.children.each_with_index.reverse_each { |child, index| pending << [child, path + [index]] }
+        end
+        found.freeze
+      end
+    end
+
+    Snapshot = Data.define(:root, :overlays, :text_runs, :frame, :accessibility, :hits) do
+      def find(test_id: nil, type: nil) = where(test_id: test_id, type: type).first
+
+      def where(test_id: nil, type: nil)
+        return [].freeze unless root
+        found = []
+        pending = [root]
+        until pending.empty?
+          entry = pending.pop
+          if (!test_id || entry.test_id == test_id) &&
+              (!type || (type.is_a?(Class) ? entry.element.is_a?(type) : entry.type == type))
+            found << entry
+          end
+          pending.concat(entry.children.reverse)
+        end
+        found.freeze
+      end
+
+      def at(point)
+        return unless point
+        owner = hits.reverse_each.find { |hit| hit.contains?(point) }&.owner
+        while owner
+          pending = [root].compact
+          until pending.empty?
+            entry = pending.pop
+            return entry if entry.element.equal?(owner)
+            pending.concat(entry.children)
+          end
+          owner = owner.respond_to?(:parent) ? owner.parent : nil
+        end
+        nil
+      end
+    end
+
+    module_function
+
+    def snapshot(window)
+      raise ArgumentError, "expected a rendered window" unless window.respond_to?(:last_root) && window.respond_to?(:dispatcher)
+
+      seen = {}
+      root = entry(window.last_root, window, seen)
+      popup = window.popup if window.respond_to?(:popup)
+      popup = Platform::Headless::Popup.new(labels: copy(popup.labels), enabled: copy(popup.enabled),
+        selected_index: popup.selected_index, bounds: popup.bounds) if popup
+      overlays = Overlays.new(tooltip: copy(window.tooltip_state), popup: popup,
+        menu: window.app&.respond_to?(:menu_bar) ? window.app.menu_bar : nil)
+      text_runs = copy(window.text_runs)
+      frame = FrameInfo.new(number: window.frame_number, stats: copy(window.frame_stats))
+      Snapshot.new(root: root, overlays: overlays, text_runs: text_runs, frame: frame,
+        accessibility: AccessibilitySnapshot.new(root: copy_accessibility(window.accessibility_tree.root)),
+        hits: window.dispatcher.hit_regions)
+    end
+
+    def idle?(app)
+      app.executor.idle? && app.windows.all? { |window| window.closed? || (!window.dirty? && !window.animation_active?) }
+    end
+
+    def perform(window, node, action) = Accessibility.perform(window, SOURCE_NODES[node] || node, action)
+
+    def copy_accessibility(node)
+      return unless node
+      result = Accessibility::Node.new(role: node.role, label: copy(node.label), value: copy(node.value),
+        bounds: node.bounds, states: copy(node.states),
+        children: node.children.map { |child| copy_accessibility(child) }.freeze, actions: copy(node.actions))
+      SOURCE_NODES[result] = node
+      result
+    end
+    private_class_method :copy_accessibility
+
+    def entry(object, window, seen)
+      return unless object && !seen[object.object_id]
+      seen[object.object_id] = true
+      style = object.resolved_style if object.respond_to?(:resolved_style)
+      style ||= object.root&.resolved_style if object.respond_to?(:root)
+      handle = object.focus_handle if object.respond_to?(:focus_handle)
+      items = object.context_menu_items if object.respond_to?(:context_menu_items)
+      menu = items&.map { |label, callback| [label.dup.freeze, !callback.nil?].freeze }&.freeze if items.is_a?(Array)
+      Entry.new(element: object, type: object.class.name.to_s.delete_prefix("Zaniah::").freeze,
+        key: object.respond_to?(:identity_key) ? copy(object.identity_key) : nil,
+        test_id: object.respond_to?(:test_id) ? copy(object.test_id) : nil,
+        bounds: object.respond_to?(:layout_node) ? object.layout_node&.bounds : nil,
+        style: snapshot_style(style),
+        tooltip: object.respond_to?(:tooltip_text) ? copy(object.tooltip_text) : nil,
+        context_menu: menu, handlers: object.respond_to?(:handlers) ? copy(object.handlers) : [].freeze,
+        focusable: !!handle&.focusable, focused: !!(handle && window.dispatcher.focused.equal?(handle)),
+        children: object.respond_to?(:children) ? object.children.filter_map { |child| entry(child, window, seen) }.freeze : [].freeze)
+    end
+    private_class_method :entry
+
+    def snapshot_style(style)
+      values = style ? style.to_h : {}.freeze
+      return values if values.frozen? && values.values.none? { |value| value.is_a?(String) || value.is_a?(Array) || value.is_a?(Hash) }
+      copy(values)
+    end
+    private_class_method :snapshot_style
+
+    def copy(value)
+      case value
+      when String then value.dup.freeze
+      when Array then value.map { |item| copy(item) }.freeze
+      when Hash then value.to_h { |key, item| [copy(key), copy(item)] }.freeze
+      else value
+      end
+    end
+    private_class_method :copy
+  end
+
+  def self.bundled_font_path = File.expand_path("../../assets/fonts/Abel-Regular.ttf", __dir__)
+end