statifier 0.0.1 → 0.1.0

data/lib/statifier/interpreter/stop.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # The specification's `exitInterpreter`, as the reference ports it
+    # (`Statifier.Interpreter.exit_interpreter/1` in statifier-ex), with
+    # `returnDoneEvent` an effect: {Effect::Done}, answered last.
+    #
+    # @api private
+    module Stop
+      module_function
+
+      # `exitInterpreter`: every active state leaves in exit order, running
+      # its `<onexit>` blocks and then cancelling its live invocations, with
+      # no history recorded; the top-level final
+      # among them, if any, yields the donedata, and with none the donedata
+      # is nil. {Effect::Done} comes last, the status becomes `:done` and
+      # the internal queue is emptied, taking any event the exits raised
+      # with it, so a stopped chart is quiescent; the first
+      # `error.execution` folding the donedata raised survives as
+      # `donedata_error`. With tracing on an {Effect::Trace::ExitSet} comes
+      # first and an {Effect::Trace::Done} just before {Effect::Done}.
+      #
+      # @return [Stepped]
+      def exit_interpreter(state)
+        order = state.configuration.reverse.freeze
+        exited, effects, donedata, error = order.reduce([state, [], nil, nil]) { |acc, index| leave(acc, index) }
+        trace = Blocks.traced(state, Effect::Trace::ExitSet, indexes: order, configuration: exited.configuration)
+        done = done_effects(exited, donedata:, donedata_error: error, configuration: state.configuration)
+        Stepped.new(state: exited.with(status: :done, internal_queue: [].freeze), effects: trace + effects + done)
+      end
+
+      # The {Effect::Trace::Done} (when tracing) and the {Effect::Done} of a
+      # stop, the donedata and its error copied deeply frozen.
+      def done_effects(exited, donedata:, donedata_error:, configuration:)
+        fields = { donedata: Ractor.make_shareable(donedata, copy: true),
+                   donedata_error: Ractor.make_shareable(donedata_error, copy: true), configuration: }
+        Blocks.traced(exited, Effect::Trace::Done, **fields) + [Effect::Done.new(**fields, **exited.counters)]
+      end
+
+      # One state leaving at the stop: `[state, effects, donedata, error]`
+      # after it.
+      def leave((state, effects, donedata, error), index)
+        left = Blocks.run_blocks(state, :onexit, index)
+        left = left.then_step(Invoke::Passes.cancel_invocations(left.state, index))
+        state = left.state.with(configuration: (left.state.configuration - [index]).freeze)
+        donedata, error, state = collect_donedata(state, index) if top_level_final?(state.machine, index)
+        [state, effects + left.effects, donedata, error]
+      end
+
+      # Whether the state is a final whose parent is the root.
+      def top_level_final?(machine, index) = machine.final?(index) && machine.state(index).parent.zero?
+
+      # The top-level final's donedata and the data of the first
+      # `error.execution` folding it raised, `[data, error, state]`: the
+      # queue is read either side of the fold, so an event already queued is
+      # never taken for its own.
+      def collect_donedata(state, index)
+        before = state.internal_queue.size
+        state, data = Blocks.donedata(state, index)
+        raised = state.internal_queue.drop(before).find { _1.name == "error.execution" }
+        [data, raised&.data, state]
+      end
+    end
+  end
+end

