statifier 0.0.1 → 0.1.0

data/lib/statifier/compiler/content.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # The executable content half of the {Walk}: each content node compiled,
+    # taking the next content index first, so a container's index precedes
+    # its children's.
+    #
+    # A refusal is one of two things, class by class, as in the reference.
+    # A transition's `cond`, a `<log>`'s `expr`, an `<if>` or `<elseif>`
+    # condition, a `<foreach>`'s `array`, a `<cancel>`'s `sendidexpr`, and a
+    # `<send>`'s expressions, `<content>` and `<param>`s are load-time
+    # errors: the chart does not compile. An `<assign>`'s `expr` and a
+    # `<script>` body are deferred: the node holds a {Machine::Invalid} that
+    # fails when it runs.
+    #
+    # @api private
+    module Content
+      # The builder of each kind of content node.
+      BUILDERS = {
+        Document::Raise => :raise_node, Document::Log => :log, Document::Assign => :assign,
+        Document::If => :if_node, Document::Foreach => :foreach, Document::Script => :script,
+        Document::Send => :send_node, Document::Cancel => :cancel
+      }.freeze
+
+      # A `<send>`'s attribute pairs, in the order they compile.
+      SEND_PAIRS = [%i[event eventexpr], %i[target targetexpr], %i[type typeexpr], %i[delay delayexpr]].freeze
+
+      # The content of a block, a transition, a branch or a loop body.
+      def content_list(nodes) = nodes.map { __send__(BUILDERS.fetch(_1.class), _1, next_c_index) }.freeze
+
+      private
+
+      def content_site(c_index, element, attribute, location)
+        site({ kind: :content, c_index: }, element, attribute, location)
+      end
+
+      def raise_node(node, c_index) = Machine::Raise.new(c_index:, event: node.event, location: node.location)
+
+      def log(node, c_index)
+        expr_location = node.expr && span(node, :expr)
+        expr = node.expr && load_time(:content, node.expr, content_site(c_index, "log", "expr", expr_location))
+        Machine::Log.new(c_index:, label: node.label, expr:, location: node.location, expr_location:)
+      end
+
+      # An `<assign>`'s value: its `expr`, a refusal deferred; else its
+      # markup children as a string; else its text folded as an in-line
+      # value; else nil.
+      def assign(node, c_index)
+        expr_location = node.expr && span(node, :expr, node.node_location)
+        Machine::Assign.new(
+          c_index:, location: node.location, node_location: node.node_location, value: assign_value(node, c_index),
+          location_location: span(node, :location, node.node_location), expr_location:
+        )
+      end
+
+      def assign_value(node, c_index)
+        return text_value(node.markup, node.text) if node.expr.nil?
+
+        site = content_site(c_index, "assign", "expr", span(node, :expr, node.node_location))
+        Expressions.deferred(Expressions.compile(node.expr, site))
+      end
+
+      # Every branch's condition compiles, each refusal its own error.
+      def if_node(node, c_index)
+        branches = node.branches.each_with_index.map { |branch, position| branch(branch, position, c_index) }
+        Machine::If.new(c_index:, location: node.location, branches: branches.freeze)
+      end
+
+      # One branch: the `<if>` itself at position 0, then each `<elseif>` and
+      # `<else>`.
+      def branch(branch, position, c_index)
+        cond_location = branch.cond && span(branch, :cond)
+        site = content_site(c_index, position.zero? ? "if" : "elseif", "cond", cond_location)
+        cond = branch.cond && load_time(:content, branch.cond, site)
+        Machine::If::Branch.new(cond:, cond_location:, content: content_list(branch.content))
+      end
+
+      def foreach(node, c_index)
+        array_location = span(node, :array)
+        array = load_time(:content, node.array, content_site(c_index, "foreach", "array", array_location))
+        Machine::Foreach.new(
+          c_index:, location: node.location, array:, array_location:, item: node.item,
+          item_location: span(node, :item), index: node.index, index_location: node.index && span(node, :index),
+          content: content_list(node.content)
+        )
+      end
+
+      def script(node, c_index)
+        program = Expressions.program(node.text, content_site(c_index, "script", nil, node.location))
+        Machine::Script.new(c_index:, program:, node_location: node.location)
+      end
+
+      # A `<send>`: its attribute pairs, then its `<content>`, compile in
+      # that order and the first refusal stops the rest, its `<param>`s
+      # included; the `<param>`s then each answer their own refusal.
+      def send_node(node, c_index)
+        owner = { kind: :content, c_index: }
+        folded, refusal = send_values(node, owner)
+        record_all(:content, [refusal]) if refusal
+        Machine::Send.new(
+          c_index:, location: node.location, **folded, id: node.id, idlocation: node.idlocation,
+          namelist: namelist(node, owner, "send"),
+          params: refusal ? Numbering::EMPTY : params(:content, node.params, owner),
+          attribute_locations: node.attribute_locations
+        )
+      end
+
+      # The folded attribute pairs and `<content>` of a `<send>`, and the
+      # first refusal among them.
+      def send_values(node, owner)
+        folded = { event: nil, target: nil, type: nil, delay: nil, content: nil }
+        steps = SEND_PAIRS.map { |names| [names.first, -> { pair(node, names, owner, "send") }] }
+        steps << [:content, -> { node.content && content_value(node.content, owner) }]
+        steps.each do |key, step|
+          value = step.call
+          return [folded, value] if value.is_a?(Error)
+
+          folded[key] = value
+        end
+        [folded, nil]
+      end
+
+      # A `<cancel>`: `sendid` as a literal, else `sendidexpr` compiled.
+      def cancel(node, c_index)
+        sendid = record_all(:content, [pair(node, %i[sendid sendidexpr], { kind: :content, c_index: }, "cancel")]).first
+        Machine::Cancel.new(c_index:, location: node.location, sendid:, attribute_locations: node.attribute_locations)
+      end
+    end
+  end
+end

