defimpl MyApp Panel {
    on-event {|event|
        # Pre-pass: let the widget tree consume first
        if ![tui/dispatch-tree-event $widget-state $event $bounds] {
            # Then handle leftover events at the panel level
            [match $event~key {
                :escape => [do-cancel]
                _       => nil
            }]
        }
    }
} 

 defimpl MyApp AppLifecycle {
    on-init {||
        [tui/set-widget-tree $widget-state]     # opt into framework dispatch
        # ... rest of init ...
    }
}

defimpl MyApp Keyable {
    on-key {|event|
        @doc "Fires ONLY when no focused widget consumed the key."
        [match $event~key {
            :escape => [do-cancel]
            _       => nil                      # bubble further
        }]
        # Modifier chords read the boolean fields:
        if ($event~ctrl and ($event~key == :s)) { [do-save] }
    }
} 

 defimpl MyInput Keyable {
    on-key {|event bounds|
        [match $event~key {
            :backspace => [handle-backspace $self]
            :enter     => [handle-submit $self]
            _          => nil                   # bubble everything else
        }]
    }
} 

 [tui/focus-widget "id"]                       # set focus
[tui/focused-widget-id]                       # -> id string | nil
[tui/cycle-focus :forward $tree]              # Tab-style cycling
[tui/cycle-focus :back    $tree]              # Shift-Tab
[tui/clear-focus]                             # drop focus 

 defimpl MyButton Hittable {
    hit {|event bounds|
        if ($event~type == :mouse-down) {
            :clicked                          # or a map with details
        } {
            nil                                # let it bubble
        }
    }
} 

 defimpl MyApp AppLifecycle {
    on-init {||
        # ... set up widget tree ...
        [tui/set-widget-tree $widget-state]
        [tui/focus-widget "query"]            # default focus on the search box
    }
} 

 defimpl MyApp Keyable {
    on-key {|event|
        if ($event~key == :escape) {
            [tui/clear-focus]
            [reset-to-browse-mode]
        }
    }
} 

 defimpl MyApp Keyable {
    on-key {|event|
        # This only fires when no widget consumed the key.
        # So typing 's' is safe even if a text input is focused —
        # the input would have consumed it first.
        [match $event~type {
            :text => {
                [match $event~text {
                    "s" => [do-stage]
                    "c" => [do-commit]
                    _   => nil
                }]
            }
            :key-down => {
                if ($event~ctrl and ($event~key == :s)) { [do-save] }
            }
            _ => nil
        }]
    }
} 

 %{
    :type  :key-down                  # named key pressed
    :key   :page_up                   # keyword from the Key vocabulary
    :ctrl  false                      # mods are booleans: :ctrl :shift :alt
    :shift true
    :alt   false
}

%{
    :type  :text                      # printable character(s) typed
    :text  "s"
}

%{
    :type  :mouse-down                # or :mouse-up
    :x     42                         # panel-local CELLS
    :y     10                         # (pixels on SDL surfaces)
    :ctrl  false :shift false :alt false
}

%{
    :type     :mouse-move             # motion; :dragging true while held
    :x        42
    :y        10
    :dragging false
}

%{
    :type  :wheel                     # mouse scroll
    :dx    0
    :dy    -3                          # notches, negative = up
    :x     42 :y 10                    # position
}