MingaEditor.Renderer.State (Minga v0.1.0)

Copy Markdown View Source

Complete long-lived state owned by MingaEditor.Renderer.Server.

Renderer caches, font registration, frontend acknowledgement state, resident windows, observed buffer monitors, and coalesced frame credit live here. Public transitions centralize lifecycle cleanup so window close, buffer replacement, reset, and exact monitor :DOWN all discard the same state.

Summary

Types

editor_ref()
frame_credit()
frame_successor()
generation_reserver()
pipeline()
t()

Functions

accept_intent(state, intent)
acknowledge_text_presentations(state, output)

Retains immutable text presentations from one acknowledged frontend frame.

advance_credit(state)
await_ack(state, lease)
awaiting_lease(state)
clear_rejection(state)
coalesce_frame(state, attempt)
consume_adaptation(state, ack_lease)
consume_render_token(state, token)
drop_buffer_down(state, ref, buffer)
latest_successor(state, fallback)
new(opts)
prepare_highlights(state, intent)

Prepares derived highlights from this attempt's immutable sources.

receive_submission(state, submission)

Installs presentation updates before any submission can be rejected or coalesced.

reconcile_windows(state, intent)
record_adaptation(state, generation, frame_seq, descriptor, adapted)
rendering?(state)
reserve_recovery_generation(state)

Reserves a fresh generation from the live frontend connection owner.

reset_connection(state, recovery_generation, reason \\ :reset_required)

Resets frontend state after the transport connection itself was abandoned.

reset_frontend(state, recovery_generation, reason \\ :reset_required)
retry_scheduled_frame(state, token)
schedule_frame(state, attempt, token)
terminal_failure(state)
terminal_failure(state, last_good_frame_seq, reason)
text_interaction_reader(state)

Returns the protected read capability owned by this renderer generation.

text_presentation_state(state, window_id, presentation_id, atom)

Applies an ordered frontend visibility lifecycle transition.

Types

editor_ref()

@type editor_ref() :: pid() | atom() | nil

frame_credit()

@type frame_credit() ::
  :idle
  | {:scheduled, reference(), MingaEditor.Renderer.FrameAttempt.t(),
     non_neg_integer(), frame_successor() | nil}
  | {:awaiting_ack, MingaEditor.Renderer.AckLease.t(), frame_successor() | nil}

frame_successor()

@type frame_successor() :: MingaEditor.Renderer.FrameAttempt.t()

generation_reserver()

@type generation_reserver() :: (-> pos_integer())

pipeline()

@type pipeline() :: (MingaEditor.RenderPipeline.Input.t() ->
                 MingaEditor.RenderPipeline.Input.t())

t()

@type t() :: %MingaEditor.Renderer.State{
  ack_timeout_ms: pos_integer(),
  caches: MingaEditor.Renderer.Caches.t(),
  editor_pid: editor_ref(),
  font_registry: MingaEditor.UI.FontRegistry.t(),
  frame_credit: frame_credit(),
  generation_reserver: generation_reserver() | nil,
  highlight_cache: MingaEditor.Renderer.HighlightCache.t(),
  highlights: MingaEditor.Renderer.Submission.highlights(),
  message_store: MingaEditor.UI.Panel.MessageStore.t() | nil,
  observed_buffers: MingaEditor.Renderer.ObservedBuffers.t(),
  pipeline: pipeline(),
  rejection_state: MingaEditor.Renderer.RejectionState.t(),
  require_ack?: boolean(),
  resident_windows: %{
    optional(MingaEditor.Window.id()) =>
      MingaEditor.Renderer.ResidentWindowState.t()
  },
  semantic_tokens: MingaEditor.Renderer.Submission.semantic_tokens(),
  text_presentations: MingaEditor.Renderer.TextPresentations.t()
}

Functions

accept_intent(state, intent)

@spec accept_intent(t(), MingaEditor.RenderPipeline.Intent.t()) ::
  {:accepted, t()} | {:blocked, t()}

acknowledge_text_presentations(state, output)

@spec acknowledge_text_presentations(t(), MingaEditor.RenderPipeline.Input.t()) :: t()

Retains immutable text presentations from one acknowledged frontend frame.

advance_credit(state)

