hecks 3.9.1 → 3.11.0

data/lib/hecks/bluebook/dsl/bootstrap_table.rb

@@ -30,6 +30,7 @@ module Hecks
           ["Aggregate", "given"] => :given_impl,
           ["Aggregate", "projects"] => :projects_impl,
           ["Lifecycle", "transition"] => :transition_impl,
+          ["Lifecycle", "mark"] => :mark_impl,
           ["Bluebook", "attaches_to"] => :attaches_to_impl,
           ["Bluebook", "provides"] => :provides_impl,
           ["Bluebook", "aggregate"] => :aggregate_impl,
@@ -57,6 +58,7 @@ module Hecks
           ["Entity", "entity"] => :entity_impl,
           ["Policy", "on"] => :on_impl,
           ["Policy", "trigger"] => :trigger_impl,
+          ["Policy", "ask"] => :ask_impl,
           ["Policy", "across"] => :across_impl,
           ["ProcessManager", "starts_on"] => :starts_on_impl,
           ["ProcessManager", "ends_on"] => :ends_on_impl,

data/lib/hecks/bluebook/dsl/command_builder/mutations.rb

@@ -28,7 +28,7 @@ module Hecks
         # @raise [ArgumentError] on any other keyword
         def sets_impl(target, positional_to = UNSET, **ops)
           refuse_unknown_ops!(ops, KWARG_TO_OP.keys)
-          ops = ops.merge(to: positional_to) unless ops.key?(:to) || positional_to.equal?(UNSET)
+          ops = source_of_to(ops, positional_to)
 
           # Only a Symbol can repeat the target's name; a literal value (`to: false`,
           # a String, ...) never has `.to_sym` to compare in the first place.
@@ -98,6 +98,13 @@ module Hecks
 
         private
 
+        # Folds a positional source into `to:`, and reads arithmetic written there
+        # (`to: paid * rate / 100`) as the source it spells.
+        def source_of_to(ops, positional_to)
+          ops = ops.merge(to: positional_to) unless ops.key?(:to) || positional_to.equal?(UNSET)
+          ops[:to].is_a?(Operands::Computation) ? ops.merge(to: ops[:to].to_source) : ops
+        end
+
         # A command's effects are one update set over the pre-dispatch state — a field
         # written twice would make declaration order silently significant.
         def refuse_duplicate_targets!

data/lib/hecks/bluebook/dsl/command_builder/operands.rb

