hecks 3.0.3 → 3.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46f6f36759cf946f2fd26b0b11b0ec64b02b7b84e1213fcf239a08aa314d0168
-  data.tar.gz: 295310e1f10f391cfdc53900f7eda2ee6b96db34ced1e93fbd73e50978b6fa07
+  metadata.gz: 16dca2d33433ad6c6cd98b8dee40f652df3d84c7bb93df5cd1f7734b99542c08
+  data.tar.gz: '084b92e2ad954b89a488d44997d754cd15388136f502f918f24274fd26cf9e87'
 SHA512:
-  metadata.gz: 9d7a89486e004a7e786177ee9debfb4fcdc1e331611da9293a29cc2e16e0b4f2b388d718d3062e7b236e27b2655f16282e6e1b1065bb151fcdd8bb67c839a34f
-  data.tar.gz: 9713d8af8eb4eebdf7885e0ec9821e304f0d6be393e22968c32b971e83d920e6f4ecfa52ce3ee46a19336de8a4e50d5c70d20c443784042aeac5607046ceb9ce
+  metadata.gz: 0f2b6dda10ee042c6cb1bbe3ae9100a66c35dad25b17a031ab7ca6fd0eaf7ea5960b1a3e52024d5a40c3090ca999f1730db9275f7a5ec8b803e8ae0a465102df
+  data.tar.gz: 8aebabbb0a023e9c2ff989df18f665924ec9acf4043a922bcb995588fb424683d8d44bea2e02f2076932beae2b27d63da097153c054131aa4232c132123d33eb

data/exe/hecks

@@ -21,10 +21,16 @@ if LEGACY.include?(ARGV.first)
   exit Hecks::CLI.start(ARGV) unless Hecks::CLI.launcher_form?(ARGV)
 end
 
+# These verbs keep nothing worth a database, so they run on Memory unless told otherwise, and
+# print nothing when they end well.
+MEMORY_VERBS = %w[console].freeze
+ENV["HECKS_ENVIRONMENT"] ||= "memory" if MEMORY_VERBS.include?(ARGV.first)
+
 require "hecks"
 
 # Usage is answered from the projected chapter alone: no adapter is bound and no
-# database is opened. Only a line that runs a verb boots the domain.
+# database is opened. Only a line that runs a verb boots the domain,
+# and it boots from what the usage check already loaded.
 domain = File.expand_path("../lib/hecks/hecks", __dir__)
 program = "hecks"
 described = begin
@@ -38,10 +44,13 @@ text, status, reason = Hecks::Doors::CliRunner.usage(
 )
 unless text
   runtime = begin
-    Hecks.boot(domain, install_doors: false)
+    Hecks::Doors::LauncherOptions.quietly(hold: MEMORY_VERBS.include?(ARGV.first)) { Hecks.boot_described(described, install_doors: false) }
   rescue StandardError => e
     abort "cannot open Hecks: #{e.message.lines.first.strip}"
   end
+  # A question the world lists under `streams`, given `--stream`, tails until interrupted.
+  streamed = Hecks::Doors::CliRunner.stream(runtime: runtime, argv: ARGV, program: program)
+  exit streamed unless streamed.nil?
   text, status, reason = Hecks::Doors::CliRunner.call(
     runtime: runtime, argv: ARGV, program: program
   )
@@ -53,4 +62,5 @@ if reason
   warn reason
   exit status
 end
+exit 0 if status.zero? && MEMORY_VERBS.include?(ARGV.first)
 status.zero? ? puts(text) : abort(text)

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

@@ -62,6 +62,7 @@ module Hecks
             attributes: [:attributes, [:each, :shape_field]],
             givens:     [:givens,     [:each, :given]],
             ensures:    [:ensures,    [:each, :given]],
+            needs:      [:needs,      [:each, :need]],
             mutations:  [:mutations,  [:each, :mutation]],
             emits:      [:emits,      :plain],
             # Lifecycle state as a command guard: one state, an array, or nil (ADR 0025).
@@ -70,7 +71,8 @@ module Hecks
           },
           rows: { mutations: :mutation_rows },
           reads: { attributes: [:each, :shape_field], givens: [:each, :rule], ensures: [:each, :rule],
-                  mutations: [:call, :mutations], emits: :names, provenance: :provenance, from: :from },
+                  needs: [:each, :need], mutations: [:call, :mutations], emits: :names, provenance: :provenance,
+                  from: :from },
           derived: { position: :walk }
         ),
 

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