@spec advance_credit(t()) ::
  {:idle, t()} | {:schedule, t(), MingaEditor.Renderer.FrameAttempt.t()}

await_ack(state, lease)

@spec await_ack(t(), MingaEditor.Renderer.AckLease.t()) :: t()

awaiting_lease(state)

@spec awaiting_lease(t()) :: MingaEditor.Renderer.AckLease.t() | nil

clear_rejection(state)

@spec clear_rejection(t()) :: t()

coalesce_frame(state, attempt)

@spec coalesce_frame(t(), MingaEditor.Renderer.FrameAttempt.t()) ::
  :idle | {:coalesced, t(), MingaEditor.Renderer.FrameAttempt.t() | nil}

consume_adaptation(state, ack_lease)

@spec consume_adaptation(t(), MingaEditor.Renderer.AckLease.t()) ::
  {:ok, t(), MingaEditor.RenderPipeline.Intent.t()} | :error

consume_render_token(state, token)

@spec consume_render_token(t(), reference()) ::
  {:ok, t(), MingaEditor.Renderer.FrameAttempt.t(), non_neg_integer()} | :stale

drop_buffer_down(state, ref, buffer)

@spec drop_buffer_down(t(), reference(), pid()) :: {t(), boolean()}

latest_successor(state, fallback)

@spec latest_successor(t(), MingaEditor.Renderer.FrameAttempt.t()) ::
  MingaEditor.Renderer.FrameAttempt.t()

new(opts)

@spec new(keyword()) :: t()

prepare_highlights(state, intent)

@spec prepare_highlights(t(), MingaEditor.RenderPipeline.Intent.t()) ::
  {t(), MingaEditor.Renderer.HighlightCache.highlights()}

Prepares derived highlights from this attempt's immutable sources.

receive_submission(state, submission)

@spec receive_submission(t(), MingaEditor.Renderer.Submission.t()) ::
  {t(), MingaEditor.RenderPipeline.Intent.t()}

Installs presentation updates before any submission can be rejected or coalesced.

reconcile_windows(state, intent)

@spec reconcile_windows(t(), MingaEditor.RenderPipeline.Intent.t()) :: t()

record_adaptation(state, generation, frame_seq, descriptor, adapted)

@spec record_adaptation(
  t(),
  non_neg_integer(),
  non_neg_integer(),
  MingaEditor.Frontend.ResourcePolicy.adaptation_descriptor(),
  MingaEditor.RenderPipeline.Intent.t()
) :: {:ok, t()} | {:error, t()}

rendering?(state)

@spec rendering?(t()) :: boolean()

reserve_recovery_generation(state)

@spec reserve_recovery_generation(t()) :: pos_integer()

Reserves a fresh generation from the live frontend connection owner.

reset_connection(state, recovery_generation, reason \\ :reset_required)

@spec reset_connection(
  t(),
  non_neg_integer(),
  MingaEditor.Renderer.ResidentWindowState.hydration_reason()
) :: t()

Resets frontend state after the transport connection itself was abandoned.

reset_frontend(state, recovery_generation, reason \\ :reset_required)

@spec reset_frontend(
  t(),
  non_neg_integer(),
  MingaEditor.Renderer.ResidentWindowState.hydration_reason()
) :: t()

retry_scheduled_frame(state, token)

@spec retry_scheduled_frame(t(), reference()) :: t()

schedule_frame(state, attempt, token)

@spec schedule_frame(t(), MingaEditor.Renderer.FrameAttempt.t(), reference()) :: t()

terminal_failure(state)

@spec terminal_failure(t()) :: MingaEditor.Renderer.RejectionState.terminal() | nil

terminal_failure(state, last_good_frame_seq, reason)

@spec terminal_failure(t(), non_neg_integer(), atom()) :: t()

text_interaction_reader(state)

@spec text_interaction_reader(t()) ::
  MingaEditor.Renderer.TextInteractionIndex.Reader.t()

Returns the protected read capability owned by this renderer generation.

text_presentation_state(state, window_id, presentation_id, atom)

@spec text_presentation_state(
  t(),
  MingaEditor.Window.id(),
  non_neg_integer(),
  :active | :discarded
) ::
  {:ok, t()} | {:error, :unknown, t()}

Applies an ordered frontend visibility lifecycle transition.