data/lib/statifier/interpreter/targets.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Interpreter
+    # What a `<send>`'s resolved target and type name, and whether the core
+    # refuses them, as the reference judges them (`Statifier.Send.Target`,
+    # `Statifier.Send.Types` and `Statifier.Send.Routes` in statifier-ex).
+    # Pure over values: whether a destination exists is the driver's.
+    #
+    # @api private
+    module Targets
+      # What the driver declares a session can reach: `sessions`, the
+      # session ids a `#_scxml_` target may name; `parent?`, whether the
+      # session has a parent (the reference's `parent?`, spelled the same);
+      # and `invokes`, the invoke ids a `#_` target may name. The session
+      # itself and its internal queue need no entry.
+      Routes = ::Data.define(:sessions, :parent?, :invokes) do
+        # Whether `route` (a {Route}) is reachable.
+        def reachable?(route)
+          case route.kind
+          when :self, :internal then true
+          when :session then sessions.include?(route.id)
+          when :parent then parent?
+          when :invoke then invokes.include?(route.id)
+          else false
+          end
+        end
+      end
+
+      # What a resolved target names: `kind` one of `:self` (no target),
+      # `:internal`, `:parent`, `:session` and `:invoke` (with `id`, the
+      # session or invoke id), and `:invalid` (with `id`, the target as
+      # resolved).
+      Route = ::Data.define(:kind, :id)
+
+      # The type is neither the SCXML processor's nor a registered one.
+      UnsupportedType = ::Data.define(:type)
+
+      # The target names nothing the SCXML processor carries.
+      InvalidTarget = ::Data.define(:target)
+
+      # The declared routes do not reach the target.
+      UnreachableTarget = ::Data.define(:target)
+
+      module_function
+
+      # Parses a resolved target. Both spellings of the internal and parent
+      # targets, with and without the leading `#`, are accepted, as the
+      # reference accepts them; anything that is not one of the special
+      # targets is invalid.
+      #
+      # @return [Route]
+      def parse_target(target)
+        return Route.new(kind: :self, id: nil) if target.nil?
+        return Route.new(kind: :invalid, id: target) unless target.is_a?(String)
+
+        case target
+        when "#_internal", "_internal" then Route.new(kind: :internal, id: nil)
+        when "#_parent", "_parent" then Route.new(kind: :parent, id: nil)
+        when /\A#_scxml_(.+)\z/m then Route.new(kind: :session, id: ::Regexp.last_match(1))
+        when /\A#_(.+)\z/m then Route.new(kind: :invoke, id: ::Regexp.last_match(1))
+        else Route.new(kind: :invalid, id: target)
+        end
+      end
+
+      # Whether the SCXML processor carries `type`: no type, its short form
+      # `scxml`, or its URI.
+      def built_in_type?(type)
+        type.nil? || type == "scxml" || type == Datamodel::SystemVariables::SCXML_EVENT_PROCESSOR
+      end
+
+      # How a resolved type is carried: `:built_in`, `:registered` (a String
+      # in `send_types`, the registered types or nil for none) or
+      # `:unsupported`. A built-in spelling stays built in whatever the host
+      # registered.
+      def classify(send_types, type)
+        return :built_in if built_in_type?(type)
+        return :registered if type.is_a?(String) && send_types&.include?(type)
+
+        :unsupported
+      end
+
+      # Why a send is refused, as `[kind, reason]` with `kind` the `error.*`
+      # event it raises (`:execution` or `:communication`), or nil. The type
+      # is judged first; a registered type's target is its processor's own
+      # and never parsed; with `routes` declared, an immediate send's target
+      # must be reachable, while a delayed one (`delay_ms` set) is routed
+      # when it fires.
+      def reject_reason(target, type, delay_ms, send_types, routes)
+        case classify(send_types, type)
+        when :unsupported then [:execution, UnsupportedType.new(type:)]
+        when :registered then nil
+        else target_reason(target, delay_ms, routes)
+        end
+      end
+
+      # A target's refusal under the SCXML processor, or nil.
+      def target_reason(target, delay_ms, routes)
+        route = parse_target(target)
+        return [:execution, InvalidTarget.new(target:)] if route.kind == :invalid
+        return nil if routes.nil? || !delay_ms.nil? || routes.reachable?(route)
+
+        [:communication, UnreachableTarget.new(target:)]
+      end
+    end
+  end
+end