@@ -0,0 +1,121 @@
+module Hecks
+  module Bluebook
+    module DSL
+      class CommandBuilder
+        # Lets a bluebook write arithmetic where a `sets` takes its source: inside a command, a bare
+        # name that is one of its arguments or one of its owner's fields reads as an operand, and
+        # `+ - * /` over operands and numbers build a {Hecks::Computed}.
+        #
+        #     sets :refund_cents, to: paid_cents * late_percent / 100
+        module Operands
+          # One node of the arithmetic a `sets` source spells: an operand name, a number, or two
+          # nodes joined by an operator. Renders the canonical text the expression grammar reads,
+          # parenthesised only where the written grouping needs it.
+          class Computation
+            # Binding strength of each operator; `*` and `/` bind tighter than `+` and `-`.
+            PRECEDENCE = { :+ => 1, :- => 1, :* => 2, :/ => 2 }.freeze
+
+            attr_reader :operator, :left, :right
+
+            # @param operator [Symbol, nil] the joining operator, or nil for a name or number
+            # @param left [Object] the operand name or number, or the left node
+            # @param right [Object, nil] the right node of a joined pair
+            def initialize(operator, left, right = nil)
+              @operator = operator
+              @left = left
+              @right = right
+            end
+
+            PRECEDENCE.each_key do |operator|
+              define_method(operator) { |other| Computation.new(operator, self, Computation.wrap(other)) }
+            end
+
+            # Lets `100 * paid` work: Ruby asks the right-hand operand to coerce the number.
+            #
+            # @return [Array<Computation>] the number and this node, as a left and right pair
+            def coerce(number) = [Computation.wrap(number), self]
+
+            # @return [Hecks::Computed, Symbol, Numeric] the source a `sets` records: the canonical
+            #   text of joined arithmetic, or for a lone operand its argument name, or its number
+            def to_source
+              return Computed.new(to_text) if operator
+
+              return left if left.is_a?(Numeric)
+
+              path? ? Computed.new(left.to_s) : left.to_sym
+            end
+
+            # Reaches a field of the value object a name holds: `charged.cents` is the operand
+            # `charged` followed by its field `cents`, read by the same dotted path a `given` reads.
+            #
+            # @return [Computation] the operand extended by one path segment
+            def method_missing(field, *args, &block)
+              return super unless field_read?(args, block)
+
+              Computation.new(nil, "#{left}.#{field}")
+            end
+
+            def respond_to_missing?(field, include_private = false) = field_read?([], nil) || super
+
+            # @return [Boolean] whether this operand is a dotted path into a value object
+            def path? = left.to_s.include?(".")
+
+            # @return [String] the expression text, such as `paid * rate / 100`
+            def to_text
+              return operand_text unless operator
+
+              "#{side_text(left, false)} #{operator} #{side_text(right, true)}"
+            end
+
+            # @param value [Computation, Numeric] a node or a number
+            # @return [Computation] the node, or the number wrapped as one
+            # @raise [Bluebook::DSL::Malformed] if `value` is neither
+            def self.wrap(value)
+              return value if value.is_a?(Computation)
+              return new(nil, value) if value.is_a?(Numeric)
+
+              raise Malformed, "a sets expression joins argument names and numbers, not #{value.inspect}"
+            end
+
+            private
+
+            def operand_text = left.to_s
+
+            # Only a bare name (or an existing path) can be followed by a field.
+            def field_read?(args, block) = operator.nil? && !left.is_a?(Numeric) && args.empty? && block.nil?
+
+            # A joined side is parenthesised when it binds looser than this operator, or equally
+            # on the right, so the printed text parses back to the same grouping.
+            def side_text(side, right_side)
+              return side.to_text unless side.operator
+
+              looser = PRECEDENCE.fetch(side.operator) < PRECEDENCE.fetch(operator)
+              equal_on_right = right_side && PRECEDENCE.fetch(side.operator) == PRECEDENCE.fetch(operator)
+              looser || equal_on_right ? "(#{side.to_text})" : side.to_text
+            end
+          end
+
+          private
+
+          # A bare name the command declares as an argument, or its owner declares as a field,
+          # is an operand; anything else keeps the builder's own answer.
+          def method_missing(word, *args, **kwargs, &block)
+            return Computation.new(nil, word) if operand?(word, args, kwargs, block)
+
+            super
+          end
+
+          def respond_to_missing?(word, include_private = false)
+            operand?(word, [], {}, nil) || super
+          end
+
+          def operand?(word, args, kwargs, block)
+            return false unless args.empty? && kwargs.empty? && block.nil?
+
+            attributes.any? { |attr| attr.name == word } || @owner_attributes.any? { |attr| attr.name == word }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/dsl/command_builder.rb

@@ -4,6 +4,7 @@ require_relative "command_builder/owner"
 require_relative "command_builder/rules"
 require_relative "command_builder/mutations"
 require_relative "command_builder/implicit_attributes"
+require_relative "command_builder/operands"
 module Hecks
   module Bluebook
     module DSL
@@ -17,6 +18,7 @@ module Hecks
         include WordGate
         include NeedWord
         include ImplicitAttributes
+        include Operands
 
         # Sentinel for "this keyword was never passed" — distinct from Ruby's own
         # nil/false, so `to: false` doesn't get treated as absent.

data/lib/hecks/bluebook/dsl/hecksagon_builder.rb

@@ -44,6 +44,7 @@ module Hecks
           @binds              = []
           @subscriptions      = []
           @attachments        = []
+          @driving            = []
           @bounded            = false
           @translates         = []
         end
@@ -57,6 +58,13 @@ module Hecks
         # Subscribes to an event from outside this domain's own bluebook.
         def subscribe(event) = @subscriptions << event.to_s
 
