statifier 0.0.1 → 0.1.0

data/lib/statifier/interpreter/name_match.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # The event-name matcher of the specification's section 3.13 (Appendix
+    # D's `nameMatch`), as the reference matches.
+    #
+    # A descriptor matches an event name when its tokens are a prefix of the
+    # event's tokens on token boundaries: `error` matches `error.execution`
+    # and not `errors.execution`. A trailing `*` token, or the empty token a
+    # trailing dot leaves, is dropped before the prefix test, so `*` matches
+    # every event, `foo.*` matches `foo` and `foo.bar`, and `foo.` matches as
+    # `foo` does. A `*` anywhere else is matched as written.
+    #
+    # A transition's descriptors arrive split on their dots by the compiler
+    # (`Machine::Transition#events`), so both sides here are token lists; an
+    # event name is split once per selection round by {tokenize}.
+    #
+    # @api private
+    module NameMatch
+      module_function
+
+      # Whether any of `descriptors` (a list of token lists, one per
+      # descriptor of a transition's `event` attribute) matches the event
+      # whose name is `event_tokens`.
+      def name_match?(descriptors, event_tokens) = descriptors.any? { descriptor_match?(_1, event_tokens) }
+
+      # Whether one descriptor's tokens, normalized, are a prefix of
+      # `event_tokens`.
+      def descriptor_match?(descriptor, event_tokens)
+        normalized = normalize(descriptor)
+        event_tokens.take(normalized.size) == normalized
+      end
+
+      # The descriptor with a trailing `*` or empty token dropped.
+      def normalize(descriptor) = ["*", ""].include?(descriptor.last) ? descriptor[0...-1] : descriptor
+
+      # An event name split on its dots, every empty part kept: the empty
+      # name is one empty token, as the reference splits it.
+      def tokenize(name) = name.empty? ? [""] : name.split(".", -1)
+    end
+  end
+end