data/lib/statifier/interpreter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "machine"
+require_relative "datamodel"
+require_relative "frozen"
+require_relative "effect"
+require_relative "event"
+
+module Statifier
+  # The interpreter's algorithm, ported function for function from the
+  # specification's Appendix D pseudocode as the reference ports it: which
+  # transitions an event enables ({Selection}, with the event-name matcher
+  # {NameMatch}), what those transitions enter ({Entering}), and which
+  # states they leave and enter, in order ({ExitEntry}); and what a block of
+  # executable content does ({Content}, with `<send>` and `<cancel>` in
+  # {Send}); and the loop over them ({Loop}, with {Step}, {Blocks},
+  # {Macrostep} and {Stop}), which starts a chart, takes an event and runs
+  # each macrostep over a {MachineState}.
+  #
+  # Every function here is pure over plain values: a machine, a
+  # configuration, the recorded history, and, where an expression is
+  # evaluated, the datamodel. Below the loop none of them moves a queue or
+  # keeps state; each answers what the step that calls it needs as a frozen
+  # value (the datamodel a block leaves, its effects and the events it raised
+  # included). The loop threads one {MachineState} through them and answers
+  # the state it leaves, never changing the one it was given.
+  #
+  # @api private
+  module Interpreter
+    # What selection, exit and entry read of an execution, the two globals
+    # the pseudocode keeps beside the chart: `machine`, the compiled chart;
+    # `configuration`, the indexes of the active states as a frozen Array in
+    # ascending index order (document order); and `history`, the recorded
+    # value of each history state that has one, a frozen Hash of the history
+    # state's index to a frozen ascending Array of state indexes.
+    Snapshot = ::Data.define(:machine, :configuration, :history) do
+      # Whether the state at `index` is active.
+      def active?(index) = configuration.include?(index)
+    end
+  end
+end
+
+require_relative "interpreter/name_match"
+require_relative "interpreter/selection"
+require_relative "interpreter/entering"
+require_relative "interpreter/exit_entry"
+require_relative "interpreter/targets"
+require_relative "interpreter/send"
+require_relative "interpreter/content"
+require_relative "interpreter/foreach"
+require_relative "interpreter/machine_state"
+require_relative "interpreter/blocks"
+require_relative "interpreter/invoke"
+require_relative "interpreter/step"
+require_relative "interpreter/macrostep"
+require_relative "interpreter/stop"
+require_relative "interpreter/loop"