+        # Admits a driving adapter (`Ruby`, `Cli`, `Json` or `Mcp`) to reach this domain. Once any
+        # is declared, the adapters left out refuse the domain; none declared leaves it open.
+        #
+        # @param adapter [String, Symbol] the adapter's name
+        # @return [void]
+        def driven_by(adapter) = @driving << adapter.to_s
+
         # Attaches a chapter by name and loads it into the current registry, marked bounded.
         #
         # Without `from:` the name is a chapter the gem carries (a framework member such as
@@ -111,7 +119,8 @@ module Hecks
         # No ungoverned-role check here — it runs once on the merged result at verify! time.
         def build
           Hecksagon.new(domain: @domain, binds: @binds, subscriptions: @subscriptions,
-                        attachments: @attachments, bounded: @bounded, translates: @translates)
+                        attachments: @attachments, bounded: @bounded, translates: @translates,
+                        driving: @driving)
         end
 
         # Loads a chapter the gem carries and records it as attached from the gem.

data/lib/hecks/bluebook/dsl/lifecycle_builder.rb

@@ -14,6 +14,32 @@ module Hecks
           @field       = field
           @default     = default
           @transitions = []
+          @marks       = {}
+        end
+
+        # Names a meaning and the states that carry it, such as
+        # `mark :holds_seat, "pending", "succeeded"`.
+        #
+        # Listed in `BOOTSTRAP_CALLS_FALLBACK` because syntax.bluebook uses it during boot.
+        #
+        # @param name [Symbol, String] a lowercase word (`holds_seat`)
+        # @param states [Array<String, Symbol>] one or more states, each named once
+        # @return [Array<String>] the states just recorded
+        # @raise [Bluebook::DSL::Malformed] for a name that is not a lowercase word, a name
+        #   declared twice, no states, or a state named twice in one mark
+        def mark_impl(name, *states)
+          mark = name.to_s
+          unless mark.match?(/\A[a-z][a-z0-9_]*\z/)
+            raise Malformed, "lifecycle :#{@field} mark #{name.inspect} is not a lowercase word (such as :holds_seat)"
+          end
+          raise Malformed, "lifecycle :#{@field} declares mark :#{mark} twice" if @marks.key?(mark)
+          raise Malformed, "lifecycle :#{@field} mark :#{mark} names no states" if states.empty?
+
+          names = states.map(&:to_s)
+          twice = names.find { |state| names.count(state) > 1 }
+          raise Malformed, "lifecycle :#{@field} mark :#{mark} names state #{twice.inspect} twice" if twice
+
+          @marks[mark] = names
         end
 
         # Records one transition row per command in `mapping`, all sharing its `from:` guard.
@@ -40,10 +66,12 @@ module Hecks
         #
         # @return [Bluebook::Lifecycle] the state machine: its field, default and transitions
         # @raise [Bluebook::DSL::Malformed] if two transitions for one command could both apply
-        #   from the same state (C5.3); skipped while shadow-parsing frozen era text
+        #   from the same state (C5.3; skipped while shadow-parsing frozen era text), or a mark
+        #   names a state the lifecycle does not have
         def build
           refuse_ambiguity!
-          Lifecycle.new(field: @field, default: @default, transitions: @transitions)
+          refuse_unknown_mark_states!
+          Lifecycle.new(field: @field, default: @default, transitions: @transitions, marks: @marks)
         end
 
         # Evaluates a `lifecycle` block against a fresh builder and returns what it built.
@@ -62,6 +90,21 @@ module Hecks
 
         private
 
+        # A mark may name only the default or a transition target: anything else is a typo that
+        # would silently mark nothing. (A `from:` state is not enough; it is not reachable.)
+        def refuse_unknown_mark_states!
+          known = ([@default] + @transitions.map { |(_command, transition)| transition.target }).map(&:to_s)
+
+          @marks.each do |mark, states|
+            unknown = states - known
+            next if unknown.empty?
+
+            raise Malformed,
+                  "lifecycle :#{@field} mark :#{mark} names #{unknown.map(&:inspect).join(", ")}, which " \
+                  "is not a state of the lifecycle (states: #{known.uniq.join(", ")})"
+          end
+        end
+
         # C5.3 (docs/semantics/bluebook-semantics.md): overlapping `from:` sets for one command
         # are refused. Disjoint sets are legitimate. An undeclared `from:` state is left to
         # `hecks model_check`.

