statifier 0.0.1 → 0.1.0

data/lib/statifier/effect.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Statifier
+  # The effects executable content answers, ported field for field from the
+  # reference's effect vocabulary (`Statifier.Effect.*` in statifier-ex):
+  # plain data values a host reads, each a `Data` the block runner answers
+  # as a deeply frozen copy, the values it carries included, except the
+  # host's own `caller_context`, which it carries untouched. The reference tags
+  # every effect with an atom beside its struct; here the class is the tag.
+  #
+  # Every effect carries the counters as they stood when it was made
+  # (`macrostep`, `microstep`, `round`), and every effect content makes
+  # carries the content node's `c_index` and its `owner`, the block it ran
+  # in: `{kind: :onentry, state_index:, ordinal:}`,
+  # `{kind: :onexit, state_index:, ordinal:}`, `{kind: :transition,
+  # t_index:}` or `{kind: :finalize, state_index:, invoke_index:}`.
+  #
+  # A value is a predicator value: `nil` is null and `Predicator::UNDEFINED`
+  # is no value at all.
+  #
+  # These are the effects the driver's calls answer a host
+  # ({Driver::Moved}'s `effects`), and what a host's processor is handed.
+  # Beside content's effects are the ones the interpreter's loop answers:
+  # {DatamodelInit}, {BudgetExhausted}, {Done}, the invocation effects
+  # ({Invoke}, {CancelInvoke} and {Autoforward}) and the {Trace} effects.
+  # The driver adds one of its own, {Child}, which carries an effect an
+  # invoked child's run answered.
+  #
+  # Every effect a call's runs answered is among the call's effects, in the
+  # order made, whatever the driver did with it:
+  #
+  # - A {Send} or a {SendDelayed}, by its type. A type the host registered
+  #   is handed to that type's processor (`deliver`), delayed or not. The
+  #   SCXML type, or none, is routed by its target, and a {SendDelayed} of it
+  #   waits as a pending timer until {Statifier.advance} reaches it. A send
+  #   of any other type is refused inside the chart with `error.execution`
+  #   and answers no effect.
+  # - A {Cancel} drops every pending timer under its send id and tells a
+  #   processor holding a delayed send under it, once.
+  # - An {Invoke} of the SCXML type whose content is markup starts a child
+  #   session in process (no content, or content that is not markup or does
+  #   not compile, raises `error.communication`); any other type raises
+  #   `error.execution` inside the chart. A {CancelInvoke} stops the child,
+  #   and an {Autoforward} hands it the event.
+  # - A {Log} is the host's to record; the driver does nothing with it.
+  # - A {Done} says the chart stopped; its pending timers and queued external
+  #   events are discarded.
+  # - An error is never an effect: `error.execution` and
+  #   `error.communication` are events the chart takes from its internal
+  #   queue, seen by a host only in what the chart does next, or, for a
+  #   chart started with `trace: true`, as a {Trace::EventDequeued}. The
+  #   one failure answered as an effect is a {BudgetExhausted}: a macrostep
+  #   spent its round budget, and the driver then queues external events
+  #   without taking them.
+  # - A {Child} carries an effect an invoked child answered, tagged with the
+  #   child's session id; a child's own child's effect is tagged with its
+  #   own.
+  module Effect
+    # A `<log>`: `label` as written, nil when it was not, and `value`, the
+    # evaluated `expr`, nil for a `<log>` without one.
+    Log = ::Data.define(:label, :value, :c_index, :owner, :macrostep, :microstep, :round)
+
+    # A `<send>` with no delay, for the host to deliver now. `event`,
+    # `target` and `type` are the resolved values, nil when the element
+    # wrote neither attribute of the pair; `data` is the payload;
+    # `send_id` is always set, generated when the author named none, and
+    # `id_from_author?` is true when the element wrote `id` or
+    # `idlocation`. `ordinal` is set only for a type the host registered: the
+    # timer counter as this send advanced it.
+    Send = ::Data.define(
+      :event, :target, :type, :data, :send_id, :c_index, :owner, :macrostep, :microstep, :round, :ordinal,
+      :id_from_author?
+    )
+
+    # A `<send>` with a delay, for the host to schedule `delay_ms`
+    # milliseconds from now: every field of {Send}, the delay, an `ordinal`
+    # that is always set, and `caller_context`, the opaque value the host
+    # attached to the step, the same object it attached (never copied or
+    # frozen), nil when it attached none.
+    SendDelayed = ::Data.define(
+      :event, :target, :type, :data, :send_id, :delay_ms, :c_index, :owner, :macrostep, :microstep, :round,
+      :ordinal, :id_from_author?, :caller_context
+    )
+
+    # A `<cancel>`: the host drops the pending delayed send `send_id` names,
+    # if any. `ordinal` and `caller_context` as {SendDelayed}'s.
+    Cancel = ::Data.define(:send_id, :c_index, :owner, :macrostep, :microstep, :round, :ordinal, :caller_context)
+
+    # One write to the datamodel: `location_path` the path written (a String
+    # key or an Integer index per segment, the root first),
+    # `location_source` the location as written, `new_value` and
+    # `prior_value` the values at the path after and before. A write by
+    # content carries its `c_index` and `owner` and a nil `d_index`; a
+    # `<data>` that binds carries its `d_index`, its id as the one-segment
+    # path and the source, and a nil `c_index` and `owner`. The two writes
+    # no content node makes carry a nil `c_index` and `d_index`: an
+    # `<invoke>`'s `idlocation` write, owned by `{kind: :invoke,
+    # state_index:, invoke_index:}`, and each write an empty `<finalize>`
+    # makes, owned by `{kind: :finalize, state_index:, invoke_index:}`.
+    DatamodelChange = ::Data.define(
+      :location_path, :location_source, :new_value, :prior_value, :d_index, :c_index, :owner, :macrostep,
+      :microstep, :round
+    )
+
+    # An `<invoke>` started, for the driver to start its service. `type`
+    # and `src` are the resolved values, nil when the element wrote neither
+    # attribute of the pair; `params` is the `namelist` and `<param>` values
+    # as data (`Predicator::UNDEFINED` for none); `content` the `<content>`
+    # child's data, nil when it has none; `autoforward` the attribute;
+    # `invoke_id` always set, generated when the author named none;
+    # `state_index` the invoking state and `invoke_index` the element's
+    # position among that state's `<invoke>`s; and `caller_context` as
+    # {SendDelayed}'s.
+    Invoke = ::Data.define(
+      :invoke_id, :type, :src, :params, :content, :autoforward, :state_index, :invoke_index, :macrostep,
+      :microstep, :round, :caller_context
+    )
+
+    # A live invocation is cancelled: its invoking state, `state_index`,
+    # exits (or the chart stops) before it answered. `caller_context` as
+    # {SendDelayed}'s.
+    CancelInvoke = ::Data.define(:invoke_id, :state_index, :macrostep, :microstep, :round, :caller_context)
+
+    # An external event forwarded, unchanged, to the live invocation
+    # `invoke_id` names, whose `<invoke>` sets `autoforward`; `state_index`
+    # is its invoking state and `event` the {Event} whole.
+    Autoforward = ::Data.define(:invoke_id, :state_index, :event, :macrostep, :microstep, :round)
+
+    # An effect an invoked child's run answered, as the driver reports it
+    # among a call's effects: `session_id`, the child's session id (its
+    # parent's, a dot and the invoke id), and `effect`, the effect itself. A
+    # child's own child's effect is reported the same way, under its own
+    # session id.
+    Child = ::Data.define(:session_id, :effect)
+
+    # The datamodel as the chart starts, before any `<data>` binds: the
+    # host's values, the system variables over them and every `<data>` id
+    # the host did not supply, declared undefined. Answered first when a
+    # chart starts.
+    DatamodelInit = ::Data.define(:datamodel, :macrostep, :microstep, :round)
+
+    # A macrostep spent its round budget without reaching a stable
+    # configuration: `configuration`, the state indexes active where the
+    # last round left them, in document order; `budget`, the budget spent (a
+    # count, or `:infinity`); and `pending_internal_events`, the {Event}s
+    # still queued, oldest first. The chart keeps running.
+    BudgetExhausted = ::Data.define(:configuration, :budget, :pending_internal_events, :macrostep, :microstep,
+                                    :round)
+
+    # The chart stopped. `donedata` is the top-level final's `<donedata>`
+    # (`Predicator::UNDEFINED` when it has none, or it failed), nil when no
+    # top-level final was active; `donedata_error`, the data of the first
+    # `error.execution` that folding it raised, else nil; and
+    # `configuration`, the state indexes active when it stopped, in document
+    # order. Answered last.
+    Done = ::Data.define(:donedata, :donedata_error, :configuration, :macrostep, :microstep, :round)
+
+    # The trace effects, ported field for field from the reference's
+    # (`Statifier.Effect.Trace.*`): diagnostics the loop answers only for a
+    # state started with `trace: true`, each stamped with the counters as
+    # they stood at the phase it reports. Configurations and index lists
+    # are frozen Arrays in the order the reference gives.
+    module Trace
+      # One selection round's written conditions, in walk order: each a
+      # `{t_index:, outcome:, reason:}` Hash, `outcome` `:enabled`,
+      # `:disabled` or `:error` (with its `reason`). Answered only when the
+      # round evaluated one.
+      CondsEvaluated = ::Data.define(:evaluations, :macrostep, :microstep, :round)
+
+      # A block of content ran: its `owner` (a content owner, or
+      # `{kind: :global_script, index:}` for a `<script>` child of
+      # `<scxml>`) and `c_indexes`, the nodes that ran, the failing one
+      # included.
+      ContentExecuted = ::Data.define(:owner, :c_indexes, :macrostep, :microstep, :round)
+
+      # The chart stopped: {Effect::Done}'s fields, just before it.
+      Done = ::Data.define(:donedata, :donedata_error, :configuration, :macrostep, :microstep, :round)
+
+      # The states a microstep enters, in entry order (`indexes`), and the
+      # `configuration` once they have entered.
+      EntrySet = ::Data.define(:indexes, :configuration, :macrostep, :microstep, :round)
+
+      # An {Event} was taken, `from` `:external` or `:internal`.
+      EventDequeued = ::Data.define(:event, :from, :macrostep, :microstep, :round)
+
+      # The states a microstep exits (or the chart's stop leaves), in exit
+      # order (`indexes`), and the `configuration` once they have left.
+      ExitSet = ::Data.define(:indexes, :configuration, :macrostep, :microstep, :round)
+
+      # The pass over live invocations an external event makes before
+      # selection: the `event`, the invoke ids `finalized` and those
+      # `forwarded` to.
+      FinalizeAutoforward = ::Data.define(:event, :finalized, :forwarded, :macrostep, :microstep, :round)
+
+      # The invoke pass at the end of a stable macrostep: the states it
+      # walked (`state_indexes`, entry order) and the `invoke_ids` it
+      # started.
+      InvokePass = ::Data.define(:state_indexes, :invoke_ids, :macrostep, :microstep, :round)
+
+      # A macrostep reached a stable configuration with the chart running.
+      MacrostepStable = ::Data.define(:configuration, :macrostep, :microstep, :round)
+
+      # A selection: the `t_indexes` it took (empty included) and the
+      # `event` it selected on, nil for an eventless round.
+      TransitionsSelected = ::Data.define(:t_indexes, :event, :macrostep, :microstep, :round)
+    end
+  end
+end