data/lib/statifier/lowering/branches.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Lowering
+    # The builders of `<if>`, `<elseif>`, `<else>` and `<foreach>`.
+    #
+    # @api private
+    module Executable
+      module_function
+
+      # An `<if>` is folded into partitions: the first branch is the `<if>`'s
+      # own, each `<elseif>` or `<else>` opens the next, and executable
+      # content joins whichever branch is open.
+      def if_node(element, source)
+        results, errors = Lowering.walk_children(element, source)
+        cond = Reading.value(element, "cond")
+        return [nil, errors + [Errors.missing_attribute("if", "cond", element.location)]] if cond.nil?
+
+        first = branch(element, cond, Reading.locations(element, %w[cond]))
+        branches, misplaced = partition(results, first, element.name)
+        [[:content_node, Document::If.new(location: element.location, branches:)], errors + misplaced]
+      end
+
+      # An `<elseif>` takes no children; it is a partition mark for its `<if>`.
+      def elseif(element, _source)
+        errors = misplaced_children(element, "elseif")
+        cond = Reading.value(element, "cond")
+        return [nil, errors + [Errors.missing_attribute("elseif", "cond", element.location)]] if cond.nil?
+
+        [[:elseif, branch(element, cond, Reading.locations(element, %w[cond]))], errors]
+      end
+
+      # An `<else>` takes no attributes: the first one written is refused,
+      # and the branch is made all the same.
+      def else_node(element, _source)
+        errors = misplaced_children(element, "else")
+        first = element.attributes.first
+        errors += [Errors.unexpected_attribute("else", first.name, first.location)] if first
+        [[:else, branch(element, nil, Reading::NO_LOCATIONS)], errors]
+      end
+
+      # Both required attributes are checked before the node is given up, so
+      # a `<foreach>` missing both reports both.
+      def foreach(element, source)
+        results, errors = Lowering.walk_children(element, source)
+        missing = %w[item array].select { |name| Reading.value(element, name).nil? }
+        unless missing.empty?
+          return [nil, errors + missing.map { Errors.missing_attribute("foreach", _1, element.location) }]
+        end
+
+        filled, misplaced = Placement.fold(results, Placement::CONTENT, element.name)
+        [[:content_node, foreach_node(element, Placement.many(filled, :content))], errors + misplaced]
+      end
+
+      # The node of a `<foreach>` whose required attributes were written.
+      def foreach_node(element, content)
+        Document::Foreach.new(
+          location: element.location, array: Reading.value(element, "array"), item: Reading.value(element, "item"),
+          index: Reading.value(element, "index"), content:,
+          attribute_locations: Reading.locations(element, %w[array item index])
+        )
+      end
+
+      # A branch opened by `element`, holding no content yet.
+      def branch(element, cond, attribute_locations)
+        Document::If::Branch.new(location: element.location, cond:, content: Reading::EMPTY, attribute_locations:)
+      end
+
+      # Folds an `<if>`'s lowered children into its branches.
+      def partition(results, first, parent_name)
+        open = [[first, []]]
+        errors = []
+        results.compact.each do |tag, node|
+          case tag
+          when :content_node then open.last.last << node
+          when :elseif, :else then open << [node, []]
+          else errors.unshift(Placement.misplaced(tag, node, parent_name))
+          end
+        end
+        [open.map { |opened, content| opened.with(content: content.freeze) }.freeze, errors]
+      end
+    end
+  end
+end