data/lib/statifier/compiler/error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # Why a chart did not compile: a reason symbol, the detail that reason
+    # carries (a frozen Hash), a message for a person, and the span reported.
+    # The shape of {Lowering::Error} and {Validator::Error}.
+    #
+    # The one reason is `:expression_compile_error`, an expression or
+    # program that predicator refused. Its detail:
+    #
+    # - `owner`: the node the expression belongs to, a frozen Hash in the
+    #   machine's index spaces: `{kind: :transition, t_index:}`,
+    #   `{kind: :content, c_index:}`, `{kind: :donedata, state_index:}`,
+    #   `{kind: :data, d_index:}`, `{kind: :global_script, index:}` or
+    #   `{kind: :invoke, state_index:, invoke_index:}`;
+    # - `element` and `attribute`: where it was written, as Strings
+    #   (`"transition"` and `"cond"`); a `<script>` body, written as the
+    #   element's text, has the element `"script"` and a nil attribute;
+    # - `source`: the expression as written;
+    # - `error`: predicator's own `Predicator::ParseError`, its position in
+    #   the expression's own lines and columns.
+    #
+    # The span is the attribute's value when one was written, and the element
+    # otherwise.
+    #
+    # @api private
+    Error = ::Data.define(:reason, :detail, :message, :location)
+  end
+end

