hecks 3.5.0 → 3.7.0

data/lib/hecks/bench/ruby_runner.rb

@@ -15,21 +15,23 @@ module Hecks
 
       def call(workload, adapter:, warmup:, iterations:)
         unless ADAPTERS.include?(adapter)
-          raise ArgumentError, "unknown adapter #{adapter.inspect} — one of #{ADAPTERS.join(', ')}"
+          raise ArgumentError, "unknown adapter #{adapter.inspect} — one of #{ADAPTERS.join(", ")}"
         end
 
         load_dependencies
         schema = "bench_#{Process.pid}_#{rand(1 << 32).to_s(16)}"
         quietly_for_postgres do
-          boot(workload, adapter, schema) do |runtime|
-            workload.setup.each { |step| dispatch(runtime, step) }
-            measure(runtime, workload, warmup: warmup, iterations: iterations)
-          end
+          boot(workload, adapter, schema) { |runtime| run_workload(runtime, workload, warmup, iterations) }
         end
       ensure
         drop_schema(schema) if schema && POSTGRES_ADAPTERS.include?(adapter)
       end
 
+      def run_workload(runtime, workload, warmup, iterations)
+        workload.setup.each { |step| dispatch(runtime, step) }
+        measure(runtime, workload, warmup: warmup, iterations: iterations)
+      end
+
       def boot(workload, adapter, schema)
         Hecks::Fuzzing::IsolatedBoot.call(workload.domain_path, adapter: adapter, database: DATABASE,
                                           schema: schema, scratch: { database: DATABASE, schema: schema }) do |copy|
@@ -52,12 +54,15 @@ module Hecks
         GC.start
         samples = []
         started = now
-        iterations.times do |n|
-          workload.cycle(warmup + n).each { |step| samples << [step.verb, time { dispatch(runtime, step) }] }
-        end
+        iterations.times { |n| samples.concat(timed_cycle(runtime, workload.cycle(warmup + n))) }
         Run.new(samples: samples, wall_seconds: now - started)
       end
 
+      # @return [Array<Array(String, Float)>] each step's verb and how long its dispatch took
+      def timed_cycle(runtime, steps)
+        steps.map { |step| [step.verb, time { dispatch(runtime, step) }] }
+      end
+
       def dispatch(runtime, step)
         runtime.dispatch_flat(step.verb, step.ruby_args)
       end

data/lib/hecks/bench/rust_runner.rb

@@ -43,9 +43,7 @@ module Hecks
       def call(workload, binary:, warmup:, iterations:)
         IO.popen([binary, "--serve"], "r+") do |pipe|
           pipe.sync = true
-          workload.setup.each { |step| ask(pipe, step.to_json_line) }
-          warmup.times { |n| workload.cycle(n).each { |step| ask(pipe, step.to_json_line) } }
-          run = measure(pipe, workload, warmup: warmup, iterations: iterations)
+          run = measured_run(pipe, workload, warmup, iterations)
           Run.new(samples: run.samples, wall_seconds: run.wall_seconds,
                   extras: { roundtrip_floor_p50_us: floor(pipe) })
         ensure
@@ -53,21 +51,31 @@ module Hecks
         end
       end
 
+      def measured_run(pipe, workload, warmup, iterations)
+        workload.setup.each { |step| ask(pipe, step.to_json_line) }
+        warmup.times { |n| workload.cycle(n).each { |step| ask(pipe, step.to_json_line) } }
+        measure(pipe, workload, warmup: warmup, iterations: iterations)
+      end
+
       def measure(pipe, workload, warmup:, iterations:)
         samples = []
         started = now
         iterations.times do |n|
-          workload.cycle(warmup + n).each do |step|
-            line = step.to_json_line
-            began = now
-            answer = round_trip(pipe, line)
-            samples << [step.verb, now - began]
-            check(answer, step.verb)
-          end
+          workload.cycle(warmup + n).each { |step| samples << timed_step(pipe, step) }
         end
         Run.new(samples: samples, wall_seconds: now - started)
       end
 
+      # @return [Array(String, Float)] the step's verb and how long its round trip took
+      def timed_step(pipe, step)
+        line = step.to_json_line
+        began = now
+        answer = round_trip(pipe, line)
+        sample = [step.verb, now - began]
+        check(answer, step.verb)
+        sample
+      end
+
       # An empty step is refused without touching the store: the cost of the pipes alone.
       def floor(pipe)
         seconds = Array.new(FLOOR_SAMPLES) do