@@ -74,6 +74,9 @@ module Hecks
           Given.new(description: rule[:description], canonical: rule[:canonical])
         end
 
+        # One outside fact a command needs, as the Symbol `Command#needs` holds.
+        def need(row) = row[:fact].to_sym
+
         # All three fields are identifiers, unlike Invariant/Given's free text, so they
         # come back as Symbols.
         def projected_field(row)

data/lib/hecks/bluebook/command.rb

@@ -54,6 +54,7 @@ module Hecks
         attributes: many(:attributes),
         givens:     -> { givens.map { |rule| Expression::AstJson.rule_row(rule) } },
         ensures:    -> { ensures.map { |rule| Expression::AstJson.rule_row(rule) } },
+        needs:      -> { needs.map { |fact| { fact: fact.to_s } } },
         mutations:  many(:mutations),
         emits:      :emits,
         # The lifecycle state this command is admissible from: a guard, not a transition.
@@ -62,7 +63,7 @@ module Hecks
       )
 
       class << self
-        attr_reader :role, :goal, :attributes, :givens, :ensures, :mutations, :emits, :references,
+        attr_reader :role, :goal, :attributes, :givens, :ensures, :needs, :mutations, :emits, :references,
                     :from, :provenance
 
         # Mints one command as its own anonymous subclass of the class `declare` is called on.
@@ -71,18 +72,18 @@ module Hecks
         # @param role [String, nil] the declared role text; `goal` is the goal text
         # @param attributes [Array<Bluebook::Attribute>] the declared arguments
         # @param givens [Array<Bluebook::Given>] the declared preconditions
-        # @param ensures [Array<Bluebook::Given>] the declared postconditions
+        # @param ensures [Array<Bluebook::Given>] the postconditions; `needs` the facts it supplies
         # @param mutations [Array<Bluebook::Mutation>] the state changes it applies
         # @param emits [Array<String>] the event names it may emit
         # @param references [String, Symbol, nil] the aggregate its `reference_to` addresses
         # @param from [String, Array<String>, nil] the lifecycle states it is admissible from
         # @param provenance [Object, nil] the declared canonical source, as written
-        def declare(name:, role: nil, goal: nil, attributes: [], givens: [], ensures: [],
+        def declare(name:, role: nil, goal: nil, attributes: [], givens: [], ensures: [], needs: [],
                     mutations: [], emits: [], references: nil, from: nil, provenance: nil)
           verb = Class.new(self)
           verb.hecks_name = name.to_s
           verb.absorb(role: role, goal: goal, attributes: attributes, givens: givens,
-                      ensures: ensures, mutations: mutations, emits: emits, references: references&.to_s,
+                      ensures: ensures, needs: needs, mutations: mutations, emits: emits, references: references&.to_s,
                       from: from, provenance: provenance)
           verb
         end
@@ -93,12 +94,13 @@ module Hecks
         #
         # @return [Class] self
         def absorb(role:, goal:, attributes:, givens:, ensures:, mutations:, emits:, references:,
-                   from: nil, provenance: nil)
+                   needs: [], from: nil, provenance: nil)
           @role       = role
           @goal       = goal
           @attributes = attributes
           @givens     = givens
           @ensures    = ensures
+          @needs      = needs
           @mutations  = mutations
           @emits      = emits
           @references = references

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

@@ -41,6 +41,7 @@ module Hecks
           ["Command", "then_set"] => :then_set_impl,
           ["Command", "delegates_to"] => :delegates_to_impl,
           ["Command", "attribute"] => :attribute_impl,
+          ["Command", "needs"] => :needs_impl,
           ["Command", "corrects"] => :corrects_impl,
           ["Entity", "identified_by"] => :identified_by_impl,
           ["Entity", "given"] => :given_impl,

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

@@ -22,6 +22,7 @@ module Hecks
           @owner             = owner
           @givens            = []
           @ensures           = []
+          @needs             = []
           @mutations         = []
           @emits             = []
           @named_givens      = named_givens
@@ -66,6 +67,31 @@ module Hecks
         # @return [String] the description as stored
         def goal(value) = @goal = value
 