data/lib/statifier/interpreter/selection.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # Transition selection, ported function for function from the
+    # pseudocode as the reference ports it; each function names the one it
+    # ports.
+    #
+    # The domain half ({find_lcca}, {get_effective_target_states},
+    # {get_transition_domain} and {compute_exit_set}) answers which states a
+    # transition leaves; {ExitEntry} uses it too. The selection half
+    # ({condition_match}, {select_transitions},
+    # {select_eventless_transitions} and {remove_conflicting_transitions})
+    # answers which transitions fire.
+    #
+    # The two selection walks evaluate conditions against one context built
+    # per round from the datamodel the caller passes and the snapshot's
+    # configuration. A condition that fails, or answers something other than
+    # true or false, leaves its transition unselected: the walks answer,
+    # beside the transitions, every written condition they evaluated and
+    # how it came out ({Selected}), in walk order, and the caller raises an
+    # `error.execution` for each that failed.
+    #
+    # @api private
+    module Selection
+      # What a selection round answered: `transitions`, the transitions that
+      # fire, in the order the round took them; and `evaluations`, an
+      # {Evaluation} per written condition the round evaluated, in walk
+      # order.
+      Selected = ::Data.define(:transitions, :evaluations)
+
+      # One written condition evaluated: the transition's `t_index`; its
+      # `outcome`, `:enabled`, `:disabled` or `:error`; and `reason`, the
+      # failure an `:error` carries, else nil. A transition with no
+      # condition is never recorded.
+      Evaluation = ::Data.define(:t_index, :outcome, :reason)
+
+      module_function
+
+      # `findLCCA`: the least common compound ancestor of `indexes`
+      # ({Machine#lcca}). A parallel is never one.
+      def find_lcca(machine, indexes) = machine.lcca(indexes)
+
+      # `getEffectiveTargetStates`: the transition's targets, each history
+      # target resolved to its recorded value when it has one, else to its
+      # default transition's own effective targets, as a frozen Array. The
+      # list is not deduplicated; no caller's answer changes on a repeat.
+      def get_effective_target_states(snapshot, transition)
+        transition.targets.flat_map { effective_target_states(snapshot, _1) }.freeze
+      end
+
+      # One target's effective states.
+      def effective_target_states(snapshot, target)
+        machine = snapshot.machine
+        return [target] unless machine.history?(target)
+        return snapshot.history.fetch(target) if snapshot.history.key?(target)
+
+        default = machine.transitions.fetch(machine.state(target).history_default)
+        get_effective_target_states(snapshot, default)
+      end
+
+      # `getTransitionDomain`: the state whose active descendants the
+      # transition exits, or nil when its effective targets are empty. An
+      # internal transition whose source is compound and whose every
+      # effective target is a proper descendant of it has the source as its
+      # domain; any other has the least common compound ancestor of its
+      # source and its effective targets.
+      def get_transition_domain(snapshot, transition)
+        targets = get_effective_target_states(snapshot, transition)
+        return nil if targets.empty?
+
+        machine = snapshot.machine
+        source = transition.source
+        return source if internal_domain?(machine, transition, targets)
+
+        find_lcca(machine, [source, *targets])
+      end
+
+      # Whether an internal transition's domain is its own source.
+      def internal_domain?(machine, transition, targets)
+        source = transition.source
+        transition.type == :internal && machine.compound?(source) &&
+          targets.all? { machine.descendant?(_1, source) }
+      end
+
+      # `computeExitSet`: every active state that is a proper descendant of
+      # some transition's domain, across `transitions`, as a frozen Array in
+      # document order (exit order is its reverse). A transition with no
+      # written target contributes nothing, and neither does one whose
+      # written targets resolve to no domain.
+      def compute_exit_set(snapshot, transitions)
+        exit_set = transitions.reject { _1.targets.empty? }.flat_map do |transition|
+          domain = get_transition_domain(snapshot, transition)
+          domain.nil? ? [] : snapshot.configuration.select { snapshot.machine.descendant?(_1, domain) }
+        end
+        exit_set.uniq.sort.freeze
+      end
+
+      # `conditionMatch`: the transition's condition evaluated against `data`
+      # and the snapshot's configuration (for `In()`); no condition is true.
+      #
+      # @return [Datamodel::Evaluated] true or false, or the reason it failed
+      def condition_match(snapshot, transition, data, clock: nil)
+        Datamodel.evaluate_cond(context(snapshot, data, clock), transition.cond)
+      end
+
+      # `selectTransitions`: the transitions the event named `name` enables,
+      # at most one per active atomic state, the states taken in document
+      # order. Each state is searched, then each proper ancestor outward, for
+      # the first transition in document order whose descriptors match the
+      # name and whose condition holds, so a descendant's transition preempts
+      # an ancestor's. The first occurrence of each transition is kept, and
+      # the list passes through {remove_conflicting_transitions}.
+      #
+      # @return [Selected]
+      def select_transitions(snapshot, name, data, clock: nil)
+        round(snapshot, context(snapshot, data, clock), NameMatch.tokenize(name))
+      end
+
+      # `selectEventlessTransitions`: {select_transitions}'s walk over the
+      # transitions that name no event. A transition naming one is never
+      # taken here, and an eventless one never by {select_transitions}.
+      #
+      # @return [Selected]
+      def select_eventless_transitions(snapshot, data, clock: nil)
+        round(snapshot, context(snapshot, data, clock), nil)
+      end
+
+      # `removeConflictingTransitions`: the enabled transitions, filtered to
+      # a set no two of which exit a common state. Taken in the order given,
+      # each is checked against those kept so far: on a conflict, one whose
+      # source is a descendant of the kept one's source preempts it and keeps
+      # checking; otherwise the later one is dropped and the check stops. A
+      # surviving transition is appended after every kept one it preempted is
+      # removed.
+      def remove_conflicting_transitions(snapshot, enabled)
+        enabled.reduce([]) do |filtered, candidate|
+          preempted = resolve(snapshot, candidate, filtered)
+          preempted.nil? ? filtered : (filtered - preempted) + [candidate]
+        end.freeze
+      end
+
+      # The kept transitions `candidate` preempts, or nil when a kept one
+      # preempts `candidate`.
+      def resolve(snapshot, candidate, filtered)
+        filtered.each_with_object([]) do |kept, preempted|
+          next unless conflict?(snapshot, candidate, kept)
+          return nil unless snapshot.machine.descendant?(candidate.source, kept.source)
+
+          preempted << kept
+        end
+      end
+
+      # Whether two transitions' exit sets share a state.
+      def conflict?(snapshot, one, other)
+        compute_exit_set(snapshot, [one]).intersect?(compute_exit_set(snapshot, [other]))
+      end
+
+      # The round both selection walks share: every active atomic state in
+      # document order, the written conditions recorded in walk order, the
+      # first occurrence of each transition kept and the conflicts removed.
+      # `tokens` is nil for the eventless walk.
+      def round(snapshot, context, tokens)
+        evaluations = []
+        enabled = snapshot.configuration.select { snapshot.machine.atomic?(_1) }.sort.filter_map do |atomic|
+          selected_for_atomic_state(snapshot.machine, context, atomic, tokens, evaluations)
+        end
+        transitions = remove_conflicting_transitions(snapshot, enabled.uniq(&:t_index))
+        Selected.new(transitions:, evaluations: evaluations.freeze)
+      end
+
+      # The labelled `break loop` of one atomic state's search: the state,
+      # then each proper ancestor outward, stopping at the first that has an
+      # enabled transition.
+      def selected_for_atomic_state(machine, context, atomic, tokens, evaluations)
+        [atomic, *machine.proper_ancestors(atomic)].each do |index|
+          found = first_matching_transition(machine, context, index, tokens, evaluations)
+          return found unless found.nil?
+        end
+        nil
+      end
+
+      # A state's own transitions in document order, stopping at the first
+      # enabled one, so a later sibling's condition is never evaluated once
+      # an earlier one is taken.
+      def first_matching_transition(machine, context, index, tokens, evaluations)
+        machine.state(index).transitions.each do |t_index|
+          transition = machine.transitions.fetch(t_index)
+          return transition if enabled?(context, transition, tokens, evaluations)
+        end
+        nil
+      end
+
+      # The eventless predicate when `tokens` is nil, the event-matched one
+      # otherwise; both end in the transition's condition, which, when
+      # written, is recorded in `evaluations`.
+      def enabled?(context, transition, tokens, evaluations)
+        eventless = transition.events.empty?
+        return false unless tokens.nil? ? eventless : !eventless && NameMatch.name_match?(transition.events, tokens)
+        return true if transition.cond.nil?
+
+        evaluated = Datamodel.evaluate_cond(context, transition.cond)
+        evaluations << evaluation(transition, evaluated)
+        evaluated.ok? && evaluated.value
+      end
+
+      # How one written condition came out.
+      def evaluation(transition, evaluated)
+        t_index = transition.t_index
+        return Evaluation.new(t_index:, outcome: :error, reason: evaluated.error) unless evaluated.ok?
+
+        Evaluation.new(t_index:, outcome: evaluated.value ? :enabled : :disabled, reason: nil)
+      end
+
+      # The context one round evaluates against.
+      def context(snapshot, data, clock)
+        Datamodel.context(data, snapshot.machine, snapshot.configuration, clock:)
+      end
+    end
+  end
+end