data/lib/hecks/bluebook/dsl/policy_builder.rb

@@ -39,6 +39,8 @@ module Hecks
         # @return [void]
         # @raise [Bluebook::DSL::Malformed] if `command_ref` is quoted text outside shadow-parsing
         def trigger_impl(command_ref, with: nil)
+          raise Malformed, "#{@name} declares both a trigger and an ask — a policy does one" if @ask
+
           if command_ref.is_a?(::String) && !MetaValidator.shadow_parsing?
             raise Malformed,
                   "#{@name}'s trigger #{command_ref.inspect} is quoted text — give the bare command " \
@@ -50,6 +52,26 @@ module Hecks
           @projection_declared = !with.nil?
         end
 
+        # Records the need this policy puts to the outside, in the domain's own words.
+        #
+        # The runtime resolves the name against the hecksagon's declared asks (the event's
+        # aggregate and the ask's name) and dispatches the port operation the match names, as
+        # `trigger` would have. `with:` projects the event onto the operation as it does for
+        # `trigger`.
+        #
+        # @param name [Symbol, String] the need, such as `:check`
+        # @param with [Hash{Symbol => Object}, nil] event payload to operation arguments;
+        #   `nil` forwards the whole payload
+        # @return [void]
+        # @raise [Bluebook::DSL::Malformed] if the policy already triggers a command
+        def ask_impl(name, with: nil)
+          raise Malformed, "#{@name} declares both a trigger and an ask — a policy does one" if @trigger_command
+
+          @ask = name.to_s
+          @with_spec = (with || {}).to_a
+          @projection_declared = !with.nil?
+        end
+
         # Records the domain this policy's trigger reaches into.
         #
         # `expect_undelivered: true` declares that the target is expected never to be reached
@@ -96,16 +118,9 @@ module Hecks
         # @return [Bluebook::Policy] the built policy, carrying every field set by `on`,
         #   `trigger`, `across`, `where`, `for_each`, and `with:`
         def build
-          Policy.new(
-            name:               @name,
-            on_event:           @on_event,
-            trigger_command:    @trigger_command,
-            target_domain:      @target_domain,
-            expect_undelivered: @expect_undelivered || false,
-            where:              @where,
-            for_each:           @for_each,
-            with_spec:          @with_spec || []
-          ).tap { |policy| policy.instance_variable_set(:@projection_declared, !!@projection_declared) }
+          refuse_ask_across!
+          Policy.new(**reaction_fields, **guard_fields)
+                .tap { |policy| policy.instance_variable_set(:@projection_declared, !!@projection_declared) }
         end
 
         # Builds a `Policy` from a `policy "Name" do ... end` block.
@@ -118,6 +133,28 @@ module Hecks
           builder.instance_eval(&block) if block
           builder.build
         end
+
+        private
+
+        # What the policy reacts to and what it reaches.
+        def reaction_fields
+          { name: @name, on_event: @on_event, trigger_command: @trigger_command, ask: @ask,
+            target_domain: @target_domain }
+        end
+
+        # What decides whether it fires, and what it hands over.
+        def guard_fields
+          { expect_undelivered: @expect_undelivered || false, where: @where, for_each: @for_each,
+            with_spec: @with_spec || [] }
+        end
+
+        # An ask resolves against the ports of the domain it is declared in, so `across` has
+        # nothing to add to it.
+        def refuse_ask_across!
+          return unless @ask && @target_domain
+
+          raise Malformed, "#{@name} declares both an ask and across — an ask resolves in its own domain"
+        end
       end
     end
   end

data/lib/hecks/bluebook/dsl/rule_reference.rb

@@ -6,6 +6,9 @@ module Hecks
       # The three "declared once, referenced by name" resolution primitives shared by
       # every given/invariant/ensures scope in this DSL (ADR 0025).
       module RuleReference