+        # The outside facts a command may declare it needs, each the name of the attribute the
+        # runtime fills when the caller leaves it out. `now` is the clock port's answer, in epoch
+        # seconds.
+        NEEDABLE_FACTS = %i[now].freeze
+
+        # Declares an outside fact the runtime supplies before any given runs (ADR 0081):
+        # `needs :now` fills the command's own `now` attribute from the clock port when the caller
+        # names none.
+        #
+        # @param fact [Symbol] one of `NEEDABLE_FACTS`
+        # @return [Array<Symbol>] the facts declared so far
+        # @raise [Bluebook::DSL::Malformed] if the fact is not one the runtime can supply, or is
+        #   declared twice
+        def needs_impl(fact)
+          fact = fact.to_sym
+          unless NEEDABLE_FACTS.include?(fact)
+            raise Malformed,
+                  "#{@name} needs :#{fact}, which the runtime cannot supply — it supplies " \
+                  "#{NEEDABLE_FACTS.map { |known| ":#{known}" }.join(', ')}"
+          end
+          raise Malformed, "#{@name} declares needs :#{fact} twice" if @needs.include?(fact)
+
+          @needs << fact
+        end
+
         # Names where a concept adopted from a canonical source came from.
         #
         # @param from [Object] the canonical source, captured exactly as written
@@ -292,6 +318,7 @@ module Hecks
         def build
           resolve_implicit_attributes!
           refuse_duplicate_targets!
+          refuse_undeclared_needs!
 
           delegation = @mutations.find { |mutation| mutation.op == :delegate }
           if delegation && (@mutations.size > 1 || @emits.any?)
@@ -308,6 +335,7 @@ module Hecks
             attributes: attributes,
             givens:     @givens,
             ensures:    @ensures,
+            needs:      @needs,
             mutations:  @mutations,
             emits:      @emits,
             references: @references,
@@ -316,6 +344,20 @@ module Hecks
           )
         end
 
+        # A fact is filled into the argument of the same name, so the command declares one.
+        #
+        # @raise [Bluebook::DSL::Malformed] if a needed fact has no attribute to fill
+        def refuse_undeclared_needs!
+          declared = attributes.map { |attribute| attribute.name.to_s }
+          missing  = @needs.reject { |fact| declared.include?(fact.to_s) }
+          return if missing.empty?
+
+          raise Malformed,
+                "#{@name} needs :#{missing.first} but declares no attribute :#{missing.first} " \
+                "for the runtime to fill — add `attribute :#{missing.first}, <type>`"
+        end
+        private :refuse_undeclared_needs!
+
         # Evaluates a `command` block against a fresh builder and returns what it built.
         #
         # @param name [String] the command's name

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

@@ -40,6 +40,7 @@ module Hecks
           case rule.strategy
           when "collapse_whitespace" then map_outside_strings(text) { |segment| segment.gsub(/\s+/, " ") }
           when "replace"             then replace(text, rule)
+          when "scale_call"          then scale_call(text, rule)
           else
             raise ArgumentError, "#{rule.strategy.inspect} is not a linked normalisation strategy"
           end
@@ -55,6 +56,17 @@ module Hecks
           end
         end
 
+        # Folds a duration written as a call on a whole number into seconds: `days(730)` becomes
+        # `63072000` when the rule's token is `days` and its replacement `86400`. A call on anything
+        # but a literal whole number is left as written, and a method call (`x.days(3)`) is not a
+        # duration.
+        def scale_call(text, rule)
+          call = /(?<![[:alnum:]_.])#{Regexp.escape(rule.source_token)}\(\s*(\d+)\s*\)/
+          map_outside_strings(text) do |segment|
+            segment.gsub(call) { (Regexp.last_match(1).to_i * rule.replacement.to_i).to_s }
+          end
+        end
+
         # Yields each run of `text` outside quoted literals, copying quoted runs through verbatim.
         # Quote-blind rewriting would change what a predicate compares a string against.
         # Handles `"` and `'`; an unterminated quote is passed through raw.

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

@@ -225,6 +225,27 @@
       "replacement": ".size",
       "boundary": "word",
       "position": 2
