Enum Action 

pub enum Action {
    None,
    Quit,
    Cancel,
    Invoke(CommandInvocation),
    AbsorbPartialChord(KeyChord),
    Insert(String),
    DeleteCharBackward,
    InsertLineEdit(InsertLineEdit),
    EnterMode(ModalState),
    EnterAppend,
    EnterInsertFirstNonBlank,
    EnterAppendEndOfLine,
    DisplayLineDown,
    DisplayLineUp,
    DisplayLineStart,
    DisplayLineEnd,
    EnterBlockVisualInsert,
    EnterBlockVisualAppend,
    OpenLineBelow,
    OpenLineAbove,
    Undo,
    Redo,
    PushDigit(u8),
    EnterVisual(VisualKind),
    ExitVisual,
    ReselectLastVisual,
    EnterSelect(VisualKind),
    SelectOvertype(char),
    ExitSelect,
    ToggleVisualSelect,
    SwapVisualEnds,
    SearchWordUnderCursor(SearchDirection),
    MatchBracket,
    ToggleCaseAtCursor,
    JoinLines {
        with_space: bool,
    },
    FindRepeat {
        reverse: bool,
    },
    CreateFoldFromVisual,
    OpenFoldAtCursor,
    CloseFoldAtCursor,
    ToggleFoldAtCursor,
    OpenAllFolds,
    CloseAllFolds,
    CycleFoldAtCursor,
    CycleFoldsGlobal,
    GotoParentFold,
    DeleteFoldAtCursor,
    OpenFoldsRecursively,
    CloseFoldsRecursively,
    DeleteFoldsRecursively,
    GotoNextFold,
    GotoPrevFold,
    MouseScroll {
        pane: PaneId,
        down: bool,
    },
    MouseGoto {
        pane: PaneId,
        line: u32,
        byte: u32,
        extend: bool,
    },
    ToggleFoldEnable,
    LspSignatureHelpRequest,
    LspCompletionRequest,
    TagStackPop,
    CompletionTrigger,
    CompletionNext,
    CompletionPrev,
    CompletionAccept,
    CompletionCancel,
    CompletionCancelAndExitInsert,
    CompletionToggleDocs,
    CompletionDocsScrollDown,
    CompletionDocsScrollUp,
    CompletionFilterToSource(String),
    CompletionFilterClear,
    CompletionAcceptThenInsert(char),
    InsertRegister(char),
    OpenYankPicker,
    OpenArgPicker,
    ApplyEdit {
        target: BufferId,
        edit: Edit,
        cursor: Option<Position>,
    },
    LspDocumentSymbolRequest,
    LspWorkspaceSymbolRequest(String),
    SelectRegister(Register),
    JumpHistoryBack,
    JumpHistoryForward,
    PaneHistoryBack,
    PaneHistoryForward,
    RedrawScreen,
    WalkMarkHistoryBack,
    WalkMarkHistoryForward,
    StartMacroRecord(char),
    StopMacroRecord,
    PlayMacro(char),
    PlayLastMacro,
    RepeatLastChange,
    OverwriteChar(char),
    ReplaceUndoLast,
    JumpViewport(ViewportPos),
    ScrollCursorTo(ScrollPos),
    HorizontalScroll(HScroll),
    PageDown,
    PageUp,
    HalfPageDown,
    HalfPageUp,
    ScrollLineUp,
    ScrollLineDown,
    SetMark(char),
    JumpToMarkLine(char),
    JumpToMarkExact(char),
    OpenCommandPicker,
    OpenHistoryPicker,
    OpenSearchHistoryPicker,
    EnterCommandLine,
    CommandLineAppend(char),
    CommandLineBackspace,
    CommandLineSubmit,
    CommandLineCancel,
    CommandLineHistoryPrev,
    CommandLineHistoryNext,
    CommandLineToggleExpand,
    SearchLineSubmit,
    SearchLineCancel,
    SearchLineBackspace,
    SearchLineHistoryPrev,
    SearchLineHistoryNext,
    PromptLineSubmit,
    PromptLineCancel,
    Echo(EchoMessage),
    CloseHover,
    PickerAppend(char),
    PickerBackspace,
    PickerSelectNext,
    PickerSelectPrev,
    PickerAccept,
    PickerAcceptInSplit,
    PickerAcceptInVSplit,
    PickerAcceptInTab,
    PickerDescend,
    PickerAscendOrDeleteWord,
    PickerHelp,
    PickerDescendOrSelectNext,
    PickerDelete,
    PickerBulkAccept,
    PickerDismiss,
    TransientTrigger(String),
    TransientToggleFlag(String),
    TransientDismiss,
    PasteAfter,
    PasteBefore,
    PasteText(String),
    CommandLineClear,
    CommandLineDeleteWordBackward,
    CommandLineDescribeUnderCursor,
    CommandLineAppendChord(String),
    TransientKey(String),
    CommandLineCompleteOrAdvance,
    CommandLineCompletePrev,
    CommandLineAcceptCompletion,
    CommandLineDismissCompletion,
    SplitPaneHorizontal,
    SplitPaneVertical,
    ClosePane,
    OnlyPane,
    ToggleZoomPane,
    NavigatePane(PaneDirection),
    NextPane,
    PrevPane,
    NextTab,
    PrevTab,
    GoToTab(u32),
    NewTab,
    NewTabAt(String),
    TerminalSpawn(Option<String>),
    TerminalInput(Vec<u8>),
    EnterTerminalInsert,
    ExitTerminalInsert,
    TerminalScroll(TerminalScrollKind),
    TerminalArmExitChord,
    MovePaneToNewTab,
    CloseTab,
    OnlyTab,
    MoveTab(u32),
    EqualizePanes,
    GrowPaneHeight,
    ShrinkPaneHeight,
    GrowPaneWidth,
    ShrinkPaneWidth,
    HelpDismiss,
    FollowLink,
    OilNavigateUp,
    LspOnTypeFormattingRequest(char),
    LspInsertCompletionRequest,
    EnterSearch(SearchDirection),
    SearchAppend(char),
    SearchBackspace,
    SearchSubmit,
    SearchCancel,
    SearchLineToggleExpand,
    SearchNext,
    SearchPrevious,
    SetViewportHeight(u32),
    EnsureCursorVisible,
    DismissPopup,
    SetTerminalWidth(u16),
    SetCellMetrics {
        row_px: f32,
        col_px: f32,
    },
    AcknowledgeRedraw,
    Chain(Vec<Action>),
}