data/lib/statifier/event.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Statifier
+  # An event, as the reference carries one (`Statifier.Event` in
+  # statifier-ex): the one value every queue holds, whoever raised it.
+  #
+  # `name`; `type`, `:external`, `:internal` or `:platform` (provenance,
+  # not routing: an internal and a platform event ride the same internal
+  # queue); `data`, `Predicator::UNDEFINED` for an event with none (nil is
+  # predicator's null); `cause`, the {Cause} of an event the chart raised,
+  # nil for one the host sent; `invokeid`, `origin`, `origintype` and
+  # `sendid`, the specification's `_event` fields, nil when the event
+  # carries none; and `caller_context`, the opaque value a host attached to
+  # an external event, carried as the same object and never read.
+  #
+  # A host meets one in the effects the driver answers and as the event a
+  # processor is handed beside a send.
+  Event = ::Data.define(:name, :type, :data, :cause, :invokeid, :origin, :origintype, :sendid, :caller_context)
+
+  # The event's {Cause} and its constructors.
+  class Event
+    # Why the chart raised an event: `origin`, what raised it, and the
+    # counters as they stood when it was raised. An origin is one of
+    # `{kind: :content, c_index:, owner:}` (a content node, `owner` its
+    # block), `{kind: :state, state_index:}` (a completion, or a failed
+    # `<donedata>` `<content>`), `{kind: :transition, t_index:}` (a failed
+    # condition), `{kind: :data, d_index:}` (a failed `<data>`),
+    # `{kind: :donedata_param, state_index:, param_index:}`,
+    # `{kind: :global_script, index:}`, `{kind: :invoke, state_index:,
+    # invoke_index:}` (an `<invoke>` that failed to start) and
+    # `{kind: :finalize, state_index:, invoke_index:}` (a write of an empty
+    # `<finalize>` that failed).
+    Cause = ::Data.define(:origin, :macrostep, :microstep, :round)
+
+    # The fields an event the chart raised leaves blank.
+    BLANK = { invokeid: nil, origin: nil, origintype: nil, caller_context: nil }.freeze
+
+    # The optional fields of an event the host sends, as they stand when it
+    # names none of them.
+    EXTERNAL = { data: Predicator::UNDEFINED, sendid: nil, **BLANK }.freeze
+
+    # An event the host sent: no cause, and each of {EXTERNAL}'s fields as
+    # `fields` gives it.
+    #
+    # @return [Event]
+    # @raise [ArgumentError] for a field an event does not have
+    def self.external(name, **fields) = new(name:, type: :external, cause: nil, **EXTERNAL, **fields)
+
+    # An event raised by a `<raise>`, or by a send to the internal queue:
+    # `origin` and `origintype` are blank, as the specification requires of
+    # an internal event.
+    #
+    # @return [Event]
+    def self.internal(name, cause, data: Predicator::UNDEFINED, sendid: nil)
+      new(name:, type: :internal, data:, cause:, sendid:, **BLANK)
+    end
+
+    # An event the platform raised: an `error.*` or a `done.state.*`.
+    #
+    # @return [Event]
+    def self.platform(name, cause, data: Predicator::UNDEFINED, sendid: nil)
+      new(name:, type: :platform, data:, cause:, sendid:, **BLANK)
+    end
+
+    private_constant :BLANK, :EXTERNAL
+  end
+end