data/lib/statifier/lowering/data.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Lowering
+    # The builders of `<datamodel>`, `<data>`, `<donedata>`, `<param>`,
+    # `<content>` and `<invoke>`, and the markup slice `<content>` and
+    # `<assign>` share.
+    #
+    # @api private
+    module DataModel
+      DATAMODEL_SLOTS = { data: %i[data many] }.freeze
+      DONEDATA_SLOTS = { content: %i[content one], param: %i[params many] }.freeze
+      INVOKE_SLOTS = { param: %i[params many], content: %i[content one], finalize: %i[finalize one] }.freeze
+      INVOKE_ATTRIBUTES = %w[type typeexpr src srcexpr id idlocation].freeze
+      AUTOFORWARD = { "true" => true, "false" => false }.freeze
+
+      module_function
+
+      # A `<datamodel>`: its `<data>` children.
+      def datamodel(element, source)
+        filled, errors = States.lower_children(element, source, DATAMODEL_SLOTS)
+        [[:datamodel, Document::Datamodel.new(location: element.location, data: Placement.many(filled, :data))],
+         errors]
+      end
+
+      # A `<data>` holds text, not markup: its text is its value and each
+      # element child is misplaced.
+      def data(element, _source)
+        errors = Executable.misplaced_children(element, "data")
+        id = Reading.value(element, "id")
+        return [nil, errors + [Errors.missing_attribute("data", "id", element.location)]] if id.nil?
+
+        node = Document::Data.new(
+          location: element.location, id:, expr: Reading.value(element, "expr"),
+          src: Reading.value(element, "src"), text: Reading.text(element),
+          attribute_locations: Reading.locations(element, %w[id expr src])
+        )
+        [[:data, node], errors]
+      end
+
+      # A `<donedata>`: its `<param>` children and its last `<content>`.
+      def donedata(element, source)
+        filled, errors = States.lower_children(element, source, DONEDATA_SLOTS)
+        node = Document::Donedata.new(location: element.location, content: filled[:content],
+                                      params: Placement.many(filled, :params))
+        [[:donedata, node], errors]
+      end
+
+      # A `<param>`, which needs its `name`; its `location` attribute is
+      # `param_location`.
+      def param(element, source)
+        Executable.required(element, source, Executable::NO_SLOTS, "name") do |name, _filled|
+          [:param, Document::Param.new(
+            location: element.location, name:, expr: Reading.value(element, "expr"),
+            param_location: Reading.value(element, "location"),
+            attribute_locations: Reading.locations(element, %w[name expr location])
+          )]
+        end
+      end
+
+      # The children of a `<content>` are its payload and are never walked.
+      def content(element, source)
+        markup, markup_location = markup(element, source)
+        node = Document::Content.new(
+          location: element.location, expr: Reading.value(element, "expr"), text: Reading.text(element),
+          markup:, markup_location:, attribute_locations: Reading.locations(element, %w[expr])
+        )
+        [[:content, node], Reading::EMPTY]
+      end
+
+      # An `<invoke>`: its attributes, its `<param>` children, and its last
+      # `<content>` and `<finalize>`.
+      def invoke(element, source)
+        filled, errors = States.lower_children(element, source, INVOKE_SLOTS)
+        fields = INVOKE_ATTRIBUTES.to_h { |name| [name.to_sym, Reading.value(element, name)] }
+        node = Document::Invoke.new(
+          location: element.location, **fields, namelist: Reading.list(element, "namelist"),
+          autoforward: Reading.choice(element, "autoforward", AUTOFORWARD, false),
+          params: Placement.many(filled, :params), content: filled[:content], finalize: filled[:finalize],
+          attribute_locations: Reading.locations(element, [*INVOKE_ATTRIBUTES, "namelist", "autoforward"])
+        )
+        [[:invoke, node], errors]
+      end
+
+      # The source of an element's children from the first that is not blank
+      # text to the last, line breaks as written, and its span; both nil when
+      # it has no element child.
+      def markup(element, source)
+        significant = element.children.reject { |child| child.is_a?(XML::Text) && Reading.blank?(child.value) }
+        return [nil, nil] unless significant.any?(XML::Element)
+
+        span = across(significant.first.location, significant.last.location)
+        [span.slice(source).freeze, span]
+      end
+
+      # The span from the start of `first` to the end of `last`.
+      def across(first, last)
+        first.with(end_line: last.end_line, end_column: last.end_column, end_offset: last.end_offset)
+      end
+    end
+  end
+end