+        # Raised when the syntax table names a resolution this module cannot perform.
+        class Error < RuntimeError; end
+
         module_function
 
         # Extracts a predicate's source and builds the rule struct (Given or Invariant),
@@ -94,10 +97,10 @@ module Hecks
           actual = lookup(word, context)[:resolves_via]
           return if actual == expected_primitive
 
-          raise "internal: syntax.bluebook says #{word}/#{context} resolves via " \
-                "#{actual.inspect}, but #{word}'s own Ruby builder is about to use " \
-                "#{expected_primitive.inspect} — the grammar table and the " \
-                "implementation have drifted"
+          raise Error, "internal: syntax.bluebook says #{word}/#{context} resolves via " \
+                       "#{actual.inspect}, but #{word}'s own Ruby builder is about to use " \
+                       "#{expected_primitive.inspect} — the grammar table and the " \
+                       "implementation have drifted"
         end
       end
     end

data/lib/hecks/bluebook/dsl/world_builder.rb

@@ -102,7 +102,7 @@ module Hecks
         end
 
         class << self
-          # The builder whose block is being evaluated, so an aggregate door a facade already
+          # The builder whose block is being evaluated, so an aggregate module a facade already
           # installed (a repeat boot in one process) can record a qualified bind into it.
           #
           # @return [Bluebook::DSL::WorldBuilder, nil] nil outside a `.world` block

data/lib/hecks/bluebook/expression/ast_json/emitters.rb

@@ -55,6 +55,9 @@ module Hecks
             # Segments, as `find.path` has, so a reader need not split a dotted string.
             Resolver::Lookup         => ->(node) { { "op" => "lookup", "path" => node.path.split(".") } },
             Resolver::Addition       => binary("add", :emit_resolver),