@@ -90,7 +98,7 @@ module Hecks
       def check(answer, what)
         return if answer.start_with?('{"ok":true')
 
-        raise StepRefused, "#{what} was not accepted: #{answer.strip.empty? ? 'the binary closed its output' : answer.strip}"
+        raise StepRefused, "#{what} was not accepted: #{answer.strip.empty? ? "the binary closed its output" : answer.strip}"
       end
 
       def now

data/lib/hecks/bench/suite.rb

@@ -8,6 +8,10 @@ module Hecks
       # What to measure; `rust_binary` needs a single domain, since a binary embeds exactly one.
       Config = Struct.new(:domains, :targets, :warmup, :iterations, :runs, :rust_binary, keyword_init: true)
 
+      # What one domain's measuring holds across its rounds: the binaries built so far, and each
+      # target's run summaries.
+      Round = Struct.new(:workload, :config, :log, :binaries, :summaries)
+
       module_function
 
       def call(config, log: $stderr)
@@ -16,46 +20,70 @@ module Hecks
         skipped = unavailable_targets(config)
         active = config.targets - skipped.map { |entry| entry[:target] }
         skipped.each { |entry| log.puts "skip #{entry[:target]}: #{entry[:reason]}" }
-        results = config.domains.flat_map { |domain| measure_domain(Workload.fetch(domain), active, config, log) }
+        results = measure_all(config, active, log)
+        { environment: describe_environment(load_before, active), config: config.to_h, results: results,
+          skipped: skipped }
+      end
+
+      def measure_all(config, active, log)
+        config.domains.flat_map { |domain| measure_domain(Workload.fetch(domain), active, config, log) }
+      end
+
+      def describe_environment(load_before, active)
         environment = Environment.describe
         environment[:load_average] = { before: load_before, after: environment[:load_average] }
-        { environment: environment.merge(postgres: postgres_version(active)),
-          config: config.to_h, results: results, skipped: skipped }
+        environment.merge(postgres: postgres_version(active))
       end
 
       def validate(config)
         unknown = config.targets - TARGETS
-        raise ArgumentError, "unknown target #{unknown.first.inspect} — one of #{TARGETS.join(', ')}" if unknown.any?
+        raise ArgumentError, "unknown target #{unknown.first.inspect} — one of #{TARGETS.join(", ")}" if unknown.any?
 
         config.domains.each { |domain| Workload.fetch(domain) }
-        if config.iterations < 1 || config.runs < 1 || config.warmup.negative?
-          raise ArgumentError, "iterations and runs must be at least 1, and warmup at least 0"
-        end
+        validate_counts(config)
+        validate_rust_binary(config)
+      end
+
+      def validate_counts(config)
+        return unless config.iterations < 1 || config.runs < 1 || config.warmup.negative?
+
+        raise ArgumentError, "iterations and runs must be at least 1, and warmup at least 0"
+      end
+
+      def validate_rust_binary(config)
         return unless config.rust_binary && config.domains.size > 1
 
         raise ArgumentError, "--rust-binary embeds one domain, so it needs exactly one --domain"
       end
 
       def unavailable_targets(config)
-        postgres = PostgresProbe.unavailable_reason if config.targets.any? { |t| t.start_with?("ruby:postgres") }
+        postgres = PostgresProbe.unavailable_reason if config.targets.any? { |t| postgres_target?(t) }
         rust = RustRunner.unavailable_reason(binary: config.rust_binary) if config.targets.include?("rust")
         config.targets.filter_map do |target|
-          reason = target == "rust" ? rust : (postgres if target.start_with?("ruby:postgres"))
+          reason = target_reason(target, postgres, rust)
           { target: target, reason: reason } if reason
         end
       end
 
+      def postgres_target?(target) = target.start_with?("ruby:postgres")
+
+      def target_reason(target, postgres, rust)
+        return rust if target == "rust"
+
+        postgres if postgres_target?(target)
+      end
+
       def measure_domain(workload, targets, config, log)