data/lib/statifier/interpreter/send.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # `<send>` and `<cancel>`, as the reference's send and cancel nodes run
+    # them (`Statifier.Machine.Content.Send` and `.Cancel` in statifier-ex),
+    # with the event data its `Statifier.EventData` makes.
+    #
+    # The core delivers nothing and schedules nothing. A `<send>` answers
+    # one effect describing the message, {Effect::Send} when it goes now and
+    # {Effect::SendDelayed} with its delay when it waits, whatever its
+    # target, `#_internal` included; the driver delivers it. A `<cancel>`
+    # answers an {Effect::Cancel}.
+    #
+    # A `<send>` resolves its arguments in the reference's order: the event,
+    # the target, the type, the delay, the `namelist` and `<param>` values in
+    # document order, then `<content>`. The first that fails discards the
+    # send: no id is minted, nothing is written, and the failure is the
+    # reason the block's `error.execution` carries. Then the send id is
+    # minted (or the author's `id` read) and `idlocation` written; a write
+    # that fails discards the send the same way. Only then are the type and
+    # the target judged ({Targets.reject_reason}): a refused send keeps its
+    # minted id and its `idlocation` write, answers no effect, and fails with
+    # a {SendRejected} naming the id and the event it raises.
+    #
+    # @api private
+    module Send
+      # What a session carries for its sends from block to block, never a
+      # module variable: `send_counter`, the sequence a generated id is
+      # minted from (the next id is `send_` and the counter plus one);
+      # `timer_counter`, the ordinal sequence every delayed send, every
+      # cancel and every immediate send of a registered type advances;
+      # `send_types`, the types the host registered a processor for, or nil
+      # for none; and `routes`, the {Targets::Routes} the driver last
+      # declared, or nil when it declared none.
+      SendState = ::Data.define(:send_counter, :timer_counter, :send_types, :routes) do
+        # The state with the next generated id minted.
+        def mint = with(send_counter: send_counter + 1)
+
+        # The state with the timer counter advanced.
+        def tick = with(timer_counter: timer_counter + 1)
+      end
+
+      class SendState
+        # The send state before the first send.
+        INITIAL = new(send_counter: 0, timer_counter: 0, send_types: nil, routes: nil)
+      end
+
+      # A `<send>` refused after its id was minted: `send_id`; `kind`,
+      # `:execution` or `:communication`, the `error.*` event it raises; and
+      # `reason`, the refusal the event's data carries.
+      SendRejected = ::Data.define(:send_id, :kind, :reason)
+
+      # What executing a `<send>` or `<cancel>` answered: the `context` and
+      # `sends` the block keeps, the `effects` in order, and `error`, the
+      # reason it failed, nil when it did not. A failure answers no effect,
+      # and an argument failure keeps the context and send state it started
+      # with.
+      Sent = ::Data.define(:context, :sends, :effects, :error) do
+        # @return [Boolean] whether the element succeeded
+        def ok? = error.nil?
+      end
+
+      # The whitespace a text payload is normalized over, the ASCII set.
+      RUNS_OF_SPACE = /[ \t\n\v\f\r]+/
+
+      # A successful evaluation of nil, for an attribute not written.
+      NONE = Datamodel::Evaluated.new(value: nil, error: nil)
+
+      module_function
+
+      # Executes the {Machine::Send} `node` against `context` and `sends`;
+      # `stamp` ({Content::Stamp}) names the block and the counters.
+      #
+      # @return [Sent]
+      def execute_send(context, node, sends, stamp)
+        resolved = resolve_arguments(context, node)
+        return failed(context, sends, resolved) unless resolved.is_a?(Hash)
+
+        send_id, minted = mint(node, sends)
+        write = node.idlocation && Datamodel::Location.write(context, node.idlocation, send_id)
+        return failed(context, sends, write.error) if write && !write.ok?
+
+        judged(node, resolved.merge(send_id:, write:), minted, stamp, write ? write.context : context)
+      end
+
+      # The send id and the send state after it: the author's `id`, which
+      # consumes no counter, else the next generated id.
+      def mint(node, sends) = node.id.nil? ? ["send_#{sends.mint.send_counter}", sends.mint] : [node.id, sends]
+
+      # A send whose id is minted and whose `idlocation` is written, judged
+      # ({Targets.reject_reason}): refused, keeping both, or accepted.
+      def judged(node, resolved, sends, stamp, context)
+        kind, reason = Targets.reject_reason(*resolved.values_at(:target, :type, :delay_ms), sends.send_types,
+                                             sends.routes)
+        return failed(context, sends, SendRejected.new(send_id: resolved[:send_id], kind:, reason:)) if kind
+
+        accepted(node, resolved, sends, stamp, context)
+      end
+
+      # Executes the {Machine::Cancel} `node`: its send id resolved and the
+      # effect naming it. An id that names nothing pending is the host's
+      # no-op, not a failure.
+      #
+      # @return [Sent]
+      def execute_cancel(context, node, sends, stamp)
+        evaluated = Datamodel.evaluate(context, node.sendid)
+        return failed(context, sends, evaluated.error) unless evaluated.ok?
+
+        sends = sends.tick
+        effect = Effect::Cancel.new(send_id: evaluated.value, c_index: node.c_index, **stamp.fields,
+                                    ordinal: sends.timer_counter, caller_context: stamp.caller_context)
+        Sent.new(context:, sends:, effects: [effect].freeze, error: nil)
+      end
+
+      # A `<content>` body as data, as the reference's event data reads one:
+      # blank text is no data; text that predicator reads as a literal (a
+      # number, a string, a list, a map) is that value; anything else is the
+      # trimmed text with each run of whitespace one space.
+      def text_data(text)
+        trimmed = text.nil? ? "" : Lowering::Errors.trim(text)
+        return Predicator::UNDEFINED if trimmed.empty?
+
+        compiled = Predicator.compile(trimmed)
+        evaluated = compiled.ok? ? Predicator.evaluate(compiled.value, {}, on_unbound: :error) : compiled
+        evaluated.ok? ? evaluated.value : trimmed.gsub(RUNS_OF_SPACE, " ")
+      end
+
+      # `namelist` and `<param>` values (name and value pairs) as data: a
+      # Hash, the last of a repeated name winning, or no data when there are
+      # none.
+      def params_data(pairs) = pairs.empty? ? Predicator::UNDEFINED : pairs.to_h.freeze
+
+      # Every argument resolved, as a Hash, or the reason the first failed.
+      def resolve_arguments(context, node)
+        resolved = {}
+        { event: node.event, target: node.target, type: node.type }.each do |key, expr|
+          evaluated = expr.nil? ? NONE : Datamodel.evaluate(context, expr)
+          return evaluated.error unless evaluated.ok?
+
+          resolved[key] = evaluated.value
+        end
+        resolve_rest(context, node, resolved)
+      end
+
+      # The delay and the payload, after the first three.
+      def resolve_rest(context, node, resolved)
+        delay = resolve_delay(context, node.delay)
+        return delay.error unless delay.ok?
+
+        data = resolve_data(context, node)
+        data.ok? ? resolved.merge(delay_ms: delay.value, data: data.value) : data.error
+      end
+
+      # The delay in whole milliseconds ({Datamodel::Delay}), nil for a send
+      # with none.
+      def resolve_delay(context, delay)
+        return NONE if delay.nil?
+
+        evaluated = Datamodel.evaluate(context, delay)
+        evaluated.ok? ? Datamodel::Delay.milliseconds(evaluated.value) : evaluated
+      end
+
+      # The payload: the `namelist` and `<param>` values, stopping at the
+      # first that fails, then, when the node has a `<content>` child, that
+      # child's data in their place.
+      def resolve_data(context, node)
+        pairs = resolve_params(context, node.namelist + node.params)
+        return pairs unless pairs.ok?
+
+        content = node.content
+        return value(params_data(pairs.value)) if content.nil?
+
+        content.is_a?(Machine::Static) ? value(text_data(content.value)) : Datamodel.evaluate(context, content)
+      end
+
+      # A successful evaluation of `value`.
+      def value(value) = Datamodel::Evaluated.new(value:, error: nil)
+
+      # Each param's name and value, in order, or the first failure.
+      def resolve_params(context, params)
+        pairs = params.map do |param|
+          evaluated = Datamodel.evaluate(context, param.expr)
+          return evaluated unless evaluated.ok?
+
+          [param.name, evaluated.value]
+        end
+        value(pairs)
+      end
+
+      # A failure: no effect, and the context and send state the block keeps.
+      def failed(context, sends, error) = Sent.new(context:, sends:, effects: [].freeze, error:)
+
+      # A send that is not refused: the timer counter advanced for a delay
+      # or a registered type, its `idlocation` write's change, then its own
+      # effect. `resolved` carries the send id and the {Datamodel::Written}
+      # of its `idlocation`, nil when it has none.
+      def accepted(node, resolved, sends, stamp, context)
+        stamps = stamps?(resolved, sends)
+        sends = sends.tick if stamps
+        write = resolved[:write]
+        changes = write ? [Content.change(write, node.idlocation, resolved[:send_id], node.c_index, stamp)] : []
+        effect = send_effect(node, resolved, stamp, (sends.timer_counter if stamps))
+        Sent.new(context:, sends:, effects: (changes << effect).freeze, error: nil)
+      end
+
+      # Whether the send stamps an ordinal: a delay, or a registered type.
+      def stamps?(resolved, sends)
+        !resolved[:delay_ms].nil? || Targets.classify(sends.send_types, resolved[:type]) == :registered
+      end
+
+      # The effect itself, immediate or delayed.
+      def send_effect(node, resolved, stamp, ordinal)
+        fields = resolved.slice(:event, :target, :type, :data, :send_id)
+                         .merge(c_index: node.c_index, **stamp.fields, ordinal:,
+                                id_from_author?: !node.id.nil? || !node.idlocation.nil?)
+        return Effect::Send.new(**fields) if resolved[:delay_ms].nil?
+
+        Effect::SendDelayed.new(**fields, delay_ms: resolved[:delay_ms], caller_context: stamp.caller_context)
+      end
+    end
+  end
+end

