A compound state that sends itself a delayed event on entry and finishes when that event arrives.

<state id="s_WAI" initial="s_WAI__waiting">
  <state id="s_WAI__waiting">
    <onentry><send delay="48h" event="statifier_blocks.wait.blk_WAI" id="s_WAI__send"/></onentry>
    <transition event="statifier_blocks.wait.blk_WAI" target="s_WAI__done"/>
  </state>
  <final id="s_WAI__done"/>
</state>

The event name carries the block id, so two waits in the same chart never wake each other. <send> names no target, which under spec 6.2.2 is the running session's own external queue - and a delayed send on that queue is exactly what statifier_oban turns into a durable timer. This type still does not know durable timers exist; it emits an ordinary delayed send and the host's session decides what backs it.

The send id rides the reserved role

The id is minted with Context.role_id/2 under StatifierBlocks.Compiler.Cancels.armed_role/0, the same reserved role core.send mints under, so StatifierBlocks.Compiler.Cancels reaches this send as it reaches any other: a wait left before its delay elapses - by an interrupt, by a losing complete: first lane, by an abandoned group - has its timer cancelled in the enclosing scope's <onexit>. The wait's own state bounds only what the interpreter holds; a delayed send a durable host has already scheduled outlives the state that armed it unless something cancels it.

The duration is compiled, not read out

The stored value is the author's own spelling, so the emitted delay attribute is not simply those bytes: the string is parsed to the expression language's normalised duration and rendered from it. Both steps live in StatifierBlocks.Core.Duration - parse/1 then to_delay/1, exactly the pair core.send calls - which is why the component-to-unit table that used to sit here is now in that module's moduledoc and nowhere else. Two duration tables would be two grammars the day one of them was edited.

The attribute is left unannotated for the reason core.send's emit writes out: ADR-0004 decision 9 annotates an attribute whose value is the author's verbatim, and these bytes are not - a repeated unit accumulates and a fraction expands, so 3h2h emits 5h.

A wait constrains nothing and is constrained by nothing beyond being a step: it declares kinds and leaves consumes and produces to ADR-0003 decision 5's permissive default, since waiting transforms no data.

This block as one line of prose (ADR-0002's 2026-09-07 amendment).

The duration is repeated exactly as the author wrote it rather than spelled out in words: "90m" is what the field holds, what the emitted delay attribute carries, and what an author reading a list back recognizes as the thing they typed.

A block with nothing in the field yet says only what it is - there is no duration to name, and a sentence naming a default the emission does not use would be a line that lies.

iex> StatifierBlocks.Core.Wait.sentence(%{"duration" => "30s"})
"Wait 30s"

iex> StatifierBlocks.Core.Wait.sentence(%{})
"Wait"

timer <duration> for the stored duration, or nil (ADR-0002 amendment H6).

The stored bytes rather than the compiled ones: a 3h2h emits as 5h but the card reads timer 3h2h, showing the author their own spelling, which is what the inspector field beside it holds.

Read with no default, exactly as emit/2 reads it. A wait with no duration stored has nothing to say yet, and a card that filled in the schema's 1h would be asserting a value while the finding validate_config/1 files says the key is required.

iex> StatifierBlocks.Core.Wait.summary(%{"duration" => "30s"})
"timer 30s"

iex> StatifierBlocks.Core.Wait.summary(%{})
nil