-        binaries = {}
-        summaries = Hash.new { |hash, target| hash[target] = [] }
-        config.runs.times do |index|
-          targets.each do |target|
-            run = measure_once(workload, target, config, binaries)
-            summaries[target] << run.summary
-            log.puts progress_line("#{workload.name} #{target}", "run #{index + 1}/#{config.runs}", summaries[target].last)
-          end
-        end
-        targets.map { |target| aggregate(workload.name, target, summaries[target]) }
+        round = Round.new(workload, config, log, {}, targets.to_h { |target| [target, []] })
+        config.runs.times { |index| targets.each { |target| measure_target(round, target, index) } }
+        targets.map { |target| aggregate(workload.name, target, round.summaries[target]) }
+      end
+
+      def measure_target(round, target, index)
+        summary = measure_once(round.workload, target, round.config, round.binaries).summary
+        round.summaries[target] << summary
+        position = "run #{index + 1}/#{round.config.runs}"
+        round.log.puts progress_line("#{round.workload.name} #{target}", position, summary)
       end
 
       def progress_line(label, position, summary)
@@ -91,7 +119,7 @@ module Hecks
       end
 
       def postgres_version(active)
-        PostgresProbe.server_version if active.any? { |target| target.start_with?("ruby:postgres") }
+        PostgresProbe.server_version if active.any? { |target| postgres_target?(target) }
       end
     end
   end

data/lib/hecks/bench/workload.rb

@@ -41,26 +41,33 @@ module Hecks
 
       def self.fetch(name)
         all.fetch(name) do
-          raise ArgumentError, "unknown domain #{name.inspect} — one of #{all.keys.join(', ')}"
+          raise ArgumentError, "unknown domain #{name.inspect} — one of #{all.keys.join(", ")}"
         end
       end
 
       def self.pizzas
-        new(name: "pizzas", setup: [], cycle: lambda { |n|
-          pizza = "pizza-#{n}"
-          [
-            Step.new("Pizzas::Order.CreatePizza",
-                     { "name"  => { "value" => pizza },
-                       "pizza" => { "price_cents" => { "cents" => 1200 }, "size" => { "value" => "large" } } }),
-            Step.new("Pizzas::Order.AddTopping",
-                     { "name" => pizza, "topping" => { "value" => "Basil" }, "amount" => { "value" => 3 } }),
-            Step.new("Pizzas::Order.AddTopping",
-                     { "name" => pizza, "topping" => { "value" => "Olive" }, "amount" => { "value" => 2 } }),
-            Step.new("Pizzas::Order.Purchase",
-                     { "name" => pizza, "customer_name" => { "value" => "Chris" },
-                       "amount" => { "cents" => 1200 } })
-          ]
-        })
+        new(name: "pizzas", setup: [], cycle: method(:pizza_cycle))
+      end
+
+      def self.pizza_cycle(number)
+        pizza = "pizza-#{number}"
+        [create_pizza(pizza), add_topping(pizza, "Basil", 3), add_topping(pizza, "Olive", 2), purchase(pizza)]
+      end
+
+      def self.create_pizza(pizza)
+        Step.new("Pizzas::Order.CreatePizza",
+                 { "name"  => { "value" => pizza },
+                   "pizza" => { "price_cents" => { "cents" => 1200 }, "size" => { "value" => "large" } } })
+      end
+
+      def self.add_topping(pizza, topping, amount)
+        Step.new("Pizzas::Order.AddTopping",
+                 { "name" => pizza, "topping" => { "value" => topping }, "amount" => { "value" => amount } })
+      end
+
+      def self.purchase(pizza)
+        Step.new("Pizzas::Order.Purchase",
+                 { "name" => pizza, "customer_name" => { "value" => "Chris" }, "amount" => { "cents" => 1200 } })
       end
 
       def self.banking
@@ -68,21 +75,25 @@ module Hecks
                             { "reference" => { "value" => "CUST-0001" },
                               "name"      => { "given" => "Ada", "family" => "Lovelace" },
                               "email"     => { "address" => "ada@example.com" } })
