# `MingaEditor.Frontend.Manager.OutputPressure`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga_editor/frontend/manager/output_pressure.ex#L1)

Bounded frontend output retention and acknowledgement correlation state.

# `control_key`

```elixir
@type control_key() :: non_neg_integer() | {non_neg_integer(), non_neg_integer()}
```

# `stats`

```elixir
@type stats() :: %{
  current_frame_seq: non_neg_integer() | nil,
  replacement_frame_seq: non_neg_integer() | nil,
  current_bytes: non_neg_integer(),
  replacement_bytes: non_neg_integer(),
  retained_bytes: non_neg_integer(),
  control_batches: non_neg_integer(),
  control_bytes: non_neg_integer(),
  total_retained_bytes: non_neg_integer(),
  minimum_ack_generation: non_neg_integer(),
  last_admitted_generation: non_neg_integer(),
  last_admitted_frame_seq: non_neg_integer(),
  last_applied_generation: non_neg_integer(),
  last_applied_frame_seq: non_neg_integer()
}
```

# `t`

```elixir
@type t() :: %MingaEditor.Frontend.Manager.OutputPressure{
  controls: %{required(control_key()) => binary()},
  current: MingaEditor.Frontend.Manager.PendingFrame.t() | nil,
  last_admitted_frame_seq: non_neg_integer(),
  last_admitted_generation: non_neg_integer(),
  last_applied_frame_seq: non_neg_integer(),
  last_applied_generation: non_neg_integer(),
  minimum_ack_generation: non_neg_integer(),
  replacement: MingaEditor.Frontend.Manager.PendingFrame.t() | nil,
  retry_token: reference() | nil,
  unwritable_since: integer() | nil
}
```

# `acknowledge`

```elixir
@spec acknowledge(t(), non_neg_integer(), non_neg_integer()) ::
  {:accepted, t()} | :stale
```

Accepts a correlated acknowledgement or rejects stale generation and sequence values.

# `admitted`

```elixir
@spec admitted(t()) :: {MingaEditor.Frontend.Manager.PendingFrame.t(), t()}
```

Advances after the current frame is admitted and returns the admitted frame.

# `consume_retry`

```elixir
@spec consume_retry(t(), reference()) :: {:ok, t()} | :stale
```

Consumes the matching retry token and rejects stale timer messages.

# `control_admitted`

```elixir
@spec control_admitted(t(), control_key()) :: t()
```

Drops one admitted control batch.

# `controls_pending?`

```elixir
@spec controls_pending?(t()) :: boolean()
```

Returns whether any control batch is retained.

# `enqueue`

```elixir
@spec enqueue(t(), MingaEditor.Frontend.Manager.PendingFrame.t()) ::
  {:attempt, t()} | {:coalesced, t()}
```

Retains a first unwritable frame or replaces the single coalesced successor.

# `expired?`

```elixir
@spec expired?(t(), integer(), non_neg_integer()) :: boolean()
```

Returns whether the current unwritable interval reached its failure budget.

# `mark_unwritable`

```elixir
@spec mark_unwritable(t(), integer(), reference()) :: t()
```

Marks the current admission unwritable and correlates one retry token.

# `new`

```elixir
@spec new() :: t()
```

Returns empty pressure state.

# `next_control`

```elixir
@spec next_control(t()) :: {control_key(), binary()} | nil
```

Returns the next retained control batch in deterministic resource-key order.

# `require_recovery`

```elixir
@spec require_recovery(t(), MingaEditor.Frontend.Manager.PendingFrame.t()) :: t()
```

Drops retained output and requires acknowledgements from the next generation.

# `retain_control`

```elixir
@spec retain_control(t(), control_key(), binary()) :: t()
```

Coalesces the latest unwritable out-of-band control batch by resource key.

# `retry_scheduled?`

```elixir
@spec retry_scheduled?(t()) :: boolean()
```

Returns whether a retry timer is already correlated.

# `settled`

```elixir
@spec settled(t()) :: t()
```

Clears the unwritable interval after every retained batch drains.

# `stats`

```elixir
@spec stats(t()) :: stats()
```

Returns bounded retained-byte and acknowledgement diagnostics.

---

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