# `Cyclium.Mode`
[🔗](https://github.com/Cyclium/cyclium_ex/blob/main/lib/cyclium/mode.ex#L1)

Runtime mode management for cyclium nodes.

Controls whether episodes execute locally (`:full`) or are deferred to
a trigger request table for another node to pick up (`:trigger_only`).

Supports both node-wide mode and per-actor overrides, switchable at
runtime without restart.

## Node-wide mode

    Cyclium.Mode.set(:trigger_only)
    Cyclium.Mode.set(:full)

## Per-actor overrides

    Cyclium.Mode.set_actor_override(:client_health, :trigger_only)
    Cyclium.Mode.clear_actor_override(:client_health)
    Cyclium.Mode.clear_all_overrides()

## Querying

    Cyclium.Mode.current()                      # node-wide mode
    Cyclium.Mode.effective(:client_health)       # per-actor, falls back to node
    Cyclium.Mode.runner_for(:client_health)      # resolved runner module
    Cyclium.Mode.overrides()                     # all active overrides

Reads are ETS-backed for zero-cost lookups in hot paths (actor event handling).

# `child_spec`

Returns a specification to start this module under a supervisor.

See `Supervisor`.

# `clear_actor_override`

```elixir
@spec clear_actor_override(atom()) :: :ok
```

Clears a per-actor override, falling back to node-wide mode.

# `clear_all_overrides`

```elixir
@spec clear_all_overrides() :: :ok
```

Clears all per-actor overrides.

# `current`

```elixir
@spec current() :: :full | :trigger_only | :disabled
```

Returns the node-wide mode.

# `default_runner`

```elixir
@spec default_runner() :: module()
```

Returns the default runner based on node-wide mode (for non-actor contexts).

# `effective`

```elixir
@spec effective(atom()) :: :full | :trigger_only | :disabled
```

Returns the effective mode for a specific actor (override or node-wide).

# `overrides`

```elixir
@spec overrides() :: %{required(atom()) => :full | :trigger_only}
```

Returns all active per-actor overrides.

# `runner_for`

```elixir
@spec runner_for(atom() | String.t()) :: module()
```

Returns the runner module for the given actor based on effective mode.

# `set`

```elixir
@spec set(:full | :trigger_only | :disabled) :: :ok
```

Sets the node-wide mode at runtime.

# `set_actor_override`

```elixir
@spec set_actor_override(atom(), :full | :trigger_only) :: :ok
```

Sets a mode override for a specific actor.

# `start_link`

# `status`

```elixir
@spec status() :: map()
```

Returns a summary of the current mode state.

---

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