-        new(name: "banking", setup: [register], cycle: lambda { |n|
-          number = { "value" => "acct-#{n}" }
-          money = ->(cents) { { "cents" => cents, "currency" => "USD" } }
-          [
-            Step.new("Banking::Account.Open",
-                     { "number" => number, "kind" => { "name" => "current" },
-                       "daily_limit" => { "cents" => 50_000 }, "customer" => "CUST-0001" }),
-            Step.new("Banking::Account.Credit",
-                     { "number" => number, "amount" => money.call(10_000), "narrative" => { "text" => "Deposit" } }),
-            Step.new("Banking::Account.Credit",
-                     { "number" => number, "amount" => money.call(5000), "narrative" => { "text" => "Deposit" } }),
-            Step.new("Banking::Account.Debit",
-                     { "number" => number, "amount" => money.call(2500), "narrative" => { "text" => "Groceries" } })
-          ]
-        })
+        new(name: "banking", setup: [register], cycle: method(:banking_cycle))
+      end
+
+      def self.banking_cycle(number)
+        account = { "value" => "acct-#{number}" }
+        [open_account(account), ledger_step("Credit", account, 10_000, "Deposit"),
+         ledger_step("Credit", account, 5000, "Deposit"), ledger_step("Debit", account, 2500, "Groceries")]
+      end
+
+      def self.open_account(account)
+        Step.new("Banking::Account.Open",
+                 { "number" => account, "kind" => { "name" => "current" },
+                   "daily_limit" => { "cents" => 50_000 }, "customer" => "CUST-0001" })
+      end
+
+      def self.ledger_step(verb, account, cents, narrative)
+        Step.new("Banking::Account.#{verb}",
+                 { "number" => account, "amount" => { "cents" => cents, "currency" => "USD" },
+                   "narrative" => { "text" => narrative } })
       end
     end
   end

data/lib/hecks/bluebook/aggregate.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/aggregate"
+require_relative "keyword_fields"
 require_relative "expression/ast_json"
 
 module Hecks
@@ -43,28 +44,21 @@ module Hecks
                   :projected_fields, :identified_by, :identity_paths, :identity_heads, :lifecycle,
                   :entities, :queries, :policies, :ports, :reference_targets, :provenance
 
+      # Every optional field and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        description: nil, attributes: [], value_objects: [], commands: [], invariants: [],
+        preconditions: [], projected_fields: [], identified_by: [], lifecycle: nil, entities: [],
+        queries: [], policies: [], ports: [], reference_targets: [], provenance: nil
+      }.freeze
+
       # Assigns the declared fields, then `settle` derives identity, name indexes and owner stamps.
-      def initialize(name:, description: nil, attributes: [], value_objects: [],
-                     commands: [], invariants: [], preconditions: [], projected_fields: [], identified_by: [], lifecycle: nil,
-                     entities: [], queries: [], policies: [], ports: [], reference_targets: [],
-                     provenance: nil)
-        @name              = name.to_s
-        @hecks_name        = @name
-        @description       = description
-        @attributes        = attributes
-        @value_objects     = value_objects
-        @commands          = commands
-        @invariants        = invariants
-        @preconditions     = preconditions
-        @projected_fields  = projected_fields
-        @identified_by     = identified_by
-        @lifecycle         = lifecycle
-        @entities          = entities
-        @queries           = queries
-        @policies          = policies
-        @ports             = ports
-        @reference_targets = reference_targets
-        @provenance        = provenance
+      #
+      # @param name [String, Symbol] the aggregate's name
+      # @param given [Hash] any key of `FIELD_DEFAULTS`; an unknown key raises `ArgumentError`
+      def initialize(name:, **given)
+        @name       = name.to_s
+        @hecks_name = @name
+        KeywordFields.assign(self, KeywordFields.fill(given, FIELD_DEFAULTS))
 
         settle
       end

data/lib/hecks/bluebook/assembly/aggregate_assembly.rb

@@ -15,40 +15,37 @@ module Hecks
         # @return [Bluebook::Aggregate] the built aggregate, with every reference stamped
         #   to resolve against it
         def aggregate
-          shapes   = Array(@row[:value_objects]).map { |shape| value_object(shape) }
-          commands = Array(@row[:commands]).map { |verb| Build.call("Command", verb) }
-          entities = Array(@row[:entities]).map { |piece| entity(piece) }
-          asks     = Array(@row[:queries]).map { |ask| Build.call("Query", ask) }
+          ir = Build.call("Aggregate", @row, **built_children)
 
-          fields = Array(@row[:attributes]).map { |field| Marks.attribute(field) }
+          stamp_references(ir)
+          ir
+        end
 
-          ir = Build.call(
-            "Aggregate", @row,
-            value_objects:     shapes,
-            commands:          commands,
-            entities:          entities,
-            queries:           asks,
+        private
+
+        # The children `Build` cannot derive from the row alone, already built.
+        def built_children
+          {
+            value_objects:     build_all("ValueObject", @row[:value_objects]),
+            commands:          build_all("Command", @row[:commands]),
+            entities:          Array(@row[:entities]).map { |piece| entity(piece) },
+            queries:           build_all("Query", @row[:queries]),
             lifecycle:         lifecycle_of(@row),
             # Policies live on the chapter, which is what `PolicyInterpreter` reads.
             policies:          [],
-            reference_targets: reference_targets(fields)
-          )
-
-          stamp_references(ir)
-          ir
+            reference_targets: reference_targets(Array(@row[:attributes]).map { |field| Marks.attribute(field) })
+          }
         end
 
