# `MingaEditor.RenderModel.Window.ResidentStore`
[🔗](https://github.com/jsmestad/minga/blob/main/lib/minga_editor/render_model/window/resident_store.ex#L1)

Persistent indexed resident-row sequence.

Rows are held in an implicit chunk treap. Rank split/concatenation copy only
the search paths and the at-most-64-row boundary chunks; untouched prefix and
suffix subtrees are shared verbatim. Buffer positions are therefore not
stored eagerly in suffix payloads: `payload_at/2` and `payload_range/3`
project positional metadata when a caller actually reads a row.

# `entry`

```elixir
@type entry() :: %{id: term(), content_hash: non_neg_integer(), payload: term()}
```

# `t`

```elixir
@type t() :: %MingaEditor.RenderModel.Window.ResidentStore{
  digest: Minga.RenderModel.Window.ContentDigest.t(),
  root: tree(),
  size: non_neg_integer(),
  work: work()
}
```

# `tree`

```elixir
@type tree() ::
  nil | {:chunk, non_neg_integer(), pos_integer(), tree(), tuple(), tree()}
```

# `work`

```elixir
@type work() :: %{
  rows_visited: non_neg_integer(),
  rows_copied: non_neg_integer(),
  rows_emitted: non_neg_integer(),
  chunks_touched: non_neg_integer()
}
```

# `delete_at`

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

# `digest`

```elixir
@spec digest(t()) :: Minga.RenderModel.Window.ContentDigest.t()
```

# `empty?`

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

# `entries`

```elixir
@spec entries(t()) :: [entry()]
```

Materializes all entries. Reserved for hydration/debug/oracle paths.

# `entry`

```elixir
@spec entry(term(), non_neg_integer(), term()) :: entry()
```

# `entry_at`

```elixir
@spec entry_at(t(), non_neg_integer()) :: {:ok, entry()} | :error
```

# `from_entries`

```elixir
@spec from_entries([entry()]) :: t()
```

# `insert_at`

```elixir
@spec insert_at(t(), non_neg_integer(), entry()) :: t()
```

# `new`

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

# `payload_at`

```elixir
@spec payload_at(t(), non_neg_integer()) :: {:ok, term()} | :error
```

# `payload_range`

```elixir
@spec payload_range(t(), non_neg_integer(), non_neg_integer()) :: [term()]
```

# `payloads`

```elixir
@spec payloads(t()) :: [term()]
```

Materializes all projected payloads. Reserved for explicit full hydration.

# `rebuild`

```elixir
@spec rebuild(t(), MapSet.t(non_neg_integer()), (non_neg_integer() -> entry())) :: t()
```

# `replace_at`

```elixir
@spec replace_at(t(), non_neg_integer(), entry()) :: t()
```

# `replace_range`

```elixir
@spec replace_range(t(), non_neg_integer(), non_neg_integer(), [entry()]) :: t()
```

Persistent rank splice. Only boundary/search chunks are copied.

# `size`

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

# `work`

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

---

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