data/lib/statifier/compiler/expressions.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # Every expression of a chart compiles here, once, through predicator: a
+    # condition or a value through `Predicator.compile`, a `<script>` body
+    # through `Predicator.compile_program`, as the reference compiles them.
+    #
+    # @api private
+    module Expressions
+      # Where an expression was written: what a refusal names.
+      Site = ::Data.define(:owner, :element, :attribute, :location)
+
+      module_function
+
+      # The expression `source` compiled: a {Machine::Compiled}, or the
+      # {Error} predicator's refusal makes at `site`.
+      def compile(source, site)
+        result = Predicator.compile(source)
+        result.ok? ? Machine::Compiled.new(instructions: result.value, source:) : refusal(source, result.error, site)
+      end
+
+      # The statement program `source` compiled: a {Machine::Program}, or an
+      # {Machine::Invalid} carrying the {Error} predicator's refusal makes at
+      # `site`. A program's refusal is always deferred to when it runs.
+      def program(source, site)
+        result = Predicator.compile_program(source)
+        return Machine::Program.new(instructions: result.value, source:) if result.ok?
+
+        Machine::Invalid.new(error: refusal(source, result.error, site))
+      end
+
+      # `compiled`, or an {Machine::Invalid} carrying it when it is an
+      # {Error}: the deferral the reference gives `<assign expr>`,
+      # `<data expr>` and a `namelist` entry.
+      def deferred(compiled) = compiled.is_a?(Error) ? Machine::Invalid.new(error: compiled) : compiled
+
+      # A literal value.
+      def static(value) = Machine::Static.new(value:)
+
+      # An in-line value (a `<data>` or `<assign>` body) folded to a literal:
+      # the trimmed text compiled and evaluated against an empty context that
+      # refuses every unbound name, and the trimmed text itself when either
+      # step fails. So `[1, 2]` is a list, `3` a number, and `x` the string
+      # `"x"` rather than a read of a variable.
+      def inline_value(text)
+        trimmed = Lowering::Errors.trim(text)
+        compiled = Predicator.compile(trimmed)
+        evaluated = compiled.ok? ? Predicator.evaluate(compiled.value, {}, on_unbound: :error) : compiled
+        static(evaluated.ok? ? evaluated.value : trimmed)
+      end
+
+      # The {Error} for `parse_error` on `source`, with the reference's
+      # message.
+      def refusal(source, parse_error, site)
+        position = parse_error.position
+        message = "failed to compile expression #{Lowering::Errors.quote(source)}: #{parse_error.message} " \
+                  "(predicator line #{position.line}, column #{position.column})"
+        detail = { owner: site.owner, element: site.element, attribute: site.attribute, source:, error: parse_error }
+        Error.new(reason: :expression_compile_error, detail:, message:, location: site.location)
+      end
+    end
+  end
+end

