A compound state that runs the call in an inner state and finishes at the <final> of whichever outcome it reached.

<state id="s_INV" initial="s_INV__running">
  <state id="s_INV__running">
    <invoke type="myapp:authorize">
      <param expr="order.amount" name="amount"/>
    </invoke>
    <transition event="done.invoke" target="s_INV__o_done">
      <assign expr="_event.data" location="authorization"/>
    </transition>
    <transition event="error.communication.invoke" target="s_blk_PARK"/>
  </state>
  {the on_error child's own subtree}
  <transition event="done.state.s_blk_PARK" target="s_INV__o_error" type="internal"/>
  <final id="s_INV__o_done">
    <onentry><raise event="done.outcome.s_INV.done"/></onentry>
  </final>
  <final id="s_INV__o_error">
    <onentry><raise event="done.outcome.s_INV.error"/></onentry>
  </final>
</state>

Both transitions match by prefix, and neither names an id

The <invoke> carries no id, so the engine mints one, and the two transitions match done.invoke and error.communication.invoke by SCXML's descriptor prefix rule rather than naming the invocation. That is safe for exactly the reason ADR-0004's worked example gives: both transitions sit on the inner state, which is active only while this block's own call is outstanding, so no other invocation's completion can be selected by them.

error.communication.invoke.<invoke_id> is statifier-ex ADR-0068's name - a blessed suffix extension of the error.communication that st-ADR-0051 decision 1 already assigns to this failure - which is what makes the prefix match here and a host chart's existing error.communication handler both correct at once.

An absent on_error still ends the block on error

ADR-0002's amendment of 2026-09-06, section 2: the failure final is emitted whether or not the slot is occupied, because a class is read off a final - the only thing that raises done.outcome.<state id>.error is that final's own onentry, and an outcome whose final is sometimes absent cannot be classed. With the slot empty the failure transition targets the final directly; with it occupied every byte is what it was, the transition targeting the child and the child's own done_event carrying it into the final.

An author who wants the old silence for a particular call has the slot: an occupied on_error is the amendment's section 4 definition of handling, and a handled failure reaches nothing above the block.

Who owns what

Everything here is this block's except one transition: the one leaving the on_error child for the error final is attributed to that child, because "what happens after the parking step finishes" is a fact about the child (decision 5, the same rule Emit.chain/2 follows). The type attribute's value is stamped as coming from invoke_type and the location's from assign_to, so an upstream finding inside either is the author's typo rather than a bug in this type.

error is failure-classed: a call that came back on the error path did not succeed (ADR-0002's amendment of 2026-09-06, section 3).

That is what the outcome has always meant and what the :failure slot_style on on_error has always drawn. The on_error slot is unchanged by the class - amendment section A2's refusal to marry an outcome to a slot stands, and the slot and the outcome share a word here the way core.subchart and core.map have had both for longer.

A step with two outcomes, so produces is :unknown for the reason core.branch declares it: joining the type this block's own call produces with the type its on_error subtree produces is the lattice ADR-0003 decision 4 refuses to build.

consumes is absent - an invoke reads its inputs through params, out of the datamodel, rather than through the type flow.

done and error, in that order - the pair this type has always emitted (ADR-0002's amendment of 2026-09-06, section 1).

Fixed rather than config-derived, and the same pair StatifierBlocks.InvokeStep.outcomes/0 returns for every host type built on it. Until that amendment this type exported no outcomes/1 at all, so StatifierBlocks.BlockType.outcomes/2 answered the default single done while emit/2 minted an error outcome final beside it - a raised event in no summary, which ADR-0004's outcome amendment forbids in its clause 2e.

Declaration order is read by ADR-0004 decision 6's byte determinism, so this list is never sorted.

@spec param_rows(term()) :: {:ok, [{String.t(), String.t()}]} | {:error, String.t()}

The params field's rows, as {name, path} pairs in the order the author wrote them.

One name=path per line, blank lines ignored. Public because the editor and the tests both need the same reading of the flattened field, and two spellings of it would be two chances for them to disagree - the field is provisional (ADR-0002's amendment, D1) and this function is where the provisionality is contained.

One optional slot, on_error, holding what runs when the call fails.

Its arity is zero_or_one because a failure path is one continuation, not a list of them: an author who wants several steps there puts a core.sequence in it, exactly as anywhere else a single child is asked for.