hecks 5.0.0 → 6.0.0

data/lib/hecks/bluebook/translation_expression/parser.rb

@@ -9,6 +9,15 @@ module Hecks
         NAME   = /[a-z_][a-z0-9_]*(?:\.[a-z_][a-z0-9_]*)*/
         STRING = /"(?:[^"\\]|\\.)*"/
 
+        # The double quote that opens a string literal.
+        QUOTE = /"/
+
+        # An opening parenthesis, after any whitespace: the start of a function's arguments.
+        OPEN_PAREN = /\s*\(/
+
+        # The comma between two list items.
+        LIST_COMMA = /,/
+
         # @param text [String] the expression's source text
         def initialize(text)
           @text = text.to_s
@@ -28,10 +37,10 @@ module Hecks
 
         def expression
           skip
-          return ["lit", string] if @scan.check(/"/)
+          return ["lit", string] if @scan.check(QUOTE)
 
           name = @scan.scan(NAME) || refuse("expected a field, a string or a function")
-          return function(name) if @scan.check(/\s*\(/)
+          return function(name) if @scan.check(OPEN_PAREN)
 
           name == "null" ? ["null"] : ["ref", name]
         end
@@ -57,7 +66,7 @@ module Hecks
           loop do
             items << yield(items.size)
             skip
-            break unless @scan.skip(/,/)
+            break unless @scan.skip(LIST_COMMA)
           end
           items
         end
@@ -80,7 +89,7 @@ module Hecks
 
         def string
           token = @scan.scan(STRING) || refuse("expected a string")
-          JSON.parse(token, quirks_mode: true)
+          JSON.parse(token)
         rescue JSON::ParserError
           refuse("#{token} is not a well-formed string")
         end
@@ -90,7 +99,7 @@ module Hecks
           @scan.skip(Regexp.new(Regexp.escape(mark))) || refuse("expected #{mark.inspect}")
         end
 
-        def skip = @scan.skip(/\s+/)
+        def skip = @scan.skip(Text::WHITESPACE)
 
         def check_arguments(name, arguments)
           arity = FUNCTIONS.fetch(name)

data/lib/hecks/bluebook.rb

@@ -2,20 +2,21 @@
 # assembly, authoring DSL and meta-validator.
 
 module Hecks
-  # `Hecks::Bluebook` is a class defined in bluebook/chapter.rb; reopen it with `class`.
+  # `Hecks::Bluebook` is a class defined in bluebook/declaration.rb; reopen it with `class`.
   module Bluebook
   end
 end
 
-# Required here because the chapter's frozen files lean on these at class-body level.
+# Required here because the bluebook's frozen files lean on these at class-body level.
 # Load order: expression and IR first, assembly's collaborators before its face, DSL last.
 require_relative "construct"
 require_relative "literal"
 require_relative "query_specification"
 
 require_relative "bluebook/expression"
-require_relative "bluebook/chapter"
+require_relative "bluebook/declaration"
 require_relative "bluebook/reference"
+require_relative "bluebook/one_of_union"
 require_relative "bluebook/attribute"
 require_relative "bluebook/value_object"
 require_relative "bluebook/command"
@@ -27,8 +28,10 @@ require_relative "bluebook/domain_port"
 require_relative "bluebook/policy"
 require_relative "bluebook/ask_resolution"
 require_relative "bluebook/process_manager"
+require_relative "bluebook/acknowledgements"
 require_relative "bluebook/aggregate"
 require_relative "bluebook/hecksagon"
+require_relative "bluebook/context_map"
 require_relative "bluebook/translation_expression"
 require_relative "bluebook/translation"
 require_relative "bluebook/translation_plan"

data/lib/hecks/bulk/bluebook/adapters/row_sweeper.adapter

@@ -0,0 +1,7 @@
+# Binds the `Rows` port to `RowSweeper`, which sends a bulk run's command to every row in process.
+# Required by name, not relative, so a copy of this directory shares the one implementation loaded.
+require "hecks/bulk/row_sweeper"
+
+Hecks.adapter "RowSweeper" do
+  port "Rows"
+end

data/lib/hecks/bulk/bluebook/bulk.behaviors

@@ -0,0 +1,18 @@
+Hecks.behaviors "Bulk" do
+  vision "A bulk run names a command and a query in full, and is declined when its command cannot be sent."
+
+  loads "bulk.bluebook", "../../framework/bluebook/governance.bluebook", "bulk.hecksagon", "bulk.ports.hecksagon",
+        "adapters/row_sweeper.adapter"
+
+  test "Request refuses a command that is not fully qualified" do
+    tests "Request", on: "BulkRun"
+    input run: { value: "b2" }, verb: { value: "Cancel" }, over: { value: "Shop::Order.Open" }
+    expect refused: "must match"
+  end
+
+  test "Request declines a run whose command no loaded bluebook declares" do
+    tests "Request", on: "BulkRun"
+    input run: { value: "b3" }, verb: { value: "Shop::Order.Cancel" }, over: { value: "Shop::Order.Open" }
+    expect status: "declined"
+  end
+end

data/lib/hecks/bulk/bluebook/bulk.bluebook

@@ -0,0 +1,126 @@
+# The Bulk bluebook: one command sent to every row one query answers, and what each row did with it
+# (ADR 0125). A domain attaches it with `attaches "Bulk"`.
+#
+# The sweep itself is the Rows port's: the bluebook says a run was asked for, what it ran over and
+# how each row came out, and never which store or adapter did the work. The adapter that answers
+# the port sends the command through the same row sweep a `for_each` policy uses, one row at a
+# time, under the authority of whoever asked for the run.
+Hecks.bluebook "Bulk" do
+  vision "Send one command to every row a query answers, and keep what each row did with it."
+  supporting
+
+  aggregate "BulkRun" do
+    description "One command sent to every row of one query, and the outcome of each row: delivered, or refused and why."
+
+    attribute :run,       RunKey
+    attribute :verb,      VerbName
+    attribute :over,      QueryName
+    attribute :arguments, list_of(Argument),  optional: true
+    attribute :results,   list_of(RowResult), optional: true
+    attribute :refusal,   Report,             optional: true
+    identified_by :run
+
+    value_object "RunKey" do
+      attribute :value, String, matches: :present
+
+      invariant("a run is named") { !value.to_s.empty? }
+    end
+
+    # The command each row receives, fully qualified: `Banking::Account.FreezeAccount`.
+    value_object "VerbName" do
+      attribute :value, String, matches: :command_ref
+    end
+
+    # The query whose rows the command is sent to, fully qualified: `Banking::Account.Open`.
+    value_object "QueryName" do
+      attribute :value, String, matches: :command_ref
+    end
+
+    # One argument of the query, spelled as text. A value for an argument not declared a String
+    # is read as JSON, so a value object is written as an object: `{"cents":100}`.
+    value_object "Argument" do
+      attribute :key,   String
+      attribute :value, String
+    end
+
+    # How one row came out: the row's identity, whether the command was delivered or refused, and
+    # the refusal's message when it was refused.
+    value_object "RowResult" do
+      attribute :row,     String
+      attribute :outcome, String, pattern: '^(delivered|refused)$'
+      attribute :reason,  String, optional: true
+    end
+
+    value_object "Report" do
+      attribute :value, String
+    end
+
+    lifecycle :status, default: "requested" do
+      mark :failure, "declined"
+      transition "Record"  => "swept",    from: "requested"
+      transition "Decline" => "declined", from: "requested"
+      mark :terminal, "declined", "swept"
+    end
+
+    command "Request" do
+      goal "Send one command to every row a query answers, keeping each row's outcome"
+
+      sets :run
+      sets :verb
+      sets :over
+      sets :arguments
+
+      emits BulkRunRequested
+    end
+
+    command "Record" do
+      role "System"
+      goal "Keep how every row of the run came out"
+
+      reference_to BulkRun
+      attribute :results, list_of(RowResult), sets: true
+
+
+      emits BulkRunRecorded
+    end
+
+    command "Decline" do
+      role "System"
+      goal "Keep why the run could not start, before any row was sent"
+
+      reference_to BulkRun
+      attribute :refusal, Report, sets: true
+
+
+      emits BulkRunDeclined
+    end
+
+    query "Outcome" do
+      description "How one run stands: its status, every row's outcome, or why it could not start."
+      attribute :run, RunKey
+      where(run: :run)
+      order_by :run
+    end
+
+    query "Declined" do
+      description "Every run that could not start, such as one whose command no loaded bluebook declares."
+      where(status: "declined")
+      order_by :run
+    end
+  end
+
+  policy "SweepWhenRequested" do
+    on      "BulkRun.BulkRunRequested"
+    ask     :sweep, with: { run: :run }
+  end
+
+  policy "RecordTheSweep" do
+    on      "BulkRun.BulkRunSwept"
+    trigger BulkRun::Record, with: { results: :results }
+  end
+
+  policy "RecordTheRefusal" do
+    on      "BulkRun.BulkRunRefused"
+    trigger BulkRun::Decline, with: { refusal: :refusal }
+  end
+end

data/lib/hecks/bulk/bluebook/bulk.hecksagon

@@ -0,0 +1,11 @@
+# The Bulk bluebook, bound so it boots standing alone (a fuzz or model_check boot of this directory).
+# The Rows port every attaching hecksagon shares is in bulk.ports.hecksagon.
+Hecks.hecksagon "Bulk" do
+  # `Record` and `Decline` declare a role; Governance must be attached for it to be checked.
+  attaches "Governance"
+  persisted_by "Memory"
+end
+
+Hecks.hecksagon "Governance" do
+  persisted_by "Memory"
+end

data/lib/hecks/bulk/bluebook/bulk.ports.hecksagon

@@ -0,0 +1,13 @@
+# The port Bulk declares, for every hecksagon that attaches the bluebook (`Bluebooks` loads this file
+# with it). `Sweep` sends the run's command to every row and answers each row's outcome, or refuses
+# the run with a reason (a mode the store cannot honour, a verb or query that does not resolve).
+# adapters/row_sweeper.adapter binds it.
+Hecks.hecksagon "Bulk" do
+  Bulk::BulkRun.port "Rows" do
+    asks "Sweep", to: BulkRun do
+      attribute :run, RunKey
+      answers "BulkRunSwept"
+      refuses "BulkRunRefused"
+    end
+  end
+end

data/lib/hecks/bulk/plan.rb

@@ -0,0 +1,60 @@
+require "json"
+require_relative "../naming"
+
+module Hecks
+  module Bulk
+    # What one bulk run asks for, read off its `BulkRun` record: the command, the query it runs
+    # over and the query's arguments (ADR 0125).
+    Plan = Struct.new(:verb, :over, :arguments, keyword_init: true) do
+      # Reads a plan off a record's held state, as an ask hands it to an adapter.
+      #
+      # @param held [Hash{Symbol => Object}] the record: `verb`, `over` and `arguments`,
+      #   each a plain value or a `{ value: }` cell
+      # @return [Bulk::Plan] the plan
+      def self.from_record(held)
+        new(verb: plain(held[:verb]), over: plain(held[:over]),
+            arguments: Array(held[:arguments]).to_h { |pair| [plain(pair[:key]).to_s, plain(pair[:value]).to_s] })
+      end
+
+      # The value inside a `{ value: }` cell, or the cell itself.
+      #
+      # @param cell [Object] a held field
+      # @return [Object] its plain value
+      def self.plain(cell) = cell.is_a?(Hash) && cell.key?(:value) ? cell[:value] : cell
+
+      # The `Argument` rows a `Request` takes for a query's arguments: a String as itself,
+      # anything else as JSON.
+      #
+      # @param arguments [Hash{Symbol, String => Object}] the query's arguments
+      # @return [Array<Hash{Symbol => String}>] one `{ key:, value: }` row per argument
+      def self.argument_rows(arguments)
+        arguments.map do |key, value|
+          { key: key.to_s, value: value.is_a?(String) ? value : JSON.generate(value) }
+        end
+      end
+
+      # @return [Array(String, String, String)] the query's domain, aggregate and name
+      def query_route = Naming.split_verb(over)
+
+      # The query's arguments, each read as its declared type asks: text for a String
+      # argument, JSON for anything else.
+      #
+      # @param query [Bluebook::Query, nil] the declared query
+      # @return [Hash{Symbol => Object}] the arguments the query is asked with
+      def query_arguments(query)
+        arguments.to_h do |key, text|
+          declared = query&.attributes&.find { |attribute| attribute.name.to_s == key }
+          [key.to_sym, declared.nil? || declared.type.to_s == "String" ? text : decoded(text)]
+        end
+      end
+
+      private
+
+      def decoded(text)
+        JSON.parse(text, symbolize_names: true)
+      rescue JSON::ParserError
+        text
+      end
+    end
+  end
+end

data/lib/hecks/bulk/row_sweeper.rb

@@ -0,0 +1,34 @@
+require_relative "../runtime/asking"
+require_relative "sweep"
+
+module Hecks
+  module Adapters
+    # The `Rows` port's adapter for a `BulkRun` (ADR 0125): sends the run's command to every row
+    # of its query in this process, through the boot whose `BulkRun` asked, and answers each
+    # row's outcome. A run that cannot start (a verb or query that does not resolve) raises, and
+    # the port records the refusal on the run.
+    class RowSweeper
+      # Raised when the adapter is asked outside a port operation, with no boot to send rows to.
+      class Unbound < StandardError; end
+
+      # Sends the run's command to every row.
+      #
+      # @param held [Hash{Symbol => Object}] the run's record: `verb`, `over` and `arguments`
+      # @return [Hash{Symbol => Array<Hash>}] `results:` one `RowResult` per row: `row:`,
+      #   `outcome:` ("delivered" or "refused") and, when refused, `reason:`
+      # @raise [Unbound] if no registry is asking
+      def sweep(**held)
+        registry = Runtime::Asking.registry or raise Unbound, "a bulk run is swept only when its BulkRun asks"
+
+        { results: Bulk::Sweep.new(registry, Bulk::Plan.from_record(held)).outcomes.map { |row| row_result(row) } }
+      end
+
+      private
+
+      # A row's outcome in the shape the bluebook's `RowResult` holds.
+      def row_result(row)
+        { row: row[:row], outcome: row[:delivered] ? "delivered" : "refused", reason: row[:reason] }.compact
+      end
+    end
+  end
+end

data/lib/hecks/bulk/set_arguments.rb

@@ -0,0 +1,68 @@
+require_relative "../bluebook/expression"
+require_relative "../runtime/value"
+
+module Hecks
+  module Bulk
+    # The arguments a bulk run's command carries for one row when it runs as one statement
+    # (ADR 0129): the row's key, then every declared default, each coerced as a dispatch coerces
+    # it, so an event's payload is the one a row-by-row dispatch would emit.
+    class SetArguments
+      # Stands for the row's key among the scalars: its value differs per row, so no expression
+      # that reads it compiles.
+      PER_ROW = Object.new.freeze
+
+      # @param aggregate [Bluebook::Aggregate] the aggregate the command acts on
+      # @param command [Class] the command
+      # @param key [Symbol] the argument a row's id fills
+      def initialize(aggregate, command, key)
+        @aggregate = aggregate
+        @command = command
+        @key = key.to_sym
+        @defaults = coerced(command.attributes.reject { |attribute| attribute.default.nil? })
+      end
+
+      # @param id [Object] a row's identity
+      # @return [Hash{Symbol => Object}] the arguments that row's dispatch carries
+      def for_row(id) = { @key => id }.merge(@defaults)
+
+      # Every argument as the plain scalar an expression reads, the key as {PER_ROW}.
+      #
+      # @return [Hash{Symbol => Object}]
+      def scalars
+        @defaults.transform_values { |value| Bluebook::Expression::Resolver.unwrap_scalar(value) }.merge(@key => PER_ROW)
+      end
+
+      # What a `sets` source resolves to: an argument's value for a Symbol, the literal itself
+      # otherwise.
+      #
+      # @param source [Symbol, Object] the mutation's source
+      # @return [Object] the value every row takes
+      # @raise [Runtime::TypeMismatch] if the source is the row's key, which differs per row
+      def source_value(source)
+        raise Runtime::TypeMismatch, "the row's key #{@key} differs per row" if source == @key
+
+        source.is_a?(Symbol) ? @defaults[source] : source
+      end
+
+      # The signed Integer an increment or decrement adds.
+      #
+      # @param mutation [Bluebook::Mutation] an `increment` or `decrement`
+      # @return [Integer] the amount, negative for a decrement
+      # @raise [Runtime::TypeMismatch] if the amount is not an Integer
+      def step(mutation)
+        amount = Bluebook::Expression::Resolver.unwrap_scalar(source_value(mutation.source))
+        raise Runtime::TypeMismatch, "#{mutation.target} steps by #{amount.inspect}" unless amount.is_a?(Integer)
+
+        mutation.op == :decrement ? -amount : amount
+      end
+
+      private
+
+      def coerced(attributes)
+        attributes.to_h do |attribute|
+          [attribute.name.to_sym, Runtime::Value.for_attribute(@aggregate, attribute, attribute.default, argument: true)]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bulk/set_eligibility.rb

@@ -0,0 +1,50 @@
+require_relative "../grammar"
+
+module Hecks
+  module Bulk
+    # The checks that say whether a bulk run's command and aggregate can be one statement
+    # (ADR 0129): what the statement cannot check per row rules a run out, and every expression
+    # must compile for the store's dialect. Mixed into {SetPlanner}, which supplies `@command`,
+    # `@aggregate`, `@repository` and the run's names.
+    module SetEligibility
+      # The mutations a statement writes.
+      COMPILED_OPS = %i[set increment decrement].freeze
+
+      private
+
+      def eligible?
+        store_compiles? && command_compiles? && aggregate_compiles? && expressions_compile?
+      end
+
+      def store_compiles?
+        @registry.adapter_provides?(@domain, @aggregate, "set_transform") && @repository.set_transform?
+      end
+
+      # A command acting on one existing record of its own aggregate, every argument of which has
+      # a value without the caller, and nothing checked after its writes.
+      def command_compiles?
+        acts_on_own_record? && [@command.needs, @command.ensures].all?(&:empty?) &&
+          @command.mutations.all? { |mutation| COMPILED_OPS.include?(mutation.op) } &&
+          @command.attributes.all? { |attribute| self_supplied?(attribute) }
+      end
+
+      def acts_on_own_record? = @command.references.to_s == @aggregate.hecks_name && !@command.creates?
+
+      # An argument the run never passes must have a default, or be one the command can lack.
+      def self_supplied?(attribute) = !attribute.reference? && (attribute.optional? || !attribute.default.nil?)
+
+      # No rule the store would have to check against other records or the settled whole.
+      def aggregate_compiles?
+        [@aggregate.invariants, @aggregate.entities, @aggregate.projected_fields].all?(&:empty?) &&
+          @aggregate.attributes.none?(&:reference?) && @aggregate.queries.none?(&:authorization)
+      end
+
+      def expressions_compile?
+        dialect = @repository.set_transform_dialect
+        texts = @command.givens.map(&:canonical) +
+                @command.mutations.filter_map { |mutation| mutation.source.text if mutation.source.is_a?(Computed) }
+        texts.all? { |text| Grammar.compiles_for?(text, dialect) }
+      end
+    end
+  end
+end

data/lib/hecks/bulk/set_planner.rb

@@ -0,0 +1,100 @@
+require_relative "../naming"
+require_relative "../literal"
+require_relative "../bluebook/expression"
+require_relative "../ports/persistence/set_statement"
+require_relative "../runtime/command_rules"
+require_relative "../runtime/errors"
+require_relative "../runtime/query_interpreter"
+require_relative "../runtime/value"
+require_relative "set_eligibility"
+require_relative "set_arguments"
+
+module Hecks
+  module Bulk
+    # Says a bulk run as one {Ports::Persistence::SetStatement}, or answers nil when it must run
+    # row by row (ADR 0129). It reads only the bluebook and the run; whether each expression has
+    # SQL is the store's to answer when it compiles.
+    class SetPlanner
+      include SetEligibility
+
+      # @param registry [Runtime::Registry] the registry the run's domain is booted in
+      # @param plan [Bulk::Plan] the run
+      # @param key [Symbol] the argument a row's id fills
+      def initialize(registry, plan, key)
+        @registry = registry
+        @plan = plan
+        @domain, aggregate_name, @command_name = Naming.split_verb(plan.verb)
+        @aggregate = registry.bluebook(@domain).aggregate(aggregate_name)
+        @command = @aggregate.command(@command_name)
+        @repository = registry.repository(@domain, @aggregate)
+        @arguments = SetArguments.new(@aggregate, @command, key)
+      end
+
+      # @return [Bulk::SetArguments] the arguments each row's dispatch would carry
+      attr_reader :arguments
+
+      # The run as one statement, or nil when part of it cannot be one.
+      #
+      # @return [Ports::Persistence::SetStatement, nil]
+      def statement
+        return nil unless same_aggregate? && eligible? && role_held?
+
+        query, query_args = store_query
+        query && build(query, query_args)
+      rescue *Runtime::DOMAIN_REFUSALS, Runtime::WiringError
+        nil
+      end
+
+      private
+
+      def same_aggregate?
+        query_domain, query_aggregate, = @plan.query_route
+        query_domain == @domain && query_aggregate == @aggregate.hecks_name
+      end
+
+      # The command's role is the caller's, the same for every row, so it is asked once.
+      def role_held?
+        Runtime::CommandRules.new(@registry).refuse_role_mismatch(@command, @domain)
+        true
+      end
+
+      def store_query
+        _, _, query_name = @plan.query_route
+        args = @plan.query_arguments(@aggregate.query(query_name))
+        Runtime::QueryInterpreter.new(@registry).store_specification(@domain, @aggregate, query_name, args)
+      end
+
+      def build(query, query_args)
+        Ports::Persistence::SetStatement.new(
+          query: query, query_args: query_args, arguments: @arguments.scalars,
+          givens: @command.givens.map { |given| Bluebook::Expression::Evaluator.nodes_for(given) },
+          assignments: @command.mutations.map { |mutation| assignment(mutation) },
+          transition: transition, from_guard: from_guard
+        )
+      end
+
+      def assignment(mutation)
+        kind, value = assigned(mutation)
+        Ports::Persistence::SetStatement::Assignment.new(target: mutation.target.to_s, kind: kind, value: value)
+      end
+
+      def assigned(mutation)
+        source = mutation.source
+        return [:step, @arguments.step(mutation)] unless mutation.op == :set
+        return [:copy, source.name.to_s] if source.is_a?(StateRef)
+        return [:expression, Bluebook::Expression::Resolver.parse(source.text)] if source.is_a?(Computed)
+
+        [:constant, Runtime::Value.for(@aggregate, mutation.target, @arguments.source_value(source))]
+      end
+
+      def transition
+        cases = @aggregate.lifecycle&.transitions_for(@command.hecks_name) || []
+        cases.empty? ? nil : cases.map { |move| [move_from(move), move.target] }
+      end
+
+      def move_from(move) = (Array(move.from) if move.constrained?)
+
+      def from_guard = (Array(@command.from) if @command.from && @aggregate.lifecycle)
+    end
+  end
+end

data/lib/hecks/bulk/set_sweep.rb

@@ -0,0 +1,78 @@
+require_relative "../adapters/driven/set_transform"
+require_relative "../runtime/event"
+require_relative "set_planner"
+
+module Hecks
+  module Bulk
+    # A bulk run carried out as one statement (ADR 0129). Inside one transaction of the target's
+    # repository it reads the query's rows, runs the statement, and records one event per updated
+    # row and `emits`, with that event's outbox rows; after the commit each row's reactions are
+    # delivered in query order. A row the statement skipped is the caller's to dispatch by hand.
+    class SetSweep
+      # What stops a statement before it commits, leaving the run to go row by row.
+      FALLBACKS = [Adapters::SetTransform::Uncompilable, Adapters::SetTransform::Declined].freeze
+
+      # @param registry [Runtime::Registry] the registry the run's domain is booted in
+      # @param plan [Bulk::Plan] the run
+      # @param planner [Bulk::SetPlanner] the run said as a statement
+      # @param statement [Ports::Persistence::SetStatement] the statement the planner built
+      def initialize(registry, plan, planner, statement)
+        @registry = registry
+        @plan = plan
+        @planner = planner
+        @statement = statement
+        @domain, aggregate_name, command_name = Naming.split_verb(plan.verb)
+        @aggregate = registry.bluebook(@domain).aggregate(aggregate_name)
+        @emits = @aggregate.command(command_name).emits
+        @repository = registry.repository(@domain, @aggregate)
+      end
+
+      # Runs the statement, or answers nil when the run must go row by row instead.
+      #
+      # @param read_ids [#call] answers the query's row identities, in query order
+      # @yield [id] dispatches one row the statement skipped and answers its outcome
+      # @return [Array<Hash{Symbol => Object}>, nil] one outcome per row in query order, or nil
+      #   when nothing was committed
+      def outcomes(read_ids)
+        ids, updated = commit(read_ids)
+        return nil unless ids
+
+        updated.each_value { |events, rows| @registry.outbox.deliver(rows, events, @domain, @repository) }
+        unread = updated.keys - ids.map(&:to_s)
+        (ids + unread).map { |id| updated.key?(id.to_s) ? { row: id.to_s, delivered: true } : yield(id) }
+      end
+
+      private
+
+      def commit(read_ids)
+        @repository.transaction do
+          ids = read_ids.call
+          updated = in_query_order(@repository.apply_set_transform(@statement), ids.map(&:to_s))
+
+          [ids, updated.to_h { |instance| [instance.id.to_s, record(instance)] }]
+        end
+      rescue *FALLBACKS
+        nil
+      end
+
+      def in_query_order(instances, ids)
+        positions = ids.each_with_index.to_h
+        instances.sort_by { |instance| positions.fetch(instance.id.to_s, ids.size) }
+      end
+
+      # The events a row-by-row dispatch of this row emits, logged and recorded, with their
+      # outbox rows enqueued in the statement's transaction.
+      def record(instance)
+        events = @emits.map do |name|
+          Runtime::Event.new(name: name, occurred_at: Runtime::Event.stamp, aggregate: "#{@domain}::#{@aggregate.hecks_name}",
+                             id: instance.id, payload: @planner.arguments.for_row(instance.id), correlation: nil)
+        end
+        events.each do |event|
+          @registry.event_log << event.emit!
+          @repository.record_event(event)
+        end
+        [events, @registry.outbox.enqueue(@repository, events, @domain)]
+      end
+    end
+  end
+end