data/lib/statifier/lowering/error.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Lowering
+    # Why a tree did not lower: a reason symbol, the detail that reason
+    # carries (a frozen Hash), a message for a person, and the span of the
+    # element, attribute or text refused. The reasons and their details:
+    #
+    # - `:unsupported_element` (`name`): an element in SCXML's vocabulary
+    #   that no builder reads, `<scxml>` below the root included;
+    # - `:misplaced_element` (`name`, `parent`): an element its parent has
+    #   no place for;
+    # - `:stray_text` (`text`, trimmed): text that is not blank where the
+    #   content model has no room for it;
+    # - `:unexpected_root` (`name`): a root that is not `<scxml>`;
+    # - `:missing_attribute` (`element`, `attribute`): a required attribute
+    #   absent, so the element's node cannot be made;
+    # - `:foreign_element` (`name`, `uri`): an element in another namespace;
+    # - `:unexpected_attribute` (`element`, `attribute`): an attribute on
+    #   `<else>`, which takes none;
+    # - `:unsupported_attribute` (`element`, `attribute`): `<script src>`,
+    #   which the specification defines and this engine does not fetch.
+    #
+    # @api private
+    Error = ::Data.define(:reason, :detail, :message, :location)
+
+    # The constructors of {Error}, one per reason, with the reference's
+    # messages.
+    #
+    # @api private
+    module Errors
+      # The edge characters a trim removes: Unicode white space.
+      TRIM = "\\t\\n\\v\\f\\r \\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000"
+      TRIM_EDGES = /\A[#{TRIM}]+|[#{TRIM}]+\z/
+      PREVIEW = 40
+      ESCAPES = { "\\" => "\\\\", '"' => "\\\"", "\n" => "\\n", "\t" => "\\t", "\r" => "\\r", "\#{" => "\\\#{" }.freeze
+
+      module_function
+
+      # @return [Error] `:unsupported_element`
+      def unsupported(name, location)
+        make(:unsupported_element, { name: }, "unsupported element #{quote(name)}", location)
+      end
+
+      # @return [Error] `:misplaced_element`
+      def misplaced(name, parent, location)
+        make(:misplaced_element, { name:, parent: },
+             "element #{quote(name)} is not allowed inside #{quote(parent)}", location)
+      end
+
+      # @return [Error] `:stray_text`, the message quoting at most the first
+      #   40 characters of the trimmed text
+      def stray_text(text, location)
+        trimmed = trim(text)
+        clusters = trimmed.grapheme_clusters
+        preview = clusters.size > PREVIEW ? "#{clusters.first(PREVIEW).join}..." : trimmed
+        make(:stray_text, { text: trimmed }, "stray text #{quote(preview)} is not allowed here", location)
+      end
+
+      # @return [Error] `:unexpected_root`
+      def unexpected_root(name, location)
+        make(:unexpected_root, { name: }, "expected the document root to be <scxml>, got #{quote(name)}", location)
+      end
+
+      # @return [Error] `:missing_attribute`
+      def missing_attribute(element, attribute, location)
+        make(:missing_attribute, { element:, attribute: },
+             "element #{quote(element)} is missing required attribute #{quote(attribute)}", location)
+      end
+
+      # @return [Error] `:foreign_element`
+      def foreign_element(name, uri, location)
+        make(:foreign_element, { name:, uri: },
+             "element #{quote(name)} is bound to foreign namespace #{quote(uri)}, not SCXML", location)
+      end
+
+      # @return [Error] `:unexpected_attribute`
+      def unexpected_attribute(element, attribute, location)
+        make(:unexpected_attribute, { element:, attribute: },
+             "element #{quote(element)} does not accept attribute #{quote(attribute)}", location)
+      end
+
+      # @return [Error] `:unsupported_attribute`
+      def unsupported_attribute(element, attribute, location)
+        make(:unsupported_attribute, { element:, attribute: },
+             "element #{quote(element)}'s #{quote(attribute)} attribute is defined by the spec " \
+             "but not implemented by this engine", location)
+      end
+
+      # `text` with Unicode white space trimmed from both ends.
+      def trim(text) = text.gsub(TRIM_EDGES, "").freeze
+
+      # `text` in double quotes, escaped as the reference quotes it.
+      def quote(text) = %("#{text.gsub(/\\|"|\n|\t|\r|\#\{/, ESCAPES)}").freeze
+
+      # An {Error} with its detail and message frozen.
+      def make(reason, detail, message, location)
+        Error.new(reason:, detail: detail.transform_values(&:freeze).freeze, message: message.freeze, location:)
+      end
+    end
+  end
+end

data/lib/statifier/lowering/executable.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Statifier
+  module Lowering
+    # The builders of executable content. A node that a required attribute
+    # is missing from is not made: its builder answers nil and the error.
+    #
+    # @api private
+    module Executable
+      NO_SLOTS = {}.freeze
+      SEND_SLOTS = { param: %i[params many], content: %i[content one] }.freeze
+      SEND_ATTRIBUTES = %w[event eventexpr target targetexpr type typeexpr id idlocation delay delayexpr].freeze
+
+      module_function
+
+      # A `<raise>`'s `event` is one string, not split.
+      def raise_node(element, source)
+        required(element, source, NO_SLOTS, "event") do |event, _filled|
+          [:content_node, Document::Raise.new(location: element.location, event:,
+                                              attribute_locations: Reading.locations(element, %w[event]))]
+        end
+      end
+
+      # A `<log>`: its `label` and `expr`; it takes no children.
+      def log(element, source)
+        _filled, errors = States.lower_children(element, source, NO_SLOTS)
+        node = Document::Log.new(location: element.location, label: Reading.value(element, "label"),
+                                 expr: Reading.value(element, "expr"),
+                                 attribute_locations: Reading.locations(element, %w[label expr]))
+        [[:content_node, node], errors]
+      end
+
+      # An `<assign>`'s children are its in-line value and are never walked.
+      def assign(element, source)
+        path = Reading.value(element, "location")
+        return [nil, [Errors.missing_attribute("assign", "location", element.location)]] if path.nil?
+
+        markup, markup_location = DataModel.markup(element, source)
+        node = Document::Assign.new(
+          location: path, node_location: element.location, expr: Reading.value(element, "expr"),
+          text: Reading.text(element), markup:, markup_location:,
+          attribute_locations: Reading.locations(element, %w[location expr])
+        )
+        [[:content_node, node], Reading::EMPTY]
+      end
+
+      # A `<send>`: its attributes, its `<param>` children and its last
+      # `<content>`.
+      def send_node(element, source)
+        filled, errors = States.lower_children(element, source, SEND_SLOTS)
+        fields = SEND_ATTRIBUTES.to_h { |name| [name.to_sym, Reading.value(element, name)] }
+        node = Document::Send.new(
+          location: element.location, **fields, namelist: Reading.list(element, "namelist"),
+          params: Placement.many(filled, :params), content: filled[:content],
+          attribute_locations: Reading.locations(element, [*SEND_ATTRIBUTES, "namelist"])
+        )
+        [[:content_node, node], errors]
+      end
+
+      # A `<cancel>`: its `sendid` and `sendidexpr`; it takes no children.
+      def cancel(element, source)
+        _filled, errors = States.lower_children(element, source, NO_SLOTS)
+        node = Document::Cancel.new(location: element.location, sendid: Reading.value(element, "sendid"),
+                                    sendidexpr: Reading.value(element, "sendidexpr"),
+                                    attribute_locations: Reading.locations(element, %w[sendid sendidexpr]))
+        [[:content_node, node], errors]
+      end
+
+      # A `<script>`'s text is its program. A `src` names a program to fetch,
+      # and nothing is fetched, so a `<script src>` does not lower.
+      def script(element, _source)
+        errors = misplaced_children(element, "script")
+        if Reading.attribute(element, "src")
+          return [nil, errors + [Errors.unsupported_attribute("script", "src", element.location)]]
+        end
+
+        node = Document::Script.new(location: element.location, text: Reading.text(element), src: nil,
+                                    attribute_locations: Reading::NO_LOCATIONS)
+        [[:content_node, node], errors]
+      end
+
+      # Lowers an element whose node needs the attribute `name`: walks its
+      # children, then answers nil and the missing-attribute error when it is
+      # absent, or the node the block makes from its value and the filled
+      # fields (the block answers it tagged), with the misplaced children.
+      def required(element, source, slots, name)
+        results, errors = Lowering.walk_children(element, source)
+        value = Reading.value(element, name)
+        return [nil, errors + [Errors.missing_attribute(local(element), name, element.location)]] if value.nil?
+
+        filled, misplaced = Placement.fold(results, slots, element.name)
+        [yield(value, filled), errors + misplaced]
+      end
+
+      # Each element child of an element that holds only text, misplaced.
+      def misplaced_children(element, parent)
+        element.children.grep(XML::Element).map { |child| Errors.misplaced(child.name, parent, child.location) }
+      end
+
+      # The local name of `element`, its prefix dropped.
+      def local(element) = element.name.split(":", 2).last
+    end
+  end
+end
+
+require_relative "branches"