+            Resolver::Subtraction    => binary("sub", :emit_resolver),
+            Resolver::Multiplication => binary("mul", :emit_resolver),
+            Resolver::Division       => binary("div", :emit_resolver),
             Resolver::SignTest       => lambda { |node|
               { "op" => "sign_test", "cmp" => AstJson.emit_comparison(node.operator),
                 "receiver" => AstJson.emit_resolver(node.receiver) }
@@ -81,6 +84,9 @@ module Hecks
             Resolver::Presence       => receiver_with("presence", :negated),
             Resolver::Assignment     => receiver_with("assignment", :negated),
             Resolver::Split          => receiver_with("split", :separator),
+            Resolver::Strip          => lambda { |node|
+              { "op" => "strip", "receiver" => AstJson.emit_resolver(node.receiver), "side" => node.side.to_s }
+            },
             Resolver::StartsWith     => receiver_with("starts_with", :substring),
             Resolver::EndsWith       => receiver_with("ends_with", :substring),
             Resolver::First          => receiver_only("first"),

data/lib/hecks/bluebook/expression/ast_json.rb

@@ -9,6 +9,9 @@ module Hecks
       # Lives in core because rust/host cannot link the kernel crate and interprets this from
       # ir.json.
       module AstJson
+        # Raised for an expression node that no JSON rendering exists for.
+        class UnhandledNode < RuntimeError; end
+
         module_function
 
         # The closed roster of `"op"` tags. A new node kind needs an entry here and an arm in
@@ -16,9 +19,9 @@ module Hecks
         OPS = %w[
           or and not compare include
           int float str bool nil array lookup
-          add modulo sign_test empty size to_s
+          add sub mul div modulo sign_test empty size to_s
           block_predicate find first last
-          matches_regex presence assignment split starts_with ends_with
+          matches_regex presence assignment split strip starts_with ends_with
         ].freeze
 
         # One rule row: description, canonical text, and the AST derived from that text.
@@ -119,8 +122,8 @@ module Hecks
           _, emitter = Emitters::BOOL.find { |klass, _| node.is_a?(klass) }
           return emitter.call(node) if emitter
 
-          raise "unhandled evaluator node #{node.class} — no JSON rendering exists for it " \
-                "(lib/hecks/bluebook/expression/ast_json.rb#emit_bool)"
+          raise UnhandledNode, "unhandled evaluator node #{node.class} — no JSON rendering exists for it " \
+                               "(lib/hecks/bluebook/expression/ast_json.rb#emit_bool)"
         end
 
         # Emits the JSON form of one comparison operator.
@@ -161,8 +164,8 @@ module Hecks
           _, emitter = Emitters::RESOLVER.find { |klass, _| node.is_a?(klass) }
           return emitter.call(node) if emitter
 
-          raise "unhandled resolver node #{node.class} — no JSON rendering exists for it " \
-                "(lib/hecks/bluebook/expression/ast_json.rb#emit_resolver)"
+          raise UnhandledNode, "unhandled resolver node #{node.class} — no JSON rendering exists for it " \
+                               "(lib/hecks/bluebook/expression/ast_json.rb#emit_resolver)"
         end
       end
     end

data/lib/hecks/bluebook/expression/ast_reader.rb

@@ -4,6 +4,9 @@ require_relative "resolver"
 module Hecks
   module Bluebook
     module Expression
+      # Raised for an operator `AstReader` has no arm for.
+      class UnhandledOp < RuntimeError; end
+
       # The inverse of `AstJson`: reads a rule row's `"op"`-tagged `ast` back into the
       # `Evaluator`/`Resolver` nodes, so dispatch evaluates a rule without re-parsing its text.
       module AstReader
@@ -33,9 +36,7 @@ module Hecks
         # @param klass [Class] `Evaluator::Or` or `Evaluator::And`
         # @param json [Hash] the node's `"left"` and `"right"` boolean children
         # @return [Object] the node `klass` builds over them
-        def read_pair(klass, json)
-          klass.new(left: read_bool(json["left"]), right: read_bool(json["right"]))
-        end
+        def read_pair(klass, json) = klass.new(left: read_bool(json["left"]), right: read_bool(json["right"]))
 
         # @param json [Hash] a `"compare"` node
         # @return [Evaluator::Compare] its operator and both resolver sides
@@ -51,7 +52,7 @@ module Hecks
             op.compares_less_than == cmp.fetch("less_than") &&
               op.compares_equal == cmp.fetch("equal") &&
               op.negated == cmp.fetch("negated")
-          end or raise "no comparison operator has the triple #{cmp.inspect}"
+          end or raise UnhandledOp, "no comparison operator has the triple #{cmp.inspect}"
         end
 
         # The readers `read_resolver` tries in turn; each answers `nil` for an op it does not own.
@@ -65,7 +66,7 @@ module Hecks
             node = public_send(reader, json)
             return node if node
           end
-          raise "no reader handles op #{op.inspect} — add an arm before AstJson can emit it"
+          raise UnhandledOp, "no reader handles op #{op.inspect} — add an arm before AstJson can emit it"
         end
 
         # @param json [Hash] a resolver node
@@ -80,6 +81,8 @@ module Hecks
           end
         end
 
+        def read_binary(node_class, json) = node_class.new(left: read_resolver(json["left"]), right: read_resolver(json["right"]))
+
         # @param json [Hash] a resolver node
         # @return [Object, nil] the array or lookup it spells, or `nil` for any other op
         def read_collection(json)
@@ -93,7 +96,10 @@ module Hecks
         # @return [Object, nil] the sum, remainder or sign test it spells, or `nil` for any other op
         def read_arithmetic(json)
           case json["op"]
-          when "add"    then Resolver::Addition.new(left: read_resolver(json["left"]), right: read_resolver(json["right"]))
+          when "add"    then read_binary(Resolver::Addition, json)
+          when "sub"    then read_binary(Resolver::Subtraction, json)
+          when "mul"    then read_binary(Resolver::Multiplication, json)
+          when "div"    then read_binary(Resolver::Division, json)
           when "modulo" then Resolver::Modulo.new(receiver: receiver(json), divisor: read_resolver(json["divisor"]))
           when "sign_test"
             op = operator(json["cmp"])
@@ -110,6 +116,7 @@ module Hecks
           when "size"  then Resolver::Size.new(receiver: receiver(json))
           when "first" then Resolver::First.new(receiver: receiver(json))
           when "last"  then Resolver::Last.new(receiver: receiver(json))
+          when "strip" then Resolver::Strip.new(receiver: receiver(json), side: json["side"].to_sym)
           end
         end
 
@@ -152,9 +159,7 @@ module Hecks
 
         # `SignTest#test` is only refusal wording; recovering it keeps a rebuilt node's message
         # identical to the parsed one's.
-        def sign_test_name(operator)
-          Resolver::SIGN_TEST_OPERATORS.key(operator.symbol) || operator.symbol
-        end
+        def sign_test_name(operator) = Resolver::SIGN_TEST_OPERATORS.key(operator.symbol) || operator.symbol
       end
     end
   end

data/lib/hecks/bluebook/expression/projection.json

@@ -209,6 +209,42 @@
       "category": "presence",
       "precedence": 7,
       "arity": 1
+    },
+    {
+      "symbol": ".strip",
+      "category": "text",
+      "precedence": 7,
+      "arity": 1
+    },
+    {
+      "symbol": ".lstrip",
+      "category": "text",
+      "precedence": 7,
+      "arity": 1
+    },
+    {
+      "symbol": ".rstrip",
+      "category": "text",
+      "precedence": 7,
+      "arity": 1
+    },
+    {
+      "symbol": "-",
+      "category": "arithmetic",
+      "precedence": 6,
+      "arity": 2
+    },
+    {
+      "symbol": "*",
+      "category": "arithmetic",
+      "precedence": 7,
+      "arity": 2
+    },
+    {
+      "symbol": "/",
+      "category": "arithmetic",
+      "precedence": 7,
+      "arity": 2
     }
   ],
   "normalisations": [

data/lib/hecks/bluebook/expression/resolver/operations.rb

@@ -24,6 +24,7 @@ module Hecks
           Presence       => ->(node, value, _state, _attrs) { Resolver.presence_of(node, value) },
           Assignment     => ->(node, value, _state, _attrs) { Resolver.assignment_of(node, value) },
           Split          => ->(node, value, _state, _attrs) { Resolver.split_value(value, node.separator) },
+          Strip          => ->(node, value, _state, _attrs) { Resolver.strip_value(value, node.side) },
           Last           => ->(_node, value, _state, _attrs) { Resolver.last_of(value) },
           First          => ->(_node, value, _state, _attrs) { Resolver.first_of(value) },
           Find           => ->(node, value, state, attrs) { Resolver.found_of(node, value, state, attrs) },
@@ -46,6 +47,36 @@ module Hecks
           raise EvaluationError, "addition overflowed: #{lhs} + #{rhs} is not a finite number"
         end
 
+        def subtract(left, right)
+          checked_arithmetic("subtraction", "-", left, right) { |lhs, rhs| lhs - rhs }
+        end
+
+        def multiply(left, right)
+          checked_arithmetic("multiplication", "*", left, right) { |lhs, rhs| lhs * rhs }
+        end
+
+        # Integer operands floor toward negative infinity; a zero divisor faults like `.modulo`.
+        def divide(left, right)
+          raise EvaluationError, "divided by 0" if require_number(right, "division").zero?
+
+          checked_arithmetic("division", "/", left, right) { |lhs, rhs| lhs / rhs }
+        end
+
+        # Applies `operation` to two numbers, refusing an Integer outside 64 bits or a Float that
+        # is not finite, as `add` does.
+        def checked_arithmetic(name, symbol, left, right)
+          lhs = require_number(left, name)
+          rhs = require_number(right, name)
+          result = yield(lhs, rhs)
+          return result if representable?(result)
+
+          raise EvaluationError, "#{name} overflowed: #{lhs} #{symbol} #{rhs} #{overflow_reason(result)}"
+        end
+
+        def representable?(number) = number.is_a?(Integer) ? INT64_RANGE.cover?(number) : number.finite?
+
+        def overflow_reason(number) = number.is_a?(Integer) ? "does not fit in a 64-bit integer" : "is not a finite number"
+
         def apply_sign_test(node, value)
           number = numeric(value)
           raise EvaluationError, "#{node.test} expects a number, got #{describe(value)}" unless number