Struct DispatchOutcome 

pub struct DispatchOutcome {
    pub write_failed: bool,
    pub renderer_signals: Vec<RendererSignal>,
    pub consumed: bool,
    pub effects: Vec<Effect>,
    pub next_actions: Vec<Action>,
    pub declined: bool,
}

Result of Editor::dispatch. Carries the renderer-side side-effects the caller must surface after the host-side state mutation completes.

Today the TUI’s runtime loop repaints every tick, so most dispatches return an empty renderer_signals. The Vec shape lets host helpers append signals from nested call sites without having to thread them up the call stack – mirrors how lattice_grammar::Effect::Many already aggregates inner effects.

Fields

write_failed: bool

CD.3c: a WriteToFile in the effects being applied did not land. Transient: [apply_effect_host] clears it as soon as it has stopped the batch, so it never reaches a caller.

renderer_signals: Vec<RendererSignal>

Host-to-renderer side-effects. Empty for the vast majority of dispatches (state changed; renderer just refreshes its per-frame caches on the next tick).

consumed: bool

Set when the host fully handled the action and the renderer’s post-dispatch match action { ... } body should bail. Used by the read-only-help guard (5.5.D) to short-circuit App’s match from inside Editor::dispatch. Disappears once 5.5.G collapses App’s match entirely; until then it’s the coordination channel that keeps the two halves in lockstep.

effects: Vec<Effect>

5.5.G.23: deferred effects the host produced (typically from Action::Invoke -> Editor::run_invocation host-side) that the renderer still needs to apply through its App-side effect tail (e.g. Effect::OpenBuffer -> do_edit, Effect::SaveBuffer -> do_write). The host has already called editor.handle_effect(effect.clone()) for every effect in this list, so the App-side consumer must NOT re-run handle_effect when draining; it should only run its renderer-coupled match arms (i.e. call apply_effect_app_arms).

Empty for the vast majority of dispatches (host-only arms emit no effects). The Vec shape lets nested host helpers (run_oil_invocation, etc.) append without threading the outcome up the call stack.

next_actions: Vec<Action>

5.5.G.23.insert: deferred Actions the host wants the renderer to re-dispatch through its full apply loop. Used when the host-side handler for an Action needs to fire follow-up Actions whose handlers still live App-side (typically LSP autopilots like LspOnTypeFormattingRequest / LspInsertCompletionRequest that depend on spawn_on_lsp_runtime + BatchingSink + AsyncCompletionOutcome — App-resident plumbing). The renderer drains this list via self.apply(action), so each follow-up runs through the same dispatch loop (macro-recording capture, partial-chord clear, etc.) as user-driven actions.

Empty for every host arm that doesn’t need an App-side follow-up. The Vec shape lets host helpers append without threading the outcome up the call stack.

declined: bool

AP.0.2: set when a grammar action returned Effect::Declined — the chord’s resolved binding did nothing and the dispatcher should re-resolve the chord without that action’s keymap layer (fall through). Read + reset by dispatch_chord.

Implementations

impl DispatchOutcome

pub fn take_write_failure(&mut self) -> bool

Drain other into self: append signals, effects, and next_actions; OR the consumed flag. Used by picker-accept paths that delegate to apply_picker_outcome and need to forward the full outcome upward. CD.3c: set by a WriteToFile that did not land, and read (and cleared) by the effect flattener, which then applies nothing more from the batch the write was in. See [apply_effect_host].

pub fn merge(&mut self, other: DispatchOutcome)

Trait Implementations

impl Debug for DispatchOutcome

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

Formats the value using the given formatter.

impl Default for DispatchOutcome

fn default() -> DispatchOutcome

Returns the “default value” for a type.