data/lib/statifier/compiler/numbering.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # The state half of the {Walk}. A state takes its index when the walk
+    # reaches it, before its children; then its own `<onentry>` and
+    # `<onexit>` content, its transitions (a history's are its default; any
+    # other kind's plain transitions come before its `<initial>` element's)
+    # with their content, its `<donedata>`, its `<data>`, and its `<invoke>`
+    # elements with their `<finalize>` content are numbered before the walk
+    # descends. A transition's targets can name a state the walk has not
+    # reached yet, so targets are resolved, and conditions compiled, once the
+    # walk is done.
+    #
+    # @api private
+    module Numbering
+      EMPTY = [].freeze
+
+      # The parts the root has none of.
+      ROOT_PARTS = {
+        transitions: EMPTY, onentry: EMPTY, onexit: EMPTY, initial_transition: nil, history_default: nil,
+        donedata: nil, invoke: EMPTY
+      }.freeze
+
+      PendingTransition = ::Data.define(:transition, :source, :t_index, :content)
+
+      # The fields a compiled state copies from its document node.
+      COPIED = %i[id kind history_type location attribute_locations].freeze
+
+      private
+
+      # Numbers one group of sibling states and their subtrees, depth first,
+      # from `index`; answers the group's indexes and the first index after
+      # the whole group.
+      def siblings(states, index, parent)
+        indexes = states.map do |state|
+          own = index
+          index = numbered(state, own, parent)
+          own
+        end
+        [indexes.freeze, index]
+      end
+
+      # Numbers `state` at `index` and its subtree; answers the first index
+      # after the subtree.
+      def numbered(state, index, parent)
+        own = own_parts(state, index)
+        children, after = siblings(state.states, index + 1, index)
+        @states[index] = Machine::State.new(
+          index:, parent:, last: after - 1, children:, **own, **state.to_h.slice(*COPIED),
+          initial: resolve_initial(state, children), history_children: histories(children)
+        )
+        @id_to_index[state.id] = index unless state.id.nil?
+        after
+      end
+
+      # The parts of a state numbered before its children, in the order the
+      # walk numbers them.
+      def own_parts(state, index)
+        parts = { onentry: blocks(state.onentry), onexit: blocks(state.onexit) }
+        parts.merge!(transition_parts(state, index))
+        parts.merge!(data_parts(state, index))
+      end
+
+      # A state's `<donedata>`, then its `<data>`, then its `<invoke>`s.
+      def data_parts(state, index)
+        donedata = state.donedata && build_donedata(state.donedata, index)
+        assign_data(state.datamodel_element, index)
+        invoke = state.invoke.each_with_index.map { |node, at| build_invoke(node, index, at) }.freeze
+        { donedata:, data: owned_data(index), invoke: }
+      end
+
+      # A history's transitions are its default; any other kind's plain
+      # transitions are selectable, and its `<initial>` element's follow.
+      def transition_parts(state, index)
+        plain = numbered_transitions(state.transitions, index)
+        return { transitions: EMPTY, initial_transition: nil, history_default: plain.first } if state.kind == :history
+
+        initial = numbered_transitions(state.initial_element&.transitions || EMPTY, index)
+        { transitions: plain, initial_transition: initial.first, history_default: nil }
+      end
+
+      def numbered_transitions(transitions, source)
+        transitions.map do |transition|
+          content = content_list(transition.content)
+          @pending << PendingTransition.new(transition:, source:, t_index: @pending.size, content:)
+          @pending.size - 1
+        end.freeze
+      end
+
+      def build_transition(pending)
+        transition = pending.transition
+        fields = pending.to_h.slice(:t_index, :source, :content)
+                        .merge(transition.to_h.slice(:type, :location, :attribute_locations))
+        Machine::Transition.new(
+          targets: resolve(transition.target), events: events(transition.event),
+          **transition_cond(transition, pending.t_index), **fields
+        )
+      end
+
+      # Each event descriptor split on its dots, an empty part kept.
+      def events(descriptors) = descriptors.map { _1.split(".", -1).map(&:freeze).freeze }.freeze
+
+      # A transition's condition compiled, a load-time error, and where it
+      # was written; both nil when none was.
+      def transition_cond(transition, t_index)
+        return { cond: nil, cond_location: nil } if transition.cond.nil?
+
+        cond_location = span(transition, :cond)
+        site = site({ kind: :transition, t_index: }, "transition", "cond", cond_location)
+        { cond: load_time(:transitions, transition.cond, site), cond_location: }
+      end
+
+      # A `<state>`'s default entry, in the specification's precedence.
+      # Only a `<state>` has one: a parallel enters every child, and a final
+      # or history is never entered by default.
+      def resolve_initial(state, children)
+        return EMPTY unless state.kind == :state
+        return resolve(state.initial) unless state.initial.empty?
+
+        written = state.initial_element&.transitions || EMPTY
+        written.size == 1 ? resolve(written.first.target) : children.first(1).freeze
+      end
+
+      # The indexes of `ids`; the validator has resolved every one.
+      def resolve(ids) = ids.map { @id_to_index.fetch(_1) }.freeze
+
+      def histories(children) = children.select { @states.fetch(_1).kind == :history }.freeze
+
+      def blocks(blocks) = blocks.map { block(_1) }.freeze
+
+      def block(block) = Machine::Block.new(location: block.location, content: content_list(block.content))
+
+      def assign_data(datamodel, state_index)
+        datamodel&.data&.each do |node|
+          d_index = @data.size
+          @data << data_element(node, d_index)
+          @data_by_state[state_index] << d_index
+        end
+      end
+
+      def owned_data(index) = @data_by_state.fetch(index, EMPTY).dup.freeze
+    end
+  end
+end