+    },
+    {
+      "strategy": "scale_call",
+      "source_token": "days",
+      "replacement": "86400",
+      "boundary": "word",
+      "position": 3
+    },
+    {
+      "strategy": "scale_call",
+      "source_token": "hours",
+      "replacement": "3600",
+      "boundary": "word",
+      "position": 4
+    },
+    {
+      "strategy": "scale_call",
+      "source_token": "minutes",
+      "replacement": "60",
+      "boundary": "word",
+      "position": 5
     }
   ]
 }

data/lib/hecks/bluebook/meta_validator/shapes.rb

@@ -83,6 +83,9 @@ module Hecks
         # A rule's plain description/canonical pair, for a `given`/`invariant`/`ensures`.
         def rule(row) = { description: text(row[:description]), canonical: text(row[:canonical]) }
 
+        # One outside fact a command needs, in the shape `Command#to_h` emits it.
+        def need(row) = { fact: text(row[:fact]) }
+
         # `projects :name, from: :"reference.remote_field"` (ADR 0025), read back as
         # its plain name/reference/remote_field triple.
         def projected_field(row)

data/lib/hecks/cli/console.rb

@@ -9,7 +9,7 @@ module Hecks
     # The command behind `hecks console` and Custodian's `Operation.OpenConsole`: boots a domain
     # (pizzas on Memory by default) and drops into IRB with its door installed, for dispatching a
     # real command by hand. No argument needs no database (ADR 0073); a domain directory boots as
-    # it is wired, which may bind PostgresEra.
+    # it is wired, which may bind PostgresEra (examples/directory does).
     module Console
       PIZZAS = File.expand_path("../../../examples/pizzas", __dir__)
 
@@ -25,14 +25,27 @@ module Hecks
       # @param domain [String, nil] a domain directory; the bundled pizzas domain when nil
       # @param launcher [#call] starts the interactive session; IRB unless a caller stands in
       # @return [Runtime] the runtime the session ran against
-      def call(domain = nil, launcher: -> { IRB.start(__FILE__) })
+      def call(domain = nil, launcher: -> { irb_session })
         runtime = domain ? Hecks.boot(domain) : Hecks.boot_files(DEFAULT_FILES)
         puts overview(runtime)
-        puts banner
+        puts banner(domain)
         launcher.call
         runtime
       end
 
+      # Starts IRB with an empty command line. IRB reads `ARGV` for a script to run, and a
+      # launcher's `ARGV` holds its own words (`console`, `subject=<domain>`), which IRB would
+      # open as a file and then exit without a prompt.
+      #
+      # @return [void] when the session ends; `ARGV` is restored
+      def irb_session
+        words = ARGV.dup
+        ARGV.clear
+        IRB.start(__FILE__)
+      ensure
+        ARGV.replace(words)
+      end
+
       # @param runtime [Runtime] a booted domain
       # @return [String] each chapter's vision and its aggregates' commands
       def overview(runtime)
@@ -46,16 +59,19 @@ module Hecks
         end.join
       end
 
-      # @return [String] the version and a first session to try against the pizzas domain
-      def banner
+      # @param domain [String, nil] a domain directory, or nil for the bundled pizzas domain
+      # @return [String] the version, and for the pizzas domain a first session to try
+      def banner(domain = nil)
+        return "\nhecks #{Hecks::VERSION}\n\n" if domain
+
         <<~BANNER
 
           hecks #{Hecks::VERSION}
 
           try:
-            order = Order.create_pizza!(name: { value: "Margherita" }, pizza: { price_cents: { cents: 1200 }, size: { value: "large" } })
-            order.add_topping!(topping: { value: "Basil" }, amount: { value: 3 })
-            order.purchase!(customer_name: { value: "Chris" }, amount: { cents: 1200 })
+            order = Order.create_pizza!(name: "Margherita", pizza: { price_cents: { cents: 1200 }, size: "large" })
+            order.add_topping!(topping: "Basil", amount: 3)
+            order.purchase!(customer_name: "Chris", amount: { cents: 1200 })
             order.status
             order.events.last
 

data/lib/hecks/cli/project_cli.rb