-        private
+        def build_all(category, rows)
+          Array(rows).map { |row| Build.call(category, row) }
+        end
 
         # Read from attributes, not commands: a command's self-references are not targets.
         def reference_targets(fields)
           fields.select(&:reference?).map { |field| field.type.target_name }
         end
 
-        def value_object(row)
-          Build.call("ValueObject", row)
-        end
-
         # Recurses, so entities nest to any depth (ADR 0026).
         def entity(row)
           Build.call(

data/lib/hecks/bluebook/assembly/build.rb

@@ -45,16 +45,21 @@ module Hecks
           when :plain    then value
           when :identity then value&.to_sym
           when :flag     then value ? true : false
-          when Array
-            # `[:option, name]` needs its name as well as its value.
-            if reader.first == :each
-              Array(value).map { |held| Marks.public_send(reader.last, held) }
-            else
-              Marks.option(reader.last, value)
-            end
+          when Array then read_marked(reader, value)
           else Marks.public_send(reader, value)
           end
         end
+
+        # `[:option, name]` needs its name as well as its value.
+        #
+        # @param reader [Array] `[:each, marks_method]` or `[:option, name]`
+        # @param value [Object] the raw declared value to read
+        # @return [Object] the value read through the `Marks` method `reader` names
+        def read_marked(reader, value)
+          return Marks.option(reader.last, value) unless reader.first == :each
+
+          Array(value).map { |held| Marks.public_send(reader.last, held) }
+        end
       end
     end
   end

data/lib/hecks/bluebook/assembly/contracts/read_models.rb

@@ -0,0 +1,70 @@
+module Hecks
+  module Bluebook
+    class Assembly
+      # The contracts for the read model and the member; `CONTRACTS` merges every group.
+      READ_MODELS = {
+        "ReadModel" => Contract.new(
+          holder: ReadModel, make: :new,
+          fields: {
+            name:             [:name,             :plain],
+            description:      [:description,      :plain],
+            reference_name:   [:reference_name,   :identity],
+            reference_target: [:reference_target, :plain],
+            aggregate_heads:  [:aggregate_heads,  [:each, :head]],
+            group_by:         [:group_by,         [:each, :group_by_field]],
+            # Scalars, not lists: `:plain` is for Build (native to_h value);
+            # the `reads:` entry below is for Reconstruction (stringified row).
+            count:            [:count,            :plain],
+            median_field:     [:median_field,     :plain],
+            sum_field:        [:sum_field,        :plain],
+            avg_field:        [:avg_field,        :plain],
+            min_field:        [:min_field,        :plain],
+            max_field:        [:max_field,        :plain],
+            percentile_field: [:percentile_field, :plain],
+            percentile_at:    [:percentile_at,    :plain],
+            any_field:        [:any_field,        :plain],
+            all_field:        [:all_field,        :plain],
+            # A read model inherits every option an ask has, so it reads them the
+            # same way — see Query.
+            wheres:           [:wheres,           [:each, :where_clause]],
+            order_by:         [:order_by,         :order_by],
+            limit:            [:limit,            :limit],
+            offset:           [:offset,           [:option, :offset]],
+            cursor:           [:cursor,           [:option, :cursor]],
+            null_semantics:   [:null_semantics,   [:option, :null_semantics]],
+            authorization:    [:authorization,    [:option, :authorization]],
+            inspection:       [:inspection,       [:option, :inspection]]
+          },
+          rows: { options: :read_model_option_rows },
+          # `wheres` needs its own reader so an undeclared list defaults to `[]`,
+          # not the generic reader's `nil`; real values arrive via the options
+          # merge in `read_model` below, which overrides this default.
+          reads: { reference_name: :symbol, aggregate_heads: [:each, :head],
+                  group_by: [:each, :group_by_field], wheres: [:each, :where_clause],
+                  # `count` needs boolean coercion (stringified on the wire);
+                  # `median_field` needs none — the default reader already
+                  # matches `to_h`'s String-or-nil.
+                  count: :read_model_count,
+                  # `percentile_at` needs Float coercion; every other reduction field
+                  # is a Symbol-like name the default text reader already matches.
+                  percentile_at: :read_model_percentile_at },
+          derived: {
+            position:   :walk,
+            query_name: [:computed, :query_name],
+            options:    [:folded, %i[offset cursor null_semantics authorization inspection], nil]
+          }
+        ),
+
+        # Member is nested under ValueObject. Its pairs are an open map, so it
+        # holds no `shape` field — only walk-minted `position` and `pairs`
+        # (still one row per entry, still an open map).
+        "Member"    => Contract.new(
+          holder: nil, make: nil,
+          fields: {},
+          rows: { pairs: :pair_rows },
+          derived: { position: :walk, pairs: [:folded, %i[members], nil] }
+        )
+      }.freeze
+    end
+  end
+end

data/lib/hecks/bluebook/assembly/contracts/rules.rb

@@ -0,0 +1,84 @@
+module Hecks
+  module Bluebook
+    class Assembly
+      # The contracts for the ask, entity and policy; `CONTRACTS` merges every group.
+      RULES = {
+        "Query"  => Contract.new(
+          holder: Query, make: :new,
+          fields: {
+            name:           [:name,        :plain],
+            description:    [:description, :plain],
+            attributes:     [:attributes,  [:each, :shape_field]],
+            wheres:         [:wheres,          [:each, :where_clause]],
+            order_by:       [:order_by,        :order_by],
+            limit:          [:limit,           :limit],
+            returns:        [:returns,         :plain],
+            needs:          [:needs,           [:each, :need]],
+            # Held by the language as an open map, so every one of these reads the
+            # same way and a ninth option needs no new field on either side.
+            offset:         [:offset,          [:option, :offset]],
+            cursor:         [:cursor,          [:option, :cursor]],
+            null_semantics: [:null_semantics,  [:option, :null_semantics]],
+            authorization:  [:authorization,   [:option, :authorization]],
+            inspection:     [:inspection,      [:option, :inspection]]
+          },
+          rows: { wheres: :where_rows, options: :option_rows },
+          reads: { attributes: [:each, :shape_field], wheres: [:each, :where_clause],
+                  needs: [:each, :need], order_by: [:call, :order_by], limit: [:call, :limit] },
+          derived: {
+            position:    :walk,
+            order_field: [:folded, :order_by, :field],
+            order_way:   [:folded, :order_by, :direction],
+            options:     [:folded, %i[offset cursor null_semantics authorization inspection], nil]
+          }
+        ),
+
+        "Entity" => Contract.new(
+          holder: Entity, make: :declare,
+          fields: {
+            name:          [:name,          :plain],
+            description:   [:description,   :plain],
+            # A list of paths, like Aggregate's. Must be Symbols: a String looks
+            # identical here but a symbol-keyed args lookup downstream would find
+            # nothing, silently rejecting a value that was in fact passed.
+            identified_by: [:identified_by, :plain],
+            attributes:    [:attributes,    [:each, :shape_field]],
+            # Same shape as Aggregate's own `preconditions`, one level down (ADR 0028).
+            preconditions: [:preconditions, [:each, :given]],
+            # Same shape as Aggregate's own `invariants`, checked per instance of
+            # this entity rather than the aggregate's flat state.
+            invariants:    [:invariants,    [:each, :invariant]]
+          },
+          rows: { transitions: :transition_rows, identified_by: :identity_rows },
+          reads: { identified_by: [:each, :identity_path], attributes: [:each, :shape_field],
+                   preconditions: [:each, :rule], invariants: [:each, :rule] },
+          derived: {
+            position:    :walk,
+            owner:       :parent,
+            state_field: [:folded, :lifecycle, :field],
+            state_start: [:folded, :lifecycle, :default],
+            transitions: [:folded, :lifecycle, :transitions]
+          }
+        ),
+
+        "Policy" => Contract.new(
+          holder: Policy, make: :new,
+          fields: {
+            name:               [:name,            :plain],
+            aggregate:          [:aggregate,       :plain],
+            on_event:           [:on_event,        :plain],
+            trigger_command:    [:trigger_command, :plain],
+            target_domain:      [:target_domain,   :plain],
+            expect_undelivered: [:expect_undelivered, :plain],
+            where:              [:where,           :plain],
+            for_each:           [:for_each,        :plain],
+            with_spec:          [:with_spec,       :bindings]
+          },
+          rows: { with_spec: :with_spec_rows },
+          reads: { with_spec: [:from, :with_spec], expect_undelivered: :expect_undelivered? },
+          derived: { position: :walk }
+        )
+      }.freeze
+    end
+  end
+end