# `MingaEditor.Handlers.EffectHandler`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga_editor/handlers/effect_handler.ex#L1)

Interprets side-effect instructions returned by event handlers.

Agent event handlers return `{new_state, [effect()]}` from their callbacks.
This module walks the effect list and applies each one, keeping handlers
testable as pure `state -> {state, effects}` functions.

# `effect`

```elixir
@type effect() ::
  :render
  | :render_now
  | {:render, delay_ms :: pos_integer()}
  | {:open_file, String.t()}
  | {:switch_buffer, pid()}
  | {:set_status, String.t()}
  | :clear_status
  | {:push_overlay, module()}
  | {:pop_overlay, module()}
  | {:log_message, String.t()}
  | {:log_warning, String.t()}
  | {:log, atom(), atom(), String.t()}
  | :sync_agent_buffer
  | {:update_tab_label, String.t()}
  | {:monitor, pid()}
  | :stop_spinner
  | :start_spinner
  | {:rebuild_agent_session, MingaEditor.State.Tab.t()}
  | {:request_semantic_tokens}
  | {:send_after, term(), non_neg_integer()}
  | {:conceal_spans, pid(), [map()]}
  | {:prettify_symbols, pid()}
  | {:update_agent_styled_cache}
  | {:evict_parser_trees_timer}
  | {:refresh_tool_picker}
  | {:save_session_async, term(), keyword()}
  | {:compact_session, pid()}
  | {:restart_session_timer}
  | {:cancel_session_timer}
  | {:recover_swap_entries, [Minga.Session.swap_entry()]}
  | {:restore_session, keyword()}
  | {:request_code_lens}
  | {:request_inlay_hints}
  | {:save_session_deferred}
  | {:schedule_file_tree_refresh, non_neg_integer()}
  | {:handle_git_remote_result, reference(), term()}
```

Side effects returned by event handlers and pure state functions.

* `:render` — schedule a debounced render
* `{:render, delay_ms}` — schedule render with custom delay
* `{:open_file, path}` — open a file in a new or existing buffer
* `{:switch_buffer, pid}` — make this buffer active
* `{:set_status, msg}` — show a status message in the minibuffer
* `:clear_status` — clear the status message
* `{:push_overlay, module}` — push an overlay handler onto the focus stack
* `{:pop_overlay, module}` — pop an overlay handler from the focus stack
* `{:log_message, msg}` — log to *Messages* buffer
* `{:log_warning, msg}` — log to both *Messages* and *Warnings* (warning level)
* `{:log, subsystem, level, msg}` — log via Minga.Log
* `:sync_agent_buffer` — sync agent buffer with session output
* `{:update_tab_label, label}` — update active tab label
* `{:monitor, pid}` — monitor a buffer process
* `{:stop_spinner}` — cancel outgoing agent spinner timer
* `{:start_spinner}` — start incoming agent spinner timer
* `{:rebuild_agent_session, tab}` — rebuild agent state from session process
* `{:request_semantic_tokens}` — request semantic tokens from LSP
* `{:send_after, msg, delay}` — schedule a self-send after delay
* `{:conceal_spans, pid, spans}` — apply conceal spans to a buffer
* `{:prettify_symbols, pid}` — run prettify symbols on a buffer
* `{:update_agent_styled_cache}` — re-cache GUI styled messages
* `{:evict_parser_trees_timer}` — schedule next eviction check
* `{:refresh_tool_picker}` — refresh tool picker if open
* `{:save_session_async, snapshot, opts}` — persist session in background
* `{:restart_session_timer}` — restart the periodic session timer
* `{:cancel_session_timer}` — cancel the periodic session timer
* `{:recover_swap_entries, entries}` — recover swap file entries
* `{:restore_session, opts}` — restore session from disk
* `{:request_code_lens}` — request fresh code lenses from LSP
* `{:request_inlay_hints}` — request fresh inlay hints from LSP
* `:render_now` — render immediately after a handler updates state
* `{:save_session_deferred}` — send :save_session to self
* `{:schedule_file_tree_refresh, delay}` — debounce one filesystem tree refresh
* `{:handle_git_remote_result, ref, result}` — process git remote result

# `apply_effects`

```elixir
@spec apply_effects(MingaEditor.State.t(), [effect()]) :: MingaEditor.State.t()
```

Applies a list of effects to the editor state.

Agent event handlers return `{new_state, [effect()]}` from their callbacks.
The Editor interprets each effect. This keeps handlers testable as
pure `state -> {state, effects}` functions.

---

*Consult [api-reference.md](api-reference.md) for complete listing*