@@ -103,7 +103,7 @@ module Hecks
         label      = executable || "#{path}/#{snake}"
         file       = File.join(root, label)
         text       = launcher(path, name, program, executable: executable, legacy: setting[:legacy],
-                          opted: !setting.empty?)
+                          memory_verbs: setting[:memory_verbs], opted: !setting.empty?)
         return skip(path, "#{label} is a directory") if File.directory?(file)
 
         return :drifted if check && !(File.file?(file) && File.read(file) == text)
@@ -150,10 +150,11 @@ module Hecks
       # @param executable [String, nil] the file's path under the root when it is not beside the
       #   domain; its program name is then that file's basename, and its header names the generator
       # @param legacy [Array<String>, nil] verbs an executable hands to `Hecks::CLI` first
+      # @param memory_verbs [Array<String>, nil] verbs run on Memory unless HECKS_ENVIRONMENT is set
       # @param opted [Boolean] whether the chapter's world declares a `launcher` setting
       # @return [String] the Ruby source
       # @raise [ArgumentError] if a name, path, executable or legacy verb is not plain
-      def launcher(path, name, program, executable: nil, legacy: nil, opted: !executable.nil?)
+      def launcher(path, name, program, executable: nil, legacy: nil, memory_verbs: nil, opted: !executable.nil?)
         plain!("chapter name", name, NAME)
         plain!("domain path", path, PATH)
         snake = Naming.snake(name)
@@ -174,9 +175,10 @@ module Hecks
           where = shown = "#{path}/#{snake}"
         end
 
-        handoff  = legacy_handoff(Array(legacy)) if executable
+        handoff  = legacy_handoff(Array(legacy)) + memory_default(Array(memory_verbs)) if executable
         encoding = opted ? ENCODING : ""
         ending   = opted ? OPTED_ENDING : PLAIN_ENDING
+        ending   = quiet_ending(ending) if executable && !Array(memory_verbs).empty?
 
         <<~RUBY
           #!/usr/bin/env ruby
@@ -194,7 +196,7 @@ module Hecks
           #{handoff}
           require "hecks"
 
-          #{entry(name, boot, shown, opted)}
+          #{entry(name, boot, shown, opted, quiet: !Array(memory_verbs).empty?)}
           #{ending}
         RUBY
       end
@@ -203,16 +205,19 @@ module Hecks
       # @return [String] the launcher's middle: for an opted-in launcher, usage answered from the
       #   projection and a boot only for a line that runs a verb; for any other, the boot and
       #   dispatch every launcher has always had, byte for byte
-      def entry(name, boot, shown, opted)
-        opted ? described_entry(name, boot, shown) : plain_entry(name, boot, shown)
+      def entry(name, boot, shown, opted, quiet: false)
+        opted ? described_entry(name, boot, shown, quiet: quiet) : plain_entry(name, boot, shown)
       end
 
       # @api private
       # @return [String] the opted-in launcher's middle
-      def described_entry(name, boot, shown)
+      def described_entry(name, boot, shown, quiet: false)
+        started = "Hecks.boot_described(described, install_doors: false)"
+        started = "Hecks::Doors::LauncherOptions.quietly(hold: MEMORY_VERBS.include?(ARGV.first)) { #{started} }" if quiet
         <<~RUBY.chomp
           # Usage is answered from the projected chapter alone: no adapter is bound and no
-          # database is opened. Only a line that runs a verb boots the domain.
+          # database is opened. Only a line that runs a verb boots the domain,
+          # and it boots from what the usage check already loaded.
           domain = #{boot}
           program = "#{shown}"
           described = begin
@@ -226,10 +231,13 @@ module Hecks
           )
           unless text
             runtime = begin
-              Hecks.boot(domain, install_doors: false)
+              #{started}
             rescue StandardError => e
               abort "cannot open #{name}: \#{e.message.lines.first.strip}"
             end
+            # A question the world lists under `streams`, given `--stream`, tails until interrupted.
+            streamed = Hecks::Doors::CliRunner.stream(runtime: runtime, argv: ARGV, program: program)
+            exit streamed unless streamed.nil?
             text, status, reason = Hecks::Doors::CliRunner.call(
               runtime: runtime, argv: ARGV, program: program
             )
@@ -260,6 +268,31 @@ module Hecks
         raise ArgumentError, "#{what} #{value.to_s.inspect} is not a plain word or path"
       end
 
