A block document described in words: an outline of its blocks joined by the ways control passes between them, and one line of English per block and per edge (ADR-0016).

iex> alias StatifierBlocks.{Block, Describe, Document, Palette}
iex> root =
...>   Block.new("core.sequence",
...>     id: "root",
...>     slots: %{
...>       "body" => [
...>         Block.new("core.wait", id: "wait", config: %{"duration" => "14d"}),
...>         Block.new("core.send", id: "send", config: %{"event" => "loan.overdue"})
...>       ]
...>     }
...>   )
iex> root |> Document.new() |> Describe.outline(Palette.core(), []) |> Describe.render([])
[
  "Run its steps in order",
  "Wait 14d",
  "Send loan.overdue",
  "Run its steps in order starts with Wait 14d",
  "After Wait 14d (done), Send loan.overdue",
  "Send loan.overdue (done) ends Run its steps in order"
]

Pure, and no model anywhere

outline/3 is a function of the document, the palette and its options, and render/2 of the outline and its options. Neither compiles the document, reads a clock or a random source, starts a process or sends a message of its own, reaches a network or asks a language model, and equal input answers byte-identical output. The one way either can reach another process is not of its own making: a module is made sure of (Code.ensure_loaded?/1) before it is asked - a palette's block-type module by StatifierBlocks.Palette.declares?/3, the host's phrasing module by render/2 - and a module not yet loaded is loaded by the runtime's code server. The only code either runs that this package does not own is the palette's block-type callbacks, the host's phrasing module and, because outline/3 builds the document's view model with StatifierBlocks.ViewModel.build/3, every StatifierBlocks.DocumentValidator in the palette's validators list. Each is held to be a pure function of its arguments by its own contract (StatifierBlocks.BlockType, StatifierBlocks.Describe.Phrasing, StatifierBlocks.DocumentValidator), and by contract only: nothing here enforces it, so a host callback that reads a clock or sends a message does so inside outline/3 or render/2. A validator's findings take no part in the outline: a document describes the same with or without its palette's validators.

Nodes

One StatifierBlocks.Describe.Node per block, every block exactly once, in StatifierBlocks.ViewModel.outline/1's order. A block whose type the palette cannot resolve is described as its placeholder rather than refused.

Edges, from the document's structure

The edges are the block-level flow graph of the package's note docs/block-level-flow-graph.md, read from the document's tree and the block types' declarations; nothing is compiled. Edges are found inside a resolved block of exactly the four types the note works through:

• core.sequence: an :entry edge from its entry to its first child, a :sequence edge from each child to the next, and an :exit edge from the last child to its exit. An empty body is one :entry edge from its entry straight to its exit.
• core.group, core.resumable_group: the same three over the body slot, then one :interrupt edge per handler in the interrupts slot whose outcome is abandon (to the group's exit) or resume (to the group's body, carrying a resumable group's history).
• core.branch: per arm, in slot order, a :branch edge from the branch's entry to the arm's first child - or to the branch's exit for an empty arm - followed by that arm's :sequence edges and the :exit edge from its last child to the branch's exit, where the arms converge. otherwise always has its edge; undecided has one only when it holds a block.

A type is recognised here by the module the palette resolves the block's type name to - StatifierBlocks.Core.Sequence, StatifierBlocks.Core.Group, StatifierBlocks.Core.ResumableGroup or StatifierBlocks.Core.Branch - not by the name itself; under StatifierBlocks.Palette.core/0 the two agree. A palette that registers a host's own module under core.sequence gets that block described by containment only, and one that registers StatifierBlocks.Core.Sequence under a name of the host's own gets a sequence's edges. The timer edge below recognises its sends, rules and awaits the same way.

A child here is one StatifierBlocks.ViewModel.flow_children/1 answers for the slot: a drafts shelf is a node and takes part in no edge.

A :sequence or :exit edge carries every outcome name the source block's type declares, on the one edge. They are the declared outcomes, not a compile's finals: core.await declares received and timed_out whatever its config, so both ride its edge even with no timeout set.

Every other type - core.parallel, core.foreach, core.map, core.subchart, core.invoke, a composite, a host type - is described by containment and its node's fan_label alone, and draws no edge among its children; a block of one still takes part in its parent's edges.

The timer edge, the one edge an event name draws

An event name shared by a send and a handler is not an edge, with one named exception (ADR-0016's amendment of 2026-09-27, ADR-0017 decision 3): a delayed core.send, one whose delay is a duration StatifierBlocks.Core.Duration.duration?/1 accepts, draws one :timer edge to every core.on_event and core.await anywhere in the document whose event is the send's event, the same string. The edge runs from the send to the rule or await, its container is the send's parent, and it carries the event and the delay as the send's config holds it. Only blocks the palette resolved take part, and a block inside a drafts shelf takes part in none. An undelayed send draws none. It is read from config, never compiled, and it is not a transition: it says that the send arms an event the other block waits for.

Timer edges follow every other edge, in the outline's order of their sends and, for one send, of their targets. A document with no delayed send describes exactly as it would without them.

Lines

render/2 answers one line per node, then one per edge, in the outline's orders; ADR-0016 decision 2 gives each default line's words, and a timer edge's line is In <delay>, <event> reaches <target>, the delay written in the words core.send's own sentence uses (24h reads as 24 hours). Every line is non-blank English with no newline, carriage return or tab, and uncapped: a newline, carriage return or tab inside an author's text is written as one space. A block's id never appears in a default line.