data/lib/statifier/compiler/parts.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # The data half of the {Walk}: `<data>`, `<donedata>`, `<param>`,
+    # `<content>`, `namelist` and `<invoke>`, and the helpers every half
+    # shares. A `<data>`'s `expr` and a `namelist` entry defer their refusal
+    # to when they run; every other expression here is a load-time error.
+    #
+    # @api private
+    module Parts
+      private
+
+      def site(owner, element, attribute, location) = Expressions::Site.new(owner:, element:, attribute:, location:)
+
+      # Where `node` wrote the attribute `key`: its value's span, else
+      # `fallback`, the element's span by default.
+      def span(node, key, fallback = node.location) = node.attribute_locations[key] || fallback
+
+      # `source` compiled at `site`, or nil with the refusal recorded in
+      # `group`: a load-time error.
+      def load_time(group, source, site)
+        compiled = Expressions.compile(source, site)
+        return compiled unless compiled.is_a?(Error)
+
+        @groups.fetch(group) << compiled
+        nil
+      end
+
+      # The values among `built`, each {Error} among them recorded in
+      # `group`.
+      def record_all(group, built)
+        refused, kept = built.partition { _1.is_a?(Error) }
+        @groups.fetch(group).concat(refused)
+        kept.freeze
+      end
+
+      # A literal attribute folded with its `expr` twin: a static value for
+      # the literal (the validator refuses a chart that writes both), the
+      # twin compiled (a compiled value or an {Error}), or nil for neither.
+      def pair(node, (literal, twin), owner, element)
+        written = node.public_send(literal)
+        return Expressions.static(written) unless written.nil?
+
+        source = node.public_send(twin)
+        source && Expressions.compile(source, site(owner, element, twin.to_s, span(node, twin)))
+      end
+
+      # A body with no `expr`: its markup children as a string, else its
+      # text folded as an in-line value, else nil.
+      def text_value(markup, text)
+        return Expressions.static(markup) if markup
+        return Expressions.static(nil) if Lowering::Reading.blank?(text)
+
+        Expressions.inline_value(text)
+      end
+
+      # A `<content>`'s value: its `expr` compiled (a compiled value or an
+      # {Error}), else its markup children, else its text, as written.
+      def content_value(content, owner)
+        return Expressions.static(content.markup || content.text) if content.expr.nil?
+
+        Expressions.compile(content.expr, site(owner, "content", "expr", span(content, :expr)))
+      end
+
+      # A `<param>`: its `expr` when it has no `location`, else its
+      # `location`, compiled; a {Machine::Param} or an {Error}. The
+      # validator guarantees one of the two.
+      def param(node, owner)
+        kind = node.expr && node.param_location.nil? ? :expr : :location
+        expr_location = span(node, node.expr.nil? ? :location : :expr)
+        compiled = Expressions.compile(kind == :expr ? node.expr : node.param_location,
+                                       site(owner, "param", kind.to_s, expr_location))
+        return compiled if compiled.is_a?(Error)
+
+        Machine::Param.new(name: node.name, kind:, expr: compiled, expr_location:, location: node.location)
+      end
+
+      def params(group, nodes, owner) = record_all(group, nodes.map { param(_1, owner) })
+
+      # A `namelist`'s entries, each a location read by its own name, its
+      # refusal deferred. The whole attribute shares one span.
+      def namelist(node, owner, element)
+        expr_location = span(node, :namelist)
+        node.namelist.map do |name|
+          expr = Expressions.deferred(Expressions.compile(name, site(owner, element, "namelist", expr_location)))
+          Machine::Param.new(name:, kind: :location, expr:, expr_location:, location: node.location)
+        end.freeze
+      end
+
+      # A `<data>`'s value, in the specification's precedence: `expr` (its
+      # refusal deferred), then `src`, then its text, then nil.
+      def data_element(node, d_index)
+        value, value_location = data_value(node, d_index)
+        Machine::Data.new(d_index:, id: node.id, value:, location: node.location, value_location:)
+      end
+
+      def data_value(node, d_index)
+        if node.expr
+          location = span(node, :expr)
+          [Expressions.deferred(Expressions.compile(node.expr, site({ kind: :data, d_index: }, "data", "expr",
+                                                                    location))), location]
+        elsif node.src
+          [Machine::Src.new(src: node.src), span(node, :src)]
+        else
+          [text_value(nil, node.text), node.location]
+        end
+      end
+
+      # A final state's `<donedata>`: its `<content>`'s value, or its
+      # `<param>`s.
+      def build_donedata(node, state_index)
+        owner = { kind: :donedata, state_index: }
+        content = node.content
+        if content.nil?
+          return Machine::Donedata.new(location: node.location, expr: nil, expr_location: nil,
+                                       params: params(:donedata, node.params, owner))
+        end
+
+        expr = record_all(:donedata, [content_value(content, owner)]).first
+        expr_location = content.expr ? span(content, :expr) : content.markup_location || content.location
+        Machine::Donedata.new(location: node.location, expr:, expr_location:, params: Numbering::EMPTY)
+      end
+
+      def build_invoke(node, state_index, invoke_index)
+        owner = { kind: :invoke, state_index:, invoke_index: }
+        Machine::Invoke.new(
+          index: invoke_index, **invoke_values(node, owner), namelist: namelist(node, owner, "invoke"),
+          params: params(:invoke, node.params, owner), finalize: node.finalize && block(node.finalize),
+          **node.to_h.slice(:location, :id, :idlocation, :autoforward, :attribute_locations)
+        )
+      end
+
+      # An `<invoke>`'s `type` and `src` pairs and its `<content>`, in that
+      # order, each a load-time error.
+      def invoke_values(node, owner)
+        values = { type: pair(node, %i[type typeexpr], owner, "invoke"),
+                   src: pair(node, %i[src srcexpr], owner, "invoke") }
+        values[:content] = node.content && content_value(node.content, owner)
+        values.transform_values { record_all(:invoke, [_1]).first }
+      end
+    end
+  end
+end

