# `MingaEditor.State.RenderCorrelation`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga_editor/state/render_correlation.ex#L1)

Immutable Editor-owned render scheduling, keyframe, and receipt-ordering state.

# `freshness`

```elixir
@type freshness() :: {:fresh, non_neg_integer()} | {:stale, freshness_reason()}
```

# `freshness_reason`

```elixir
@type freshness_reason() ::
  :superseded_intent | :stale_receipt_revision | :stale_sequence
```

# `t`

```elixir
@opaque t()
```

# `timer_delivery`

```elixir
@type timer_delivery() :: {:current, t()} | {:stale, t()}
```

# `timer_identity`

```elixir
@opaque timer_identity()
```

# `accept_receipt`

```elixir
@spec accept_receipt(t(), non_neg_integer(), non_neg_integer()) :: t()
```

Records one accepted asynchronous receipt.

# `accept_synchronous_receipt`

```elixir
@spec accept_synchronous_receipt(t(), non_neg_integer(), non_neg_integer()) :: t()
```

Records a synchronous receipt while preserving monotonic ordering evidence.

# `classify_receipt`

```elixir
@spec classify_receipt(t(), non_neg_integer(), non_neg_integer()) :: freshness()
```

Classifies asynchronous receipt ordering and normalizes legacy revision zero.

# `clear_timer`

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

Clears the scheduled render window while preserving its monotonic identity sequence.

# `deliver`

```elixir
@spec deliver(t(), timer_identity()) :: timer_delivery()
```

Accepts only delivery for the currently scheduled render window.

# `frontend_ready`

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

Marks a newly ready frontend as requiring a renderer-owned keyframe reset.

# `last_receipt_revision`

```elixir
@spec last_receipt_revision(t()) :: non_neg_integer()
```

Returns the last accepted render receipt revision.

# `last_receipt_sequence`

```elixir
@spec last_receipt_sequence(t()) :: non_neg_integer()
```

Returns the last accepted renderer frame sequence.

# `latest_intent_revision`

```elixir
@spec latest_intent_revision(t()) :: non_neg_integer()
```

Returns the latest submitted render intent revision.

# `new`

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

Returns initial render correlation state.

# `next_timer_identity`

```elixir
@spec next_timer_identity(t()) :: timer_identity()
```

Returns the semantic identity for the next render window.

# `request_keyframe`

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

Queues a keyframe request for one handoff to the renderer process.

# `reset`

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

Resets frontend correlation without making an older receipt fresh again.

# `schedule`

```elixir
@spec schedule(t(), timer_identity(), reference()) :: {:scheduled | :coalesced, t()}
```

Admits one render timer or coalesces into the already scheduled timer.

# `scheduled?`

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

Returns whether a render timer currently owns the throttle window.

# `scheduled_identity`

```elixir
@spec scheduled_identity(t()) :: timer_identity() | nil
```

Returns the identity of the currently scheduled render window.

# `submit`

```elixir
@spec submit(t()) :: {t(), pos_integer()}
```

Advances the Editor-owned semantic intent revision.

# `take_keyframe_request`

```elixir
@spec take_keyframe_request(t()) :: {boolean(), t()}
```

Takes a queued keyframe request so the renderer becomes its sole durable owner.

# `timer_reference`

```elixir
@spec timer_reference(t()) :: reference() | nil
```

Returns the current timer reference for cancellation at the Editor boundary.

---

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