+      # @api private
+      # @param ending [String] the launcher's closing lines
+      # @return [String] the same lines, except that a memory verb that ended well prints nothing: a
+      #   person is at it, so the settled record is noise after the session
+      def quiet_ending(ending)
+        ending.sub("status.zero? ? puts(text)",
+                   "exit 0 if status.zero? && MEMORY_VERBS.include?(ARGV.first)\nstatus.zero? ? puts(text)")
+      end
+
+      # @api private
+      # @return [String] the lines that default the listed verbs to Memory, or nothing
+      def memory_default(verbs)
+        return "" if verbs.empty?
+
+        verbs.each { |verb| plain!("memory verb", verb, VERB) }
+
+        <<~RUBY
+
+          # These verbs keep nothing worth a database, so they run on Memory unless told otherwise, and
+          # print nothing when they end well.
+          MEMORY_VERBS = %w[#{verbs.join(' ')}].freeze
+          ENV["HECKS_ENVIRONMENT"] ||= "memory" if MEMORY_VERBS.include?(ARGV.first)
+        RUBY
+      end
+
       # @api private
       # @return [String] the lines that hand the legacy verbs to `Hecks::CLI`, or nothing
       def legacy_handoff(legacy)

data/lib/hecks/cli/seed_semantics_corpus.rb

@@ -7,9 +7,12 @@ require_relative "../fuzzing"
 module Hecks
   module CLI
     # The command behind `hecks seed_semantics_corpus`: seeds (or deliberately re-seeds) the
-    # `expect` block of semantics-corpus fixtures from the Ruby runtime. Review the result
+    # `expect` block of corpus fixtures from the Ruby runtime. Review the result
     # against `docs/semantics/bluebook-semantics.md` before committing.
     #
+    # Seeds `spec/corpus/semantics/` and the conformance corpus ({FULL_SCRIPTS} plus
+    # `spec/corpus/rust_conformance/`, whose `expect` also freezes more).
+    #
     #   hecks seed_semantics_corpus                                # fill fixtures missing an expect
     #   SEED=refusal_kind_lifecycle hecks seed_semantics_corpus    # re-seed one, deliberately
     #
@@ -18,6 +21,15 @@ module Hecks
     module SeedSemanticsCorpus
       module_function
 
+      # Full corpus scripts held to the conformance bar, keyed by file, valued by domain.
+      FULL_SCRIPTS = {
+        "spec/corpus/banking.json" => "examples/banking",
+        "spec/corpus/chess.json"   => "examples/chess"
+      }.freeze
+
+      # The `expect` keys a conformance fixture freezes beyond the semantics three.
+      CONFORMANCE_KEYS = %w[queries sagas dry_runs reactions].freeze
+
       # Seeds the fixtures that need it and reports which.
       #
       # @param root [String] the checkout whose `spec/corpus/semantics/` is seeded
@@ -26,12 +38,13 @@ module Hecks
       # @return [Integer] the exit status, always 0
       def call(root:, env: ENV, out: $stdout)
         only = env.fetch("SEED", nil)
-        seeded = Dir.glob(File.join(root, "spec/corpus/semantics", "*.json")).filter_map do |path|
+        seeded = corpus_paths(root).filter_map do |path, domain, full|
           fixture = JSON.parse(File.read(path))
           name = File.basename(path, ".json")
           next if only ? only != name : fixture.key?("expect")
 
-          fixture["expect"] = expectation_for(root, fixture)
+          fixture["domain"] ||= domain if domain
+          fixture["expect"] = expectation_for(root, fixture, full: full)
           File.write(path, "#{JSON.pretty_generate(fixture)}\n")
           name
         end
@@ -39,19 +52,35 @@ module Hecks
         0
       end
 
+      # @param root [String] the checkout
+      # @return [Array<Array>] `[path, domain_to_add_or_nil, full_expect?]` for every seedable file
+      def corpus_paths(root)
+        semantics = Dir.glob(File.join(root, "spec/corpus/semantics", "*.json")).map { |p| [p, nil, false] }
+        conformance = Dir.glob(File.join(root, "spec/corpus/rust_conformance", "*.json")).map { |p| [p, nil, true] }
+        scripts = FULL_SCRIPTS.map { |file, domain| [File.join(root, file), domain, true] }
+        semantics + conformance + scripts
+      end
+
       # Replays the fixture's script against the Ruby runtime. Each refusal's `"kind"` is reduced
       # to its class name; `occurred_at` is stripped from events.
       #
       # @param root [String] the checkout the fixture's domain path is relative to
       # @param fixture [Hash] the parsed fixture: `domain` and `steps`
-      # @return [Hash{String => Array}] its `"expect"` block: refusals, instances, events
-      def expectation_for(root, fixture)
+      # @param full [Boolean] also freeze queries, sagas, dry runs, reactions (conformance)
+      # @return [Hash{String => Array}] its `"expect"` block: refusals, instances, events, and
+      #   with `full` the {CONFORMANCE_KEYS}
+      def expectation_for(root, fixture, full: false)
         result = Hecks::Fuzzing::Replay.call(File.join(root, fixture["domain"]), fixture["steps"])
-        {
+        expect = {
           "refusals"  => JSON.parse(JSON.generate(result[:refusals])).each { |r| r["kind"] = r["kind"]&.split("::")&.last },
           "instances" => JSON.parse(JSON.generate(result[:instances])),
           "events"    => JSON.parse(JSON.generate(result[:events])).each { |e| e.delete("occurred_at") }
         }
+        return expect unless full
+
+        # instances_at is Replay's per-query snapshot for the property harness, not an outcome.
+        expect["queries"] = JSON.parse(JSON.generate(result[:queries].map { |q| q.except(:instances_at) }))
+        expect.merge!(CONFORMANCE_KEYS.drop(1).to_h { |k| [k, JSON.parse(JSON.generate(result[k.to_sym]))] })
       end
 
       # @param out [IO] where the report goes

data/lib/hecks/deploy/bluebook/deploy.bluebook

@@ -20,6 +20,9 @@ Hecks.bluebook "Deploy" do
     attribute :timeout,  Timeout
     attribute :database, Database
     attribute :web,      Web
+    attribute :dispatch, Dispatch,      optional: true
+    attribute :handler_module, HandlerModule, optional: true
+    attribute :secret_env, SecretEnv,   optional: true
 
     value_object "DomainName" do
       attribute :value, String
@@ -47,6 +50,27 @@ Hecks.bluebook "Deploy" do
       attribute :value, String, one_of: ["None", "Rust"]
     end
 
+    # "Rust" (default) or "None": a domain with no `.bluebook` command surface to dispatch through
+    # (a webhook that dispatches straight into Ruby) skips the rust/host dispatch Lambda, and its
+    # WebFunction becomes its only Lambda. That WebFunction's `lambda_handler.rb` defines the module
+    # `handler_module` names, so `dispatch "None"` must name one.
+    value_object "Dispatch" do
+      attribute :value, String, one_of: ["Rust", "None"]
+    end
+
+    # The module the domain's `lambda_handler.rb` defines for its WebFunction.
+    value_object "HandlerModule" do
+      attribute :value, String
+      invariant("a handler module is named") { !value.to_s.empty? }
+    end
+
+    # The env var the WebFunction's `lambda_handler.rb` finds the fetched secret's plaintext under,
+    # once it resolves `<name>_ARN`.
+    value_object "SecretEnv" do
+      attribute :value, String
+      invariant("a secret env var is named") { !value.to_s.empty? }
+    end
+
     # 128-10240 MB, AWS Lambda's own floor and ceiling.
     value_object "Memory" do
       attribute :value, Integer
@@ -73,6 +97,13 @@ Hecks.bluebook "Deploy" do
       attribute :timeout,  Timeout
       attribute :database, Database
       attribute :web,      Web
+      attribute :dispatch, Dispatch,      optional: true
+      attribute :handler_module, HandlerModule, optional: true
+      attribute :secret_env, SecretEnv,   optional: true
+
+      given('dispatch "None" names its handler_module: add handler_module "YourModuleName" for the module lambda_handler.rb defines') do
+        dispatch.unset? || dispatch.value != "None" || handler_module.set?
+      end
 
       sets :domain
       sets :region
@@ -80,6 +111,9 @@ Hecks.bluebook "Deploy" do
       sets :timeout
       sets :database
       sets :web
+      sets :dispatch
+      sets :handler_module
+      sets :secret_env
 
       emits "LambdaTargetDeclared"
     end