data/lib/statifier/compiler/walk.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Compiler
+    # The numbering walk over one chart: made by {Compiler.compile}, used
+    # once and discarded. It numbers every state, transition, content node
+    # and `<data>` in document order and collects the refusals in four
+    # groups (the transitions', the content's, the donedata's and the
+    # invokes'), which {Compiler.compile} merges.
+    #
+    # @api private
+    class Walk
+      include Numbering
+      include Content
+      include Parts
+
+      # The pieces the walk has numbered.
+      attr_reader :id_to_index, :states, :data
+
+      # The refusals, by group, in the order the groups merge.
+      attr_reader :groups
+
+      def initialize
+        @id_to_index = {}
+        @states = []
+        @pending = []
+        @data = []
+        @data_by_state = Hash.new { |hash, key| hash[key] = [] }
+        @c_next = 0
+        @groups = { transitions: [], content: [], donedata: [], invoke: [] }
+      end
+
+      # Numbers the whole chart, the root at index 0, the root's own `<data>`
+      # first.
+      def root(document)
+        assign_data(document.datamodel_element, 0)
+        children, after = siblings(document.states, 1, 0)
+        @states[0] = Machine::State.new(
+          index: 0, id: nil, kind: :scxml, parent: nil, last: after - 1, children:, history_type: nil,
+          initial: root_initial(document.initial, children), history_children: histories(children), **ROOT_PARTS,
+          data: owned_data(0),
+          **document.to_h.slice(:location, :attribute_locations)
+        )
+      end
+
+      # The root's default entry: its `initial` attribute, else its first
+      # child.
+      def root_initial(ids, children) = ids.empty? ? children.first(1).freeze : resolve(ids)
+
+      # Every transition, built now that every id has its index.
+      def transitions = @pending.map { build_transition(_1) }.freeze
+
+      # The next content index; a container takes its own before its
+      # children's.
+      def next_c_index
+        @c_next += 1
+        @c_next - 1
+      end
+    end
+  end
+end