Variants

None

Quit

Cancel

CG.1: foreground cancellation — flip the armed token AND snap back to Normal. Reached by action:cancel, bound to <C-g> at KeymapLayer::Builtin (emacs keyboard-quit). See Editor::cancel_foreground and docs/dev/architecture/cancellation.md.

Deliberately NOT in action_is_document_mutation: cancel is an escape hatch, so it must keep working on a read-only buffer.

Invoke(CommandInvocation)

Run a CommandInvocation through lattice_grammar::execute().

AbsorbPartialChord(KeyChord)

Slice 8.i.4.a – absorb the captured chord into App::partial_chord, marking that we’re partway through a multi-key sequence the trie hasn’t fully resolved yet. Replaces the Action::SetPending(Pending::After*) flow for prefixes whose only role was “wait for the next key” (g, z, <C-w>, m, ', `, ", q, @). App::apply appends the chord and otherwise no-ops; the next keystroke runs through dispatch_normal with partial_chord as the prefix, hitting the trie’s resolved binding (gd, zo, <C-w>v, …). Parameterised Pending variants (AfterOperator(_), AfterTextObject{_}, AfterFindChar{_}, AfterCtrlX) stay on the SetPending flow for now – 8.i.4.b retires those.

Insert(String)

Insert a string at the cursor (used by Insert mode).

DeleteCharBackward

Delete the byte before the cursor (Insert-mode backspace).

InsertLineEdit(InsertLineEdit)

Insert-mode line editing (readline/vim <C-a>, <C-e>, <C-w>, <C-u>, <C-k>, <C-t>, <C-d>, …) — general across all buffers.

EnterMode(ModalState)

Move into a different modal state (Insert, Normal, …).

EnterAppend

Vim’s a: move cursor one byte right (clamped) and enter Insert.

EnterInsertFirstNonBlank

Vim’s I: move to first non-blank of line and enter Insert.

EnterAppendEndOfLine

Vim’s A: move to end of line and enter Insert.

DisplayLineDown

Vim’s gj: move down one display line (wrap segment).

DisplayLineUp

Vim’s gk: move up one display line (wrap segment).

DisplayLineStart

Vim’s g0: move to the first byte of the current display segment.

DisplayLineEnd

Vim’s g$: move to the last byte of the current display segment.

EnterBlockVisualInsert

Vim’s blockwise-visual I: move cursor to the leftmost column of the block on the top line, enter Insert, and on Esc replicate the typed text to every other line in the block at the same column. Issued only from Visual(Blockwise).

EnterBlockVisualAppend

Vim’s blockwise-visual A: same as Self::EnterBlockVisualInsert but the cursor lands one byte past the rightmost column of the block on each line.

OpenLineBelow

Vim’s o: open a new line below the current line and enter Insert.

OpenLineAbove

Vim’s O: open a new line above the current line and enter Insert.

Undo

Redo

PushDigit(u8)

Append a digit (0-9) to the in-progress count prefix.

EnterVisual(VisualKind)

Enter Visual modal state (v Charwise, V Linewise) anchored at the current cursor.

ExitVisual

Exit Visual to Normal, collapsing the selection.

ReselectLastVisual

Vim’s gv – re-enter Visual with the same anchor / head / kind as the most recently exited Visual selection.

EnterSelect(VisualKind)

SN.3d Select-mode entry (gh / gH / g<C-h>) — anchor a zero-width Select selection of the named kind at the cursor, mirroring Self::EnterVisual. Typing then overtypes it.

SelectOvertype(char)

SN.3d Select mode — a bare printable key replaces the whole selection with this char and drops into Insert (one undo step). The load-bearing new behaviour: see docs/dev/architecture/select-mode.md §3. Emitted only by translate_select’s printable fallthrough; the host handler (do_select_overtype) lands it as a single Edit::replace.

ExitSelect

SN.3d Select-mode <Esc> — collapse the selection to a cursor and drop to Normal (the Select analogue of Self::ExitVisual).

ToggleVisualSelect

SN.3d <C-g> — toggle between Visual(k) and Select(k), preserving the selection geometry (reserved in both modes for this toggle). One handler flips whichever of the two is active.

SwapVisualEnds

Vim’s o in Visual – swap the cursor to the other end of the selection so motions / text objects act on that end.

SearchWordUnderCursor(SearchDirection)

Vim’s * (Forward) and # (Backward) – search for the word under the cursor in the given direction.

MatchBracket

Vim’s % – jump to the matching bracket. Looks at or beyond the cursor on the current line for the first ()[]{} and seeks its pair using a depth-tracking scan.

ToggleCaseAtCursor

Vim’s ~ – toggle the case of the char at the cursor and advance by one byte.

JoinLines

Vim’s J (with-space) and gJ (no-space): join the current line with the next, replacing the joining newline with a single space (or nothing for gJ).

Fields

with_space: bool

FindRepeat

Vim’s ; (no-reverse) and , (reverse): repeat the last f/F/t/T find on the current line.

Fields

reverse: bool

CreateFoldFromVisual

Vim’s zf – create a fold from the current Visual selection.

OpenFoldAtCursor

Vim’s zo – open the fold containing the cursor.

CloseFoldAtCursor

Vim’s zc – close the fold containing the cursor.

ToggleFoldAtCursor

Vim’s za – toggle the fold containing the cursor.

OpenAllFolds

Vim’s zR – open all folds.

CloseAllFolds

Vim’s zM – close all folds.

CycleFoldAtCursor

org-cycle z<Space> / :fold-cycle – cycle the fold under the cursor through FOLDED → CHILDREN → SUBTREE.

CycleFoldsGlobal

org-cycle z<Tab> / :fold-cycle-global – cycle the whole buffer through OVERVIEW → CONTENTS → SHOW-ALL.

GotoParentFold

zp / :fold-goto-parent – move the cursor to the parent heading (one level up the fold hierarchy).

DeleteFoldAtCursor

Vim’s zd – delete the fold containing the cursor.

OpenFoldsRecursively

Vim’s zO – open the folds containing the cursor, recursively.

CloseFoldsRecursively

Vim’s zC – close the folds containing the cursor.

DeleteFoldsRecursively

Vim’s zD – delete the innermost fold at the cursor and its nested folds.

GotoNextFold

Vim’s zj – move cursor to the start of the next fold.

GotoPrevFold

Vim’s zk – move cursor to the end of the previous fold.

MouseScroll

MO.2: the wheel turned over pane.

The pane under the POINTER scrolls, and it does not take focus — the convention vim (mousescroll), Zed and Helix share, and the one that makes a wheel over a reference split usable while you are typing in another.

Fields

pane: PaneId

down: bool

MouseGoto

MO.2: a press or drag resolved to a buffer position in pane.

The renderer has already inverted its own geometry; this carries a buffer coordinate and nothing about the screen. extend is what separates the two gestures: a press moves the cursor and leaves any Visual selection behind, a drag keeps the press’s anchor and extends charwise Visual to here. Unlike scroll, this DOES focus the pane — clicking into a split is how you move to it.

Fields

pane: PaneId

line: u32

byte: u32

extend: bool

ToggleFoldEnable

Vim’s zi – toggle [App::foldenable]. With folds disabled every line renders flat regardless of any closed flag.

LspSignatureHelpRequest

:lsp-signature-help (Phase 4.3). Sends textDocument/signatureHelp to attached servers; the first non-empty response renders into a popup near the cursor. In Insert mode the same request fires automatically when the user types a server-advertised trigger character (commonly ( and ,).

LspCompletionRequest

:complete (Phase 4.2.g, picker-flavoured). Fires textDocument/completion at the cursor; the merged item list opens as a vertico picker (label + kind glyph + detail). Accept replaces the prefix-under-cursor with the item’s insert text. Snippet expansion + lazy completionItem/resolve are queued behind buffer-level Insert-mode completion (which doesn’t exist yet – this is the bridge until that lands).

TagStackPop

<C-t> – pop the tag stack (vim’s tag-stack :pop). Walks back through the LIFO chain of gd / gD / gy / gI drill-downs. Independent of the jump-list <C-o> walk: the stack and the list have different push semantics and can have different lengths.

CompletionTrigger

Insert-mode completion (Phase 4.2.g.1). Manually open the popup at the cursor or refresh an open one. Bound by default to <C-x><C-o> / <C-Space> / smart-tab.

CompletionNext

Move the popup selection down (<C-n> / <Down> / <Tab> cycle).

CompletionPrev

Move the popup selection up (<C-p> / <Up> / <S-Tab> cycle).

CompletionAccept

Accept the focused candidate (<C-y> / <Tab> / <CR>). Splices the candidate’s insert text into the buffer at the popup’s anchor and closes the popup.

CompletionCancel

Close the popup, stay in Insert (<C-e>).

CompletionCancelAndExitInsert

Close the popup AND exit Insert mode (<Esc>). Mirrors vim’s <Esc> semantics with one extra step (drop the popup before the modal switch).

CompletionToggleDocs

Toggle the side documentation popup for the focused candidate (<C-d>, only inside the completion-popup minor mode).

CompletionDocsScrollDown

Scroll the docs side popup forward (<C-f> inside the completion-popup minor mode).

CompletionDocsScrollUp

Scroll the docs side popup backward (<C-b> inside the completion-popup minor mode).

CompletionFilterToSource(String)

Restrict the popup to a single completion source. String is the SourceId (e.g. "gen:buffer-words"). Bound to the popup-mode filter chords introduced in CSM.K2 (<C-b> buffer, <C-o> lsp, <C-f> path, <C-t> tree-sitter, …).

CompletionFilterClear

Clear the active source filter (<C-Space>). Restores the mixed merged candidate list.

CompletionAcceptThenInsert(char)

Insert-mode character key while the completion popup is open (Phase 4.2.g.7 commit-char polish). The App’s handler decides at apply time:

• If the typed char is in the focused candidate’s effective commit-character set (LSP-supplied per-item list union’d with completion.extra_commit_chars), the popup accepts the candidate then inserts the typed char afterward (vim convention: a commit character behaves like “accept and continue typing”).
• Otherwise the typed char flows through plain do_insert_text; the popup refilters against the updated query as if the layer had returned None.

Routing every popup-time char through this single action keeps the input layer ignorant of commit-char state – the App reads it once at apply time.

InsertRegister(char)

YR.5: insert register c’s contents at the cursor.

OpenYankPicker

YR.5: open the yank-ring picker over the current surface.

OpenArgPicker

YR.6: open the picker registered for the :-line argument under the cursor, filling the pick back into that argument.

ApplyEdit

CR.0: host counterpart of lattice_grammar::Effect::ApplyEdit. Applies a mode-computed edit to target (routing through the active-document pipeline when target is the focused buffer, or the peer-buffer registry handle otherwise) and, when cursor is Some, parks the active cursor at that row. handle_effect translates the Effect into this Action and queues it on out.next_actions; the applier arm in handle_action calls Editor::apply_targeted_edit. The generic primitive the diff (and future) modes drive instead of host do_<x> methods.

Fields

target: BufferId

edit: Edit

cursor: Option<Position>

LspDocumentSymbolRequest

:lsp-symbols (Phase 4.2.e). Send textDocument/documentSymbol to every attached server; render the merged outline as a vertico picker. Selecting a row jumps to the symbol’s location.

LspWorkspaceSymbolRequest(String)

:lsp-workspace-symbol [query] (Phase 4.2.f). Send workspace/symbol to every attached server with the user-supplied query string (server-side substring filter). Empty query returns the server’s idea of “everything” (rust-analyzer streams all crate symbols). Picker UX mirrors the document-symbol path.

SelectRegister(Register)

"<reg> prefix – stash the named register for the next operator / paste invocation.

JumpHistoryBack

Vim’s Ctrl-O – step backward in the position history.

JumpHistoryForward

Vim’s Ctrl-I (Tab) – step forward.

PaneHistoryBack

PBH.3: <C-6> – step back through the ACTIVE PANE’s buffer trail. Per-pane and buffer-granular, unlike the global, position-granular JumpHistoryBack.

PaneHistoryForward

PBH.3: <C-7> – step forward through the active pane’s buffer trail.

RedrawScreen

Vim’s Ctrl-L – force a full redraw. Reparses the syntax tree, recomputes folds, clears the visible-highlight cache, and tells the runtime to clear the terminal screen on the next frame. Intended escape hatch for any visual glitch (stale highlights, leftover ANSI escape sequences from a crashed external program, terminal-resize race).

WalkMarkHistoryBack

Vim’s g; – step backward through NamedMark entries in the unified position history.

WalkMarkHistoryForward

Vim’s g, – step forward.

StartMacroRecord(char)

Vim’s q<reg> to start recording into a register; q while recording stops. App handles routing internally.

StopMacroRecord

PlayMacro(char)

Vim’s @<reg> to play. Replays the recorded Action stream.

PlayLastMacro

Vim’s @@ to repeat the most recently played macro.

RepeatLastChange

Vim’s . – re-dispatch the last buffer-mutating invocation from the current cursor.

OverwriteChar(char)

Replace mode: overwrite the char at the cursor with c and advance. Beyond end-of-line, falls back to insert (vim behavior).

ReplaceUndoLast

Backspace within Replace – pop the latest entry from replace_history and restore the original byte (or delete if the overwrite was a line extension).

JumpViewport(ViewportPos)

Jump cursor to a viewport-relative line (vim’s H, M, L).

ScrollCursorTo(ScrollPos)

Adjust scroll so the cursor lands at the viewport top / center / bottom (vim’s zt, zz, zb).

HorizontalScroll(HScroll)

HS.2: manual horizontal scroll (vim z{l,h,L,H,s,e}).

PageDown

Move cursor down / up by one viewport-page (vim’s Ctrl-F / Ctrl-B).

PageUp

HalfPageDown

VM.3j-2: vim’s <C-d> / <C-u> — view and cursor together by scroll lines. Scroll commands, so no operator composes with them.

HalfPageUp

ScrollLineUp

Scroll the viewport one line up (Ctrl-Y) or down (Ctrl-E), nudging the cursor to keep it on-screen.

ScrollLineDown

SetMark(char)

m<letter> – record the cursor at mark <letter>.

JumpToMarkLine(char)

'<letter> – jump to the line of mark <letter> (column = first non-blank).

JumpToMarkExact(char)

`<letter> – jump to the exact position of mark <letter>.

OpenCommandPicker

Open the command picker (:/M-x). On accept: if the chosen command needs a required arg, arm the cmdline; otherwise execute immediately.

OpenHistoryPicker

MB.3: q: – open the command-line history picker over command_history; accept loads the picked command into the : line without executing.

OpenSearchHistoryPicker

MB.5: q/ / q? — open the search-line history picker over search_history; accept loads the picked term into the / search line without executing.

EnterCommandLine

Pressed : in Normal mode – enter command modal with empty buffer.

CommandLineAppend(char)

Append a character to the in-progress command line.

CommandLineBackspace

Delete the last character. If the buffer is empty, leave Command mode.

CommandLineSubmit

Submit the current command line: parse + execute, then leave Command.

CommandLineCancel

Drop the current command line and leave Command modal.

CommandLineHistoryPrev

Walk to an older entry in the command history (Up arrow in Command modal).

CommandLineHistoryNext

Walk to a newer entry, eventually returning to the user’s in-progress line.

CommandLineToggleExpand

MB.2: toggle the : line’s expanded tier-2 mini-buffer band (<C-x><C-e>); collapse returns the edited text to the one-row line for review.

SearchLineSubmit

MB.5a: <CR> on the /·? search line — submit the search pattern. Resolved from search-line-mode’s Insert keymap.

SearchLineCancel

MB.5a: <Esc> / <C-c> on the /·? search line — cancel the search and restore the prior editing buffer.

SearchLineBackspace

<BS> on the /·? line: delete a char, or cancel when empty.

SearchLineHistoryPrev

MB.5b: <C-p> / <Up> on the /·? search line — walk to an older entry in search_history.

SearchLineHistoryNext

MB.5b: <C-n> / <Down> on the /·? search line — walk to a newer entry in search_history.

PromptLineSubmit

<CR> in prompt-line-mode — submit the typed text to the caller-named on_submit_action handler.

PromptLineCancel

<Esc> / <C-c> in prompt-line-mode — cancel, restore the prior editing buffer.

Echo(EchoMessage)

Replace the echo area with a typed message.

CloseHover

Dismiss the hover popup. Mirrors the :HoverClose ex-command for the keymap path. Once a hover is promoted to a help buffer (via the second-K gesture), the standard help-dismissal path (HelpDismiss) closes it instead.

PickerAppend(char)

Append a character to the picker’s query and refilter.

PickerBackspace

Drop the last char from the picker’s query and refilter.

PickerSelectNext

Move the selection cursor down one row (wraps).

PickerSelectPrev

Move the selection cursor up one row (wraps).

PickerAccept

Run the picker’s accept action against the selected candidate and dismiss.

PickerAcceptInSplit

Issue #32 (2026-05-22): <C-s> — accept candidate, opening files in a horizontal split. Non-file outcomes ignore the override.

PickerAcceptInVSplit

<C-v> — accept candidate in a vertical split.

PickerAcceptInTab

<C-t> — accept candidate in a new tab.

PickerDescend

PC.10: <C-l> — go INTO the selected candidate rather than choosing it. The source answers through PickerSourceGenerator::descend; a source with no notion of going deeper (every one but dir-pick today) returns None and this does nothing at all.

PickerAscendOrDeleteWord

PC.10 / PH.1: <C-w> — the peer of Self::PickerDescend, one level up where the source has depth (PickerSourceGenerator::ascend), and the command-line’s delete-word everywhere else.

The shape of Self::PickerDescendOrSelectNext, for the same reason: only the dispatcher can ask which source seated the picker. Ascend is asked FIRST, so a source with depth gets its own notion of “up” rather than a word boundary; a grep pattern, whose source declines, loses a word rather than everything back to a /.

Was <C-h> until PH.1 gave that key to picker help.

PickerHelp

PH.1: <C-h> — close the picker and open its help page. See Editor::do_picker_help for how the page is chosen.

PickerDescendOrSelectNext

PP.5: <Tab> — drill in where the source has depth, select the next row everywhere else.

One action rather than a <Tab> that translate resolves two ways, because translate cannot see which source seated the picker — only the dispatcher can ask it. The fallback is what keeps <Tab> meaning select-next in the pickers that have no notion of depth, which is every one but dir-pick today.

PickerDelete

PD.1: <C-d> — remove the selected row from whatever backs the list.

The source names the verb through PickerSourceSpec::delete_command; a source that names none leaves this doing nothing at all. Never a filesystem delete — see that field’s doc for why that boundary is load-bearing.

PickerBulkAccept

LR.5 (2026-08-11): <C-q> — send every candidate that survived the current query to the picker’s declared bulk outcome, and dismiss. Echoes when the opener declared none.

PickerDismiss

Drop the picker without acting on any candidate.

TransientTrigger(String)

Fire the action for a transient item key press. The string is the item’s label (used as the lookup key in the current transient spec’s groups).

TransientToggleFlag(String)

Toggle a boolean flag in the transient state.

TransientDismiss

Dismiss the transient (close the picker overlay).

PasteAfter

Vim’s p – paste the unnamed register after the cursor (charwise) or below the current line (linewise).

PasteBefore

Vim’s P – paste before cursor / above current line.

PasteText(String)

A bracketed-paste burst from the terminal – the user pressed their terminal’s paste shortcut (Ctrl-Shift-V, Cmd-V, mouse middle-click, …) and the terminal handed us the whole payload in one event. Mode-dependent target: cursor in Insert/Normal/ Visual/Replace, command line in Command, search line in Search. One undo unit, so a single u reverts the entire paste.

CommandLineClear

<C-u> – clear the entire command line.

CommandLineDeleteWordBackward

<C-w> – delete the word to the left of the cursor. (v1: cursor is at end-of-line, so deletes the trailing word.)

CommandLineDescribeUnderCursor

<C-h> – describe the command word / arg under cursor. Hybrid resolution: word-at-cursor describes itself if it resolves to a registered command; else describe the parent command at the relevant arg:<name> anchor.

CommandLineAppendChord(String)

Chord-capture overlay (ArgKind::Chord slot): append one pre-formatted chord token (<C-c>, <Esc>, gg, …) to the cmdline. Translation from the raw KeyEvent happens in input::translate_command_chord_capture.

TransientKey(String)

A transient menu row’s key, already in canonical chord spelling (<CR>, <Tab>, <Space>, g). Emitted by Editor::retarget_claimed_transient_key when the showing spec claims a key the picker would otherwise spend on its own navigation, so a menu can bind <CR> without losing it to “accept the selected row”.

CommandLineCompleteOrAdvance

<Tab> – open completion popup if closed; advance the selected candidate if open.

CommandLineCompletePrev

<S-Tab> – previous candidate when popup is open.

CommandLineAcceptCompletion

<CR> while popup open – replace the prefix with the selected candidate’s text and close the popup.

CommandLineDismissCompletion

<Esc> while popup open – close the popup without touching the command line. (Two-stage Esc: a second Esc then cancels the command line.)

SplitPaneHorizontal

<C-w>s – split the active pane horizontally (new pane below).

SplitPaneVertical

<C-w>v – split the active pane vertically (new pane right).

ClosePane

<C-w>c / <C-w>q – close the active pane.

OnlyPane

<C-w>o / :only / emacs C-x 1 – close every pane except the active one. S3b (2026-06-22).

ToggleZoomPane

ZP.2: <C-w>z / <C-w><C-z> / :zoom-pane – toggle tmux-style zoom on the active pane. The non-destructive counterpart of Self::OnlyPane: the split layout survives and the second toggle restores it verbatim.

NavigatePane(PaneDirection)

<C-w>{h,j,k,l} – move the active pane cardinally.

NextPane

<C-w>w – cycle to the next pane in declaration order.

PrevPane

<C-w>W – cycle to the previous pane.

NextTab

Issue #29 (2026-05-22): vim’s gt — next tab.

PrevTab

Vim’s gT — previous tab.

GoToTab(u32)

Vim’s {N}gt — switch to tab N (1-indexed; clamped).

NewTab

:tabnew — new empty tab (scratch buffer).

NewTabAt(String)

:tabnew <path> — new tab opening path.

TerminalSpawn(Option<String>)

Issue #40 / Terminal-mode T1 (2026-05-22): :terminal [cmd] — spawn a shell (or cmd if given) under a fresh PTY and activate as a new terminal buffer. None ⇒ spawn the user’s shell from terminal.shell (default $SHELL else /bin/sh).

TerminalInput(Vec<u8>)

Terminal-mode T2.a (2026-05-25): write encoded bytes to the active Terminal buffer’s PTY stdin. Emitted by the translate layer when the user is in Terminal-Insert mode on a Terminal buffer and the chord encodes to ANSI via keymap_terminal::key_to_ansi. The host handler (Editor::do_terminal_input) looks up the active buffer’s PtyHandle and forwards. No-op on non-Terminal active buffers (defensive — translate never emits in that state but the handler stays safe).

EnterTerminalInsert

Terminal-mode T2.a: activate terminal-insert-mode on the active Terminal buffer. Emitted by i (later a/ I/A) in Normal-in-terminal. No-op when the active buffer is not a Terminal.

ExitTerminalInsert

Terminal-mode T2.a: deactivate terminal-insert-mode on the active Terminal buffer. Emitted by <C-\><C-n> (and, T2.b, optionally <Esc> when terminal.esc_exits is true).

TerminalScroll(TerminalScrollKind)

Terminal-mode T3 (2026-05-25): re-position the active terminal’s scrollback viewport. Emitted by Normal-in- terminal motions (j/k/<C-d>/<C-u>/gg/G). No-op when the active buffer is not a Terminal.

TerminalArmExitChord

Terminal-mode T2.c (2026-05-25): user pressed <C-\> in Terminal-Insert; arm the two-key exit chord on the active terminal buffer. The next keystroke resolves it (<C-n> exits; anything else sends \x1c + that key to the PTY). Cleared automatically by the ExitTerminalInsert / TerminalInput arms.

MovePaneToNewTab

T4 (2026-05-25): <C-w>T — move the active pane (and its buffer) to a fresh tab. Vim convention. The previous tab loses the pane via the standard close-pane path; the new tab opens with a single pane referencing the same BufferId.

CloseTab

:tabclose — close active tab (no-op when only one tab).

OnlyTab

:tabonly — close every tab except the active one.

MoveTab(u32)

:tabmove [N] — move the active tab to position N (1-indexed). Negative or omitted N is handled by the ex-command parser; the runtime value here is the resolved target index.

EqualizePanes

<C-w>= – reset every split’s ratio to 0.5 (equalize all panes). Issue #28 (2026-05-22).

GrowPaneHeight

<C-w>+ – grow the active pane vertically (nudge the nearest HorizontalSplit ancestor’s ratio).

ShrinkPaneHeight

<C-w>- – shrink the active pane vertically.

GrowPaneWidth

<C-w>> – grow the active pane horizontally (nudge the nearest VerticalSplit ancestor’s ratio).

ShrinkPaneWidth

<C-w>< – shrink the active pane horizontally.

HelpDismiss

Close the active help overlay (Esc / q).

FollowLink

Follow the link under the cursor (<CR>). Resolves the link’s URL scheme and dispatches: command:NAME re-runs :describe-command NAME, key:CHORD re-runs :describe-key CHORD, file:PATH:LINE opens the file at the line. Cursor not on a link is a no-op.

OilNavigateUp

- in any normal-mode context — context-sensitive: • Document / FileTree → open oil for parent dir of current file / hovered entry • Oil buffer → oil.navigate_up()

LspOnTypeFormattingRequest(char)

5.5.G.23.insert: emitted by host-side Editor::do_insert_text after a typed character matches the active document’s onTypeFormatting trigger-char set. App-side handler fires textDocument/onTypeFormatting against the highest-priority server advertising the trigger and applies the returned edits as one undo unit.

LspInsertCompletionRequest

5.5.G.23.insert: emitted by host-side Editor::maybe_refresh_insert_completion_after_edit when the last LSP completion response was isIncomplete and the popup just refiltered against the new query. App-side handler dispatches textDocument/completion through the LspCompletionSource’s async fan-out.

EnterSearch(SearchDirection)

Pressed / (Forward) or ? (Backward) – enter Search modal with empty pattern, remembering origin so cancel restores cursor.

SearchAppend(char)

SearchBackspace

Delete one char from the pattern. If pattern is empty, leave Search.

SearchSubmit

Confirm the pattern: jump to current match (if any) and store it as last_search for n/N repeat.

SearchCancel

Drop the in-progress pattern, restore cursor, leave Search.

SearchLineToggleExpand

MB.5c: toggle the /·? search line’s expanded tier-2 mini-buffer band (<C-x><C-e>).

SearchNext

Repeat the last search in its original direction.

SearchPrevious

Repeat the last search in the opposite direction.

SetViewportHeight(u32)

Set the active pane’s viewport-height (rows). Triggered by the renderer when the window size changes. Mirrors the pre-3c.final App::set_viewport_height shape — clamps to >= 1 and runs ensure_cursor_visible host-side.

EnsureCursorVisible

Auto-scroll so the cursor stays visible in the active pane. Idempotent: no-op when the cursor is already on screen.

DismissPopup

Dismiss the active popup (closes popup_buffer, restores the previous pane focus). No-op when no popup is open.

SetTerminalWidth(u16)

Mirror the TUI’s terminal width into editor state so status-line layout matches what crossterm reported.

SetCellMetrics

IM.7a — the drawing peer’s CELL geometry in pixels: one row’s height and one column’s advance.

The host sizes an inline media block (block_geometry wants a line height and a pane width, both in pixels) and has no other way to learn either — terminal_width is columns and viewport_height is rows. Combined with the pane’s existing column count this yields the pane’s pixel width, so this is two numbers rather than a per-pane channel.

A peer that cannot draw images never sends it, and the host then reserves the provisional row count and reads no image file at all. That is the TUI: it shows alt text, which needs no header read.

Fields

row_px: f32

col_px: f32

AcknowledgeRedraw

Clear pending_redraw after the renderer has cleared the terminal buffer in response to <C-l> (RedrawScreen).

Chain(Vec<Action>)

SN.3c.2b: run a sequence of actions in order. Produced by dispatch_insert for a fall_through binding — [mode_action, native_action] — where the mode’s chord augments a native chord (active-snippet-mode’s <Esc> clears the session, then continues to the builtin <Esc> → exit insert). The renderer’s apply applies each in order. General (not snippet-specific): any future binding that wants to run + continue resolves to a Chain.

Trait Implementations

impl Clone for Action

fn clone(&self) -> Action

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Action

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.