data/lib/statifier/interpreter/step.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # The specification's `microstep`, `exitStates` and `enterStates` with
+    # their content run, as the reference runs them
+    # (`Statifier.Interpreter.microstep/2` and
+    # `Statifier.Interpreter.ExitEntry` in statifier-ex). Which states leave
+    # and enter, in which order, is {ExitEntry}'s; this module walks those
+    # moves state by state against a {MachineState}: each exiting state runs
+    # its `<onexit>` blocks while it is still active and then leaves, and
+    # each entering state joins the configuration, binds its own `<data>`
+    # on its first entry under late binding, runs its `<onentry>` blocks,
+    # its initial and default-history content, and raises its completion
+    # events, its parent's carrying the final state's `<donedata>`. The
+    # blocks run through {Blocks}.
+    #
+    # @api private
+    module Step
+      module_function
+
+      # `microstep`: the states the transitions leave exit, each
+      # transition's content runs in the order given, and the states they
+      # reach enter.
+      #
+      # @return [Stepped]
+      def microstep(state, transitions)
+        exited = exit_states(state, transitions)
+        executed = execute_transition_content(exited.state, transitions)
+        exited.then_step(executed).then_step(enter_states(executed.state, transitions))
+      end
+
+      # `exitStates`: the exit set leaves the states to invoke, the history
+      # is recorded from the configuration before anything leaves, and each
+      # state in exit order runs its `<onexit>` blocks and leaves. The
+      # {Effect::Trace::ExitSet} comes first, stamped before the exits.
+      #
+      # @return [Stepped]
+      def exit_states(state, transitions)
+        moves = ExitEntry.exit_states(state.snapshot, transitions)
+        state = state.with(states_to_invoke: (state.states_to_invoke - moves.states).freeze)
+        trace = Blocks.traced(state, Effect::Trace::ExitSet, indexes: moves.states, configuration: moves.configuration)
+        departures(Stepped.new(state: state.with(history: moves.history), effects: trace), moves.states)
+      end
+
+      # Each of `indexes` leaving in turn, after `stepped`.
+      #
+      # @return [Stepped]
+      def departures(stepped, indexes)
+        indexes.reduce(stepped) { |acc, index| acc.then_step(depart(acc.state, index)) }
+      end
+
+      # One state leaving: its `<onexit>` blocks, the cancel of its live
+      # invocations ({Invoke::Passes.cancel_invocations}), then out of the
+      # configuration.
+      #
+      # @return [Stepped]
+      def depart(state, index)
+        left = Blocks.run_blocks(state, :onexit, index)
+        left = left.then_step(Invoke::Passes.cancel_invocations(left.state, index))
+        left.with(state: left.state.with(configuration: (left.state.configuration - [index]).freeze))
+      end
+
+      # `executeTransitionContent`: each transition's content, in the order
+      # given.
+      #
+      # @return [Stepped]
+      def execute_transition_content(state, transitions)
+        transitions.reduce(Stepped.new(state:, effects: [])) do |acc, transition|
+          acc.then_step(Blocks.run_transition_content(acc.state, transition.t_index))
+        end
+      end
+
+      # `enterStates`: each state of the entry set in entry order, with the
+      # {Effect::Trace::EntrySet} first, stamped before any entry.
+      #
+      # @return [Stepped]
+      def enter_states(state, transitions)
+        moves = ExitEntry.enter_states(state.snapshot, transitions)
+        trace = Blocks.traced(state, Effect::Trace::EntrySet, indexes: moves.states.map(&:index).freeze,
+                                                              configuration: moves.configuration)
+        moves.states.reduce(Stepped.new(state:, effects: trace)) do |acc, arrival|
+          acc.then_step(arrive(acc.state, arrival))
+        end
+      end
+
+      # One {ExitEntry::Arrival}: the state joins the configuration and the
+      # states to invoke, binds its own `<data>` on its first entry, runs
+      # its `<onentry>` blocks, its initial content and its default-history
+      # content, and then raises its completions; a top-level final clears
+      # `running` instead.
+      #
+      # @return [Stepped]
+      def arrive(state, arrival)
+        index = arrival.index
+        stepped = enter(state, index)
+        stepped = stepped.then_step(Blocks.run_blocks(stepped.state, :onentry, index))
+        stepped = [arrival.initial_content, arrival.history_content].reduce(stepped) do |acc, t_index|
+          acc.then_step(Blocks.run_transition_content(acc.state, t_index))
+        end
+        stepped.with(state: complete(stepped.state, arrival))
+      end
+
+      # The state with `index` active, among the states to invoke and
+      # recorded as entered.
+      def join(state, index)
+        state.with(configuration: (state.configuration | [index]).sort.freeze,
+                   states_to_invoke: (state.states_to_invoke | [index]).sort.freeze,
+                   entered_states: (state.entered_states | [index]).sort.freeze)
+      end
+
+      # The state at `index` joined ({join}), with its own `<data>` bound
+      # when this is its first entry ({Datamodel::DataBinding.enter_state}).
+      #
+      # @return [Stepped]
+      def enter(state, index)
+        joined = join(state, index)
+        return Stepped.new(state: joined, effects: []) if state.entered_states.include?(index)
+
+        Blocks.bound(joined, Datamodel::DataBinding.enter_state(joined.context, index))
+      end
+
+      # The completions an arrival raises (origin `{kind: :state,
+      # state_index:}`, the final state's), or `running` cleared.
+      def complete(state, arrival)
+        return state.with(running: false) if arrival.stops
+
+        arrival.completions.reduce(state) do |acc, completion|
+          origin = { kind: :state, state_index: completion.final }
+          next acc.raise_platform(completion.name, origin) unless completion.donedata
+
+          acc, data = Blocks.donedata(acc, completion.final)
+          acc.raise_platform(completion.name, origin, data:)
+        end
+      end
+    end
+  end
+end