data/lib/statifier/compiler.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "predicator"
+
+require_relative "document"
+require_relative "machine"
+require_relative "validator"
+require_relative "compiler/error"
+require_relative "compiler/expressions"
+require_relative "compiler/numbering"
+require_relative "compiler/content"
+require_relative "compiler/parts"
+require_relative "compiler/walk"
+
+module Statifier
+  # The validated chart in, the {Machine} out: the fourth step of reading a
+  # chart, a port of the reference's compiler.
+  #
+  # One walk ({Walk}) interns every state, transition, content node and
+  # `<data>` to an index in document order, and every expression compiles
+  # once, through predicator: conditions and values through
+  # `Predicator.compile`, `<script>` bodies through
+  # `Predicator.compile_program`. An expression predicator refuses is an
+  # {Error} with the reason `:expression_compile_error`, or, for the classes
+  # the reference defers (an `<assign>`'s `expr`, a `<data>`'s `expr`, a
+  # `namelist` entry and a `<script>` body), a {Machine::Invalid} on the
+  # node that fails when it runs.
+  #
+  # Collect-all: every load-time refusal is answered, in document order,
+  # and the machine only when there is none.
+  #
+  # @api private
+  module Compiler
+    # What {Compiler.compile} answers: the {Machine} as `value`, or every
+    # {Error}, in document order, as `errors`.
+    Result = ::Data.define(:value, :errors) do
+      # @return [Boolean] true when the chart compiled
+      def ok? = errors.empty?
+    end
+
+    # Compiles a validated chart into its machine.
+    #
+    # @param document [Document] the chart {Validator.validate} answered
+    # @param warnings [Array<Validator::Warning>] the validator's warnings,
+    #   kept on the machine
+    # @return [Result] the frozen {Machine}, or the {Error}s
+    def self.compile(document, warnings: [])
+      walk = Walk.new
+      walk.root(document)
+      transitions = walk.transitions
+      errors = sorted(walk.groups.values.flatten)
+      return Result.new(value: nil, errors: Ractor.make_shareable(errors)) unless errors.empty?
+
+      Result.new(value: Ractor.make_shareable(machine(walk, transitions, document, warnings)), errors: Walk::EMPTY)
+    end
+
+    # The machine of a walk that found no refusal.
+    def self.machine(walk, transitions, document, warnings)
+      Machine.new(
+        states: walk.states.freeze, id_to_index: walk.id_to_index.freeze, transitions:,
+        data_elements: walk.data.freeze, global_scripts: global_scripts(document.scripts),
+        **document.to_h.slice(:name, :datamodel, :binding, :location), warnings: warnings.dup.freeze
+      )
+    end
+
+    # The `<script>` children of `<scxml>`, each compiled as a program.
+    def self.global_scripts(scripts)
+      scripts.each_with_index.map do |script, index|
+        site = Expressions::Site.new(owner: { kind: :global_script, index: }, element: "script", attribute: nil,
+                                     location: script.location)
+        Expressions.program(script.text, site)
+      end.freeze
+    end
+
+    # The errors in document order, the groups' order kept at one offset.
+    def self.sorted(errors)
+      errors.each_with_index.sort_by { |error, index| [error.location.start_offset, index] }.map(&:first)
+    end
+
+    private_class_method :machine, :global_scripts, :sorted
+  end
+end