data/lib/statifier/frozen.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Statifier
+  # How the package freezes the values it builds and answers.
+  #
+  # @api private
+  module Frozen
+    module_function
+
+    # `value`, an effect or an event, as a deeply frozen copy: whatever it
+    # carries that is not already shareable is copied before it is frozen,
+    # so no object the caller passed in (a datamodel value, the stamp's
+    # owner) is frozen in place. The one field that is not copied or frozen
+    # is `caller_context`, the host's own opaque value, which the effect
+    # carries as the same object, whatever it is.
+    def copy(value)
+      return Ractor.make_shareable(value, copy: true) unless value.respond_to?(:caller_context)
+
+      Ractor.make_shareable(value.with(caller_context: nil), copy: true).with(caller_context: value.caller_context)
+    end
+  end
+end

data/lib/statifier/interpreter/blocks.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # What a loop function answered: the {MachineState} it leaves and its
+    # effects, in the order they were made.
+    #
+    # @api private
+    Stepped = ::Data.define(:state, :effects) do
+      # This step followed by `later`: `later`'s state, and both effect
+      # lists in order.
+      def then_step(later) = Stepped.new(state: later.state, effects: effects + later.effects)
+    end
+
+    # What a step runs against a {MachineState}, as the reference runs it
+    # (`Statifier.Interpreter.Content.execute_block/3`, the binding of
+    # `Statifier.Interpreter.Datamodel` and `ExitEntry.donedata/2` in
+    # statifier-ex): a block of content, a `<data>` binding pass and a
+    # final state's `<donedata>`, each read against the state as it stands
+    # and each answering the state it leaves.
+    #
+    # A block runs through {Content.execute_block}: the datamodel it leaves,
+    # its send state and the events it raised are kept, and with tracing on
+    # a {Effect::Trace::ContentExecuted} follows its effects.
+    #
+    # @api private
+    module Blocks
+      module_function
+
+      # One block run, owned by `owner`.
+      #
+      # @return [Stepped]
+      def run_block(state, owner, content)
+        stamp = Content::Stamp.new(owner:, **state.counters, caller_context: state.caller_context)
+        outcome = Content.execute_block(state.context, content, stamp, state.sends)
+        after = kept(state, outcome)
+        trace = traced(after, Effect::Trace::ContentExecuted, owner:, c_indexes: outcome.executed)
+        Stepped.new(state: after, effects: outcome.effects + trace)
+      end
+
+      # The state with what a block left kept: its datamodel, deeply frozen,
+      # its send state and the events it raised, queued.
+      def kept(state, outcome)
+        state.with(datamodel: Ractor.make_shareable(outcome.context.data), sends: outcome.sends)
+             .enqueue(*outcome.raised)
+      end
+
+      # Each of a state's `<onentry>` or `<onexit>` blocks (`kind`), in
+      # document order, owned by its ordinal.
+      #
+      # @return [Stepped]
+      def run_blocks(state, kind, index)
+        state.machine.state(index).public_send(kind).each_with_index
+             .reduce(Stepped.new(state:, effects: [])) do |acc, (block, ordinal)|
+          acc.then_step(run_block(acc.state, { kind:, state_index: index, ordinal: }, block.content))
+        end
+      end
+
+      # The content of the transition at `t_index`; nothing when it is nil.
+      #
+      # @return [Stepped]
+      def run_transition_content(state, t_index)
+        return Stepped.new(state:, effects: []) if t_index.nil?
+
+        run_block(state, { kind: :transition, t_index: }, state.machine.transitions.fetch(t_index).content)
+      end
+
+      # What a `<data>` binding pass answered ({Datamodel::DataBinding}),
+      # kept: each binding a {Effect::DatamodelChange} (its id the one-segment
+      # path), each failure an `error.execution` (origin `{kind: :data,
+      # d_index:}`).
+      #
+      # @return [Stepped]
+      def bound(state, bound)
+        after = bound.failures.reduce(state.with(datamodel: Ractor.make_shareable(bound.data))) do |acc, failure|
+          acc.raise_failure({ kind: :data, d_index: failure.d_index }, failure.reason)
+        end
+        Stepped.new(state: after, effects: bound.changes.map { binding_change(state, _1) })
+      end
+
+      # The effect one binding answers.
+      def binding_change(state, change)
+        Frozen.copy(Effect::DatamodelChange.new(
+                      location_path: [change.id], location_source: change.id, new_value: change.new_value,
+                      prior_value: change.prior_value, d_index: change.d_index, c_index: nil, owner: nil,
+                      **state.counters
+                    ))
+      end
+
+      # `returnDoneEvent`'s data: the final state's `<donedata>` folded to
+      # the value its `done.*` event carries, as `[state, data]`. None, or
+      # an empty one, is no data; a `<content>` body is read as a `<send>`'s
+      # is ({Send.text_data}); a `<content>` `expr` is evaluated, and a
+      # failure raises `error.execution` (origin `{kind: :state,
+      # state_index:}`) and is no data; `<param>`s are evaluated in order
+      # against one context, each failure raising its own `error.execution`
+      # (origin `{kind: :donedata_param, state_index:, param_index:}`) and
+      # dropping that param.
+      def donedata(state, index)
+        donedata = state.machine.state(index).donedata
+        return [state, Predicator::UNDEFINED] if donedata.nil? || (donedata.expr.nil? && donedata.params.empty?)
+        return donedata_params(state, index, donedata.params) if donedata.expr.nil?
+
+        donedata_content(state, index, donedata.expr)
+      end
+
+      # A `<donedata>` `<content>`, as {donedata}.
+      def donedata_content(state, index, expr)
+        return [state, Send.text_data(expr.value)] if expr.is_a?(Machine::Static)
+
+        evaluated = Datamodel.evaluate(state.context, expr)
+        return [state, evaluated.value] if evaluated.ok?
+
+        [state.raise_failure({ kind: :state, state_index: index }, evaluated.error), Predicator::UNDEFINED]
+      end
+
+      # The `<donedata>` `<param>`s, as {donedata}.
+      def donedata_params(state, index, params)
+        context = state.context
+        pairs = []
+        params.each_with_index do |param, param_index|
+          evaluated = Datamodel.evaluate(context, param.expr)
+          next pairs << [param.name, evaluated.value] if evaluated.ok?
+
+          state = state.raise_failure({ kind: :donedata_param, state_index: index, param_index: }, evaluated.error)
+        end
+        [state, Send.params_data(pairs)]
+      end
+
+      # The trace effect `klass` with `fields`, stamped with `state`'s
+      # counters, as a one-element list; empty, and nothing built, when the
+      # state does not trace. Every field is deeply frozen except an {Event},
+      # already a frozen copy, whose host `caller_context` stays the host's
+      # object.
+      def traced(state, klass, **fields)
+        return [] unless state.trace
+
+        [klass.new(**fields.transform_values { _1.is_a?(Event) ? _1 : Ractor.make_shareable(_1) }, **state.counters)]
+      end
+    end
+  end
+end

data/lib/statifier/interpreter/content.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # The block runner and the content nodes it runs, as the reference runs
+    # them (`Statifier.Interpreter.Content` and `Statifier.Machine.Content.*`
+    # in statifier-ex): the specification's `executeContent`.
+    #
+    # A block runs its nodes in document order against one
+    # {Datamodel::Context}: every write a node makes (an `<assign>`, a
+    # `<foreach>`'s item and index, a `<script>`'s program, a `<send>`'s
+    # `idlocation`) is seen by every node after it. The first node that
+    # fails stops the block. The nodes that ran before it keep what they did;
+    # the failing node answers no effect, and its failure becomes one
+    # `error.*` platform event whose origin is that node, the top-level node
+    # of this block when the failure was inside an `<if>` or a `<foreach>`
+    # ({NestedContent} then names the inner node). Other blocks are not
+    # affected: each call is independent.
+    #
+    # What a failing node keeps is the reference's: a leaf that fails (a
+    # `<log>`, an `<assign>`, a `<cancel>`, a `<send>` whose argument
+    # failed, a `<script>` that never compiled) keeps nothing; an `<if>` or
+    # a `<foreach>` keeps what its nodes wrote and raised, though not their
+    # effects; a `<script>` keeps the writes its program made before it
+    # stopped; a refused `<send>` keeps its minted id and its `idlocation`
+    # write.
+    #
+    # A condition of an `<if>` that fails, or answers something other than
+    # true or false, does not stop the block: its branch counts as not
+    # taken, and its `error.execution` is raised once the top-level node that
+    # holds it finishes, after any event the taken branch raised, the order
+    # the reference takes.
+    #
+    # Nothing here moves a queue. The runner answers the events the block
+    # raised, in the order they join the internal queue, beside its effects,
+    # and the step that called it queues them and stamps their counters.
+    #
+    # @api private
+    module Content
+      # Where a block runs: `owner`, the block (`{kind: :onentry,
+      # state_index:, ordinal:}`, `{kind: :onexit, state_index:, ordinal:}`,
+      # `{kind: :transition, t_index:}` or `{kind: :finalize, state_index:,
+      # invoke_index:}`); the counters as they stand while it runs, which no
+      # node moves; and `caller_context`, the opaque value the host attached
+      # to the step (any object, never copied or frozen here), nil for none.
+      Stamp = ::Data.define(:owner, :macrostep, :microstep, :round, :caller_context) do
+        # The fields every effect content makes carries: the owner and the
+        # counters.
+        def fields = { owner:, macrostep:, microstep:, round: }
+
+        # The origin of an event the content node at `c_index` raises.
+        def origin(c_index) = { kind: :content, c_index:, owner: }
+
+        # The {Event::Cause} of an event the content node at `c_index`
+        # raises: its origin and the counters.
+        def cause(c_index) = Event::Cause.new(origin: origin(c_index), macrostep:, microstep:, round:)
+      end
+
+      # What a block answered: the `context` it leaves; `sends`, the
+      # {Send::SendState} it leaves; `effects` in the order the nodes made
+      # them; `raised`, the {Event}s it raised in queue order (an internal
+      # event per `<raise>`, a platform `error.execution` per failure and an
+      # `error.execution` or `error.communication` per refused `<send>`,
+      # each with its {Event::Cause}); and `executed`, the `c_index` of every
+      # top-level node that ran, the failing one included.
+      Outcome = ::Data.define(:context, :sends, :effects, :raised, :executed)
+
+      # A node inside an `<if>` or a `<foreach>` failed: `c_index` names it
+      # and `reason` is its failure.
+      NestedContent = ::Data.define(:c_index, :reason)
+
+      # What a block threads from node to node.
+      Run = ::Data.define(:context, :sends, :effects, :raised, :pending) do
+        # The run with `effect` appended, as a deeply frozen copy
+        # ({Frozen.copy}).
+        def effect(effect) = with(effects: (effects + [Frozen.copy(effect)]).freeze)
+
+        # The run with `events` raised, each a deeply frozen copy.
+        def raise_events(*events) = with(raised: (raised + events.map { Frozen.copy(_1) }).freeze)
+
+        # The run with a condition's failure recorded.
+        def defer(reason) = with(pending: (pending + [reason]).freeze)
+      end
+
+      module_function
+
+      # The function each kind of node runs through.
+      RUNNERS = {
+        Machine::Raise => :raise_event, Machine::Log => :log, Machine::Assign => :assign, Machine::If => :if_node,
+        Machine::Foreach => :foreach, Machine::Script => :script, Machine::Send => :send_node,
+        Machine::Cancel => :cancel
+      }.freeze
+
+      # Runs `content`, a block's nodes, in document order against
+      # `context`, stopping at the first that fails. `sends` is the send
+      # state the block starts with and `stamp` the {Stamp} its effects and
+      # events carry.
+      #
+      # @return [Outcome]
+      def execute_block(context, content, stamp, sends = Send::SendState::INITIAL)
+        run = Run.new(context:, sends:, effects: [].freeze, raised: [].freeze, pending: [].freeze)
+        executed = content.each_with_object([]) do |node, ran|
+          ran << node.c_index
+          run, failed = top_level(run, node, stamp)
+          break ran if failed
+        end
+        Outcome.new(**run.to_h.except(:pending), executed: executed.freeze)
+      end
+
+      # One top-level node run, its recorded condition failures raised
+      # against it, then its own failure: `[run, true]` when it failed.
+      def top_level(run, node, stamp)
+        cause = stamp.cause(node.c_index)
+        run, reason = execute_node(run, node, stamp)
+        run = drain(run, cause)
+        reason.nil? ? [run, false] : [run.raise_events(error_event(reason, cause)), true]
+      end
+
+      # One node run: `[run, nil]` on success, else `[run, reason]` with the
+      # run the block keeps, which never holds the failing node's effects.
+      def execute_node(run, node, stamp)
+        after, reason = __send__(RUNNERS.fetch(node.class), run, node, stamp)
+        reason.nil? ? [after, nil] : [after.with(effects: run.effects), reason]
+      end
+
+      # The pending condition failures raised with `cause`, the top-level
+      # node's, in the order they were recorded.
+      def drain(run, cause)
+        return run if run.pending.empty?
+
+        run.raise_events(*run.pending.map { error_event(_1, cause) }).with(pending: [].freeze)
+      end
+
+      # The event a failure raises: a refused `<send>` raises the event its
+      # kind names, carrying its id; anything else `error.execution`. The
+      # failure, as a predicator value ({Datamodel::ReasonValue.of}), is the
+      # event's data.
+      def error_event(reason, cause)
+        unless reason.is_a?(Send::SendRejected)
+          return Event.platform("error.execution", cause, data: Datamodel::ReasonValue.of(reason))
+        end
+
+        Event.platform("error.#{reason.kind}", cause, data: Datamodel::ReasonValue.of(reason.reason),
+                                                      sendid: reason.send_id)
+      end
+
+      # `<raise>`: one internal event named as written.
+      def raise_event(run, node, stamp)
+        [run.raise_events(Event.internal(node.event, stamp.cause(node.c_index))), nil]
+      end
+
+      # `<log>`: the label and the evaluated `expr`, nil without one, as an
+      # effect.
+      def log(run, node, stamp)
+        evaluated = node.expr.nil? ? Send::NONE : Datamodel.evaluate(run.context, node.expr)
+        return [run, evaluated.error] unless evaluated.ok?
+
+        [run.effect(Effect::Log.new(label: node.label, value: evaluated.value, c_index: node.c_index, **stamp.fields)),
+         nil]
+      end
+
+      # `<assign>`: the value evaluated, then written at the location
+      # ({Datamodel::Location.write}), which never declares a root. A write
+      # that lands answers its change.
+      def assign(run, node, stamp)
+        context = run.context
+        value = Datamodel.evaluate(context, node.value)
+        written = value.ok? ? Datamodel::Location.write(context, node.location, value.value) : value
+        return [run, written.error] unless written.ok?
+
+        [run.with(context: written.context).effect(change(written, node.location, value.value, node.c_index, stamp)),
+         nil]
+      end
+
+      # The change a content node's write made: `written` the
+      # {Datamodel::Written}, `source` the location as written.
+      def change(written, source, new_value, c_index, stamp)
+        Effect::DatamodelChange.new(location_path: written.path, location_source: source, new_value:,
+                                    prior_value: written.prior_value, d_index: nil, c_index:, **stamp.fields)
+      end
+
+      # `<if>`: the first branch whose condition is true runs, an `<else>`
+      # always; a condition that fails or is not a boolean is recorded and
+      # its branch passed over.
+      def if_node(run, node, stamp)
+        node.branches.each do |branch|
+          evaluated = Datamodel.evaluate_cond(run.context, branch.cond)
+          return nested(run, branch.content, stamp) if evaluated.ok? && evaluated.value
+
+          run = run.defer(evaluated.error) unless evaluated.ok?
+        end
+        [run, nil]
+      end
+
+      # A partition or a loop body: each node in order, the first failure
+      # wrapped as a {NestedContent} naming the inner node.
+      def nested(run, content, stamp)
+        content.each do |node|
+          run, reason = execute_node(run, node, stamp)
+          return [run, NestedContent.new(c_index: node.c_index, reason:)] unless reason.nil?
+        end
+        [run, nil]
+      end
+
+      # `<foreach>`, through {Foreach.execute}.
+      def foreach(run, node, stamp) = Foreach.execute(run, node, stamp)
+
+      # `<script>`: the program run through {Datamodel.execute}; its writes
+      # before a failure are kept.
+      def script(run, node, _stamp)
+        executed = Datamodel.execute(run.context, node.program)
+        [run.with(context: run.context.with(data: executed.data)), executed.error]
+      end
+
+      # `<send>`, through {Send.execute_send}.
+      def send_node(run, node, stamp) = sent(run, Send.execute_send(run.context, node, run.sends, stamp))
+
+      # `<cancel>`, through {Send.execute_cancel}.
+      def cancel(run, node, stamp) = sent(run, Send.execute_cancel(run.context, node, run.sends, stamp))
+
+      # What a `<send>` or `<cancel>` answered, kept.
+      def sent(run, sent)
+        kept = run.with(context: sent.context, sends: sent.sends)
+        [sent.effects.reduce(kept) { |acc, effect| acc.effect(effect) }, sent.error]
+      end
+    end
+  end
+end