hecks 4.0.0 → 6.0.0

data/lib/hecks/hecks/adapters/journal_store/held_domain.rb

@@ -18,6 +18,15 @@ module Hecks
 
         attr_reader :registry, :bluebook, :directory, :adapter_name
 
+        # @return [String] the held domain's name
+        def domain_name = bluebook.name
+
+        # @return [Array<Bluebook::Aggregate>] the held domain's aggregates
+        def aggregates = bluebook.aggregates
+
+        # @return [Array<Bluebook::Translation>] the translation edges the domain loaded
+        def translations = registry.translations
+
         # Loads a domain and finds where its eras would be held.
         #
         # @param path [String] the domain directory, or the project holding its `bluebook/`
@@ -48,7 +57,7 @@ module Hecks
             loading.load_project(loading.shared_root(nil, directory))
             case mode
             when :translated then loading.load_domain(directory, environment: environment)
-            when :bare then loading.load_each(directory, %w[*.port *.adapter *.bluebook *.hecksagon *.world])
+            when :bare then load_bare(loading, directory, environment)
             else load_scaffold(loading, directory, environment)
             end
           end
@@ -59,10 +68,13 @@ module Hecks
           loading.load_each(directory, %w[*.port *.adapter])
           loading.load_bluebooks(directory)
           loading.load_each(directory, %w[*.hecksagon *.world])
-          return unless environment
+          loading.load_overlay(directory, environment)
+        end
 
-          loading.load_each(directory, [File.join("environments", "#{environment}.hecksagon")])
-          loading.load_each(directory, [File.join("environments", "#{environment}.world")])
+        # @api private
+        def self.load_bare(loading, directory, environment)
+          loading.load_each(directory, %w[*.port *.adapter *.bluebook *.hecksagon *.world])
+          loading.load_overlay(directory, environment)
         end
 
         # @param registry [Runtime::Registry] the loaded registry
@@ -71,7 +83,7 @@ module Hecks
         def initialize(registry, directory)
           @registry = registry
           @directory = directory
-          @bluebook = registry.bluebooks.values.first or raise Runtime::NotFound, "no bluebook in #{directory}"
+          @bluebook = registry.first_bluebook or raise Runtime::NotFound, "no bluebook in #{directory}"
           first = @bluebook.aggregates.first or raise Runtime::NotFound, "#{@bluebook.name} declares no aggregates"
           @adapter_name = Ports::Persistence::BindingPolicy.resolve(registry, @bluebook.name, first).adapter
         end

data/lib/hecks/hecks/adapters/journal_store/readings/attestation.rb

@@ -21,7 +21,7 @@ module Hecks
             mismatch(held, era, ordinal, computed)
           end
 
-          def era_name(held, ordinal) = "#{held.bluebook.name} era #{ordinal}"
+          def era_name(held, ordinal) = "#{held.domain_name} era #{ordinal}"
 
           def mismatch(held, era, ordinal, computed)
             [
@@ -30,13 +30,13 @@ module Hecks
               shape_line(held, era, ordinal),
               "The held text AS IT NOW STANDS — the original is gone; this is what you would be attesting to:",
               "─" * 72, era[:held_text], "─" * 72,
-              "Read it, then `hecks reattest #{held.bluebook.name} era=#{ordinal} --confirm` accepts it."
+              "Read it, then `hecks reattest #{held.domain_name} era=#{ordinal} --confirm` accepts it."
             ].join("\n")
           end
 
           def shape_line(held, era, ordinal)
             verdict = Translation::Reattest.shape_guard!(
-              domain: held.bluebook.name, ordinal: ordinal, text: era[:held_text], stored_hash: era[:hash],
+              domain: held.domain_name, ordinal: ordinal, text: era[:held_text], stored_hash: era[:hash],
               stored_projection: era[:held_projection] && JSON.parse(era[:held_projection])
             )
             if verdict == :cosmetic

data/lib/hecks/hecks/adapters/journal_store/readings/scaffolding.rb

@@ -6,11 +6,14 @@ module Hecks
       module Readings
         # The edge file that would lead the latest held era to the current shape.
         module Scaffolding
+          # A line of an edge file that still marks a field as unresolved.
+          UNRESOLVED_LINE = /^\s*unresolved /
+
           private
 
           def scaffold(held, lineage, path)
             eras = held.held_eras(lineage)
-            return Readings.no_era(held.bluebook.name, path) if eras.empty?
+            return Readings.no_era(held.domain_name, path) if eras.empty?
 
             scaffold_latest(held, held.named(eras.last))
           end
@@ -18,7 +21,7 @@ module Hecks
           # The edge text for the latest era, or why there is nothing to scaffold.
           def scaffold_latest(held, latest)
             shadow = PostgresEra::LineageManager.shadow(latest[:held_text])
-            return "#{held.bluebook.name} matches era #{latest[:ordinal]} — nothing to scaffold." if
+            return "#{held.domain_name} matches era #{latest[:ordinal]} — nothing to scaffold." if
               Runtime::StorageShape.project(shadow) == held.shape
 
             edge_text(held, latest, Translation::Scaffold.diff(shadow, held.bluebook))
@@ -27,7 +30,7 @@ module Hecks
           def edge_text(held, latest, diffed)
             label = Runtime::StorageShape.mint_hash(held.bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
             edge = Translation::Scaffold::Edge.new(
-              domain: held.bluebook.name, from: latest[:label], to: label, ordinal: latest[:ordinal] + 1,
+              domain: held.domain_name, from: latest[:label], to: label, ordinal: latest[:ordinal] + 1,
               label: label, aggregates: diffed[:aggregates], retired: diffed[:retired]
             )
             text = Translation::Scaffold.render(edge)
@@ -35,7 +38,7 @@ module Hecks
           end
 
           def scaffold_notes(edge, text, unclaimed)
-            unresolved = text.scan(/^\s*unresolved /).size
+            unresolved = text.scan(UNRESOLVED_LINE).size
             notes = ["# Save as translations/#{edge.ordinal}-#{edge.label}.bluebook."]
             notes << "# #{unresolved} unresolved: decide what each became, then boot." if unresolved.positive?
             unclaimed.each do |name|

data/lib/hecks/hecks/adapters/journal_store/readings.rb

@@ -108,10 +108,10 @@ module Hecks
 
         def audit(held, lineage, path)
           eras = held.held_eras(lineage)
-          return Readings.no_era(held.bluebook.name, path) if eras.empty?
+          return Readings.no_era(held.domain_name, path) if eras.empty?
 
           finding = EdgeAudit.call(held, lineage, eras)
-          return "#{held.bluebook.name} stands at era 1 — no edge to audit." unless finding
+          return "#{held.domain_name} stands at era 1 — no edge to audit." unless finding
           raise Runtime::NotFound, "#{finding.report}\nAUDIT REFUSED." unless finding.ok
 
           [finding.report, AUDIT_PASSED].join("\n")

data/lib/hecks/hecks/adapters/journal_store.rb

@@ -32,7 +32,7 @@ module Hecks
       def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
 
       # Aggregate names, from the comma-separated list a request carries.
-      def names(list) = plain(list).to_s.split(",").map(&:strip).reject(&:empty?)
+      def names(list) = Text.comma_list(plain(list))
 
       # `id:old,id:new` as the map the tail merge takes; the side is what follows the last colon.
       def winners(held)
@@ -46,7 +46,7 @@ module Hecks
       def raw_era(domain, lineage, ordinal)
         present = lineage.db.exec("SELECT to_regclass('hecks_eras') AS present")[0]["present"]
         (present && lineage.raw_era(ordinal)) or
-          raise Runtime::NotFound, "#{domain.bluebook.name} holds no era #{ordinal}"
+          raise Runtime::NotFound, "#{domain.domain_name} holds no era #{ordinal}"
       end
     end
   end

data/lib/hecks/hecks/adapters/ledger/chain.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module Hecks
+  module Adapters
+    class Ledger
+      # The hash chain over a journal's entries: each digest takes the digest before it, so
+      # changing, dropping or reordering an entry changes every digest after it.
+      module Chain
+        # The digest a chain starts from: sixty-four zeros.
+        GENESIS = ("0" * 64).freeze
+
+        module_function
+
+        # The digest after one entry.
+        #
+        # Every field is length-prefixed, so no two entries pack to the same bytes.
+        #
+        # @param previous [String] the digest before this entry
+        # @param aggregate [Bluebook::Aggregate] the aggregate whose state codec encodes the entry
+        # @param entry [Ports::Persistence::Entry] the journal entry
+        # @return [String] the next digest, lowercase hexadecimal
+        def step(previous, aggregate, entry)
+          hasher = Digest::SHA256.new
+          hasher << previous
+          fields(aggregate, entry).each do |field|
+            hasher << [field.bytesize].pack("Q>")
+            hasher << field
+          end
+          hasher.hexdigest
+        end
+
+        # The digest after a run of entries.
+        #
+        # @param seed [String] the digest before the first entry
+        # @param aggregate [Bluebook::Aggregate] the aggregate the entries belong to
+        # @param entries [Array<Ports::Persistence::Entry>] the entries, in append order
+        # @return [String] the last digest, or `seed` when there are none
+        def fold(seed, aggregate, entries)
+          entries.reduce(seed) { |digest, entry| step(digest, aggregate, entry) }
+        end
+
+        # One digest for several journals' sealed points, independent of their order.
+        #
+        # @param points [Array<Hash>] each with `name:`, `through:` and the digest under `key`
+        # @param key [Symbol] which digest of each point to take: `:head` or `:previous`
+        # @return [String] lowercase hexadecimal
+        def summary(points, key)
+          lines = points.sort_by { |point| point[:name] }.map { |point| "#{point[:name]}:#{point[:through]}:#{point[key]}" }
+          Digest::SHA256.hexdigest(lines.join("\n"))
+        end
+
+        # What an entry contributes to its digest, as text.
+        def fields(aggregate, entry)
+          state = entry.state && Ports::Persistence::StateCodec.encode(aggregate, entry.state)
+          [entry.operation, entry.id.to_s, JSON.generate(state), JSON.generate(entry.mirrors)]
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/ledger/journal.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "chain"
+
+module Hecks
+  module Adapters
+    class Ledger
+      # One chained journal of a booted domain: the persistence adapter that holds it, and the seals
+      # kept beside it.
+      #
+      # An adapter's journal is chained when it can keep seals (`ledger_anchors`,
+      # `record_ledger_anchor`) beside the entries it appends. A sequenced journal (Postgres,
+      # Sqlite) seals up to its projection checkpoint, the point compaction deletes through, and
+      # counts a seal by sequence; a journal with no sequence (Heki) seals everything it holds
+      # and counts entries.
+      class Journal
+        # The seal before the first: nothing covered, the genesis digest.
+        START = { through: 0, head: Chain::GENESIS }.freeze
+
+        # @return [String] the aggregate's storage name, as the journal is named
+        attr_reader :name
+
+        # @param aggregate [Bluebook::Aggregate] the aggregate the journal belongs to
+        # @param adapter [Object] the persistence adapter holding its entries
+        # @return [Journal, nil] the chained journal, or nil when the adapter keeps no seals
+        def self.of(aggregate, adapter)
+          return unless %i[ledger_anchors record_ledger_anchor entries].all? { |method| adapter.respond_to?(method) }
+
+          new(aggregate, adapter)
+        end
+
+        # @param aggregate [Bluebook::Aggregate] the aggregate the journal belongs to
+        # @param adapter [Object] a persistence adapter that keeps seals
+        def initialize(aggregate, adapter)
+          @name = aggregate.storage_name
+          @aggregate = aggregate
+          @adapter = adapter
+        end
+
+        # @return [Boolean] whether any seal is kept beside the journal
+        def sealed? = !@adapter.ledger_anchors.empty?
+
+        # Seals the journal at its end, unless nothing was appended since its last seal.
+        #
+        # @return [Hash, nil] `name:`, `through:`, `head:` and `previous:` of the seal the journal
+        #   now stands at; nil when it was never sealed and holds nothing
+        def seal
+          last = @adapter.ledger_anchors.last
+          base = last || START
+          fresh = unsealed(base)
+          return last && { name: @name }.merge(last) if fresh.empty?
+
+          record(base, fresh)
+        end
+
+        # Compares each seal with the journal and with the seal before it.
+        #
+        # @return [Hash] `seals:` how many seals are held, `entries:` how many were re-walked
+        # @raise [Runtime::WiringError] on the first seal that does not follow the one before it,
+        #   or whose head the journal does not reproduce
+        def verify
+          held = @adapter.ledger_anchors
+          before = START
+          walked = held.sum do |anchor|
+            refuse(anchor, "does not follow the seal before it") unless anchor[:previous] == before[:head]
+            count = rewalk(anchor, before)
+            before = anchor
+            count
+          end
+          { seals: held.size, entries: walked }
+        end
+
+        private
+
+        def record(base, fresh)
+          through = fresh.last.sequence || (base[:through] + fresh.size)
+          head = Chain.fold(base[:head], @aggregate, fresh)
+          @adapter.record_ledger_anchor(through: through, head: head, previous: base[:head])
+          { name: @name, through: through, head: head, previous: base[:head] }
+        end
+
+        # The entries appended since a seal, in order.
+        def unsealed(base)
+          return @adapter.entries unless @adapter.respond_to?(:entries_since)
+
+          @adapter.entries_since(base[:through]).select { |entry| entry.sequence <= @adapter.checkpoint }
+        end
+
+        # Recomputes one seal's head from the journal, when its entries are still held.
+        def rewalk(anchor, before)
+          return 0 unless @adapter.respond_to?(:entries_since) && @adapter.respond_to?(:compacted_through)
+          return 0 if @adapter.compacted_through >= anchor[:through]
+
+          held = @adapter.entries_since(before[:through]).select { |entry| entry.sequence <= anchor[:through] }
+          refuse(anchor, "no longer matches the journal") unless Chain.fold(anchor[:previous], @aggregate, held) == anchor[:head]
+          held.size
+        end
+
+        def refuse(anchor, reason)
+          raise Runtime::WiringError, "#{@name}: the seal through #{anchor[:through]} #{reason}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/ledger.adapter

@@ -0,0 +1,7 @@
+# Required by name, not relative to this file: a fuzz or model check boots a copy of this directory,
+# and the implementation must load once, from `lib/`, not from the copy.
+require "hecks/hecks/adapters/ledger"
+
+Hecks.adapter "Ledger" do
+  port "Ledger"
+end

data/lib/hecks/hecks/adapters/ledger.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "hecks"
+require_relative "ledger/chain"
+require_relative "ledger/journal"
+
+module Hecks
+  module Adapters
+    # The `Ledger` port's adapter: seals the hash chain of a domain's append-only journals before
+    # compaction removes rows from them, and walks the chain again to show the journals were not
+    # rewritten.
+    #
+    # Each journal keeps its seals beside it (`ledger_anchors`, `record_ledger_anchor`), so a
+    # sealed head can be compared with the journal it protects and a compaction cannot take the
+    # evidence of what it removed along with it. A journal an adapter does not chain (Memory, the
+    # era journal, which the database already protects) is left out.
+    #
+    # Arguments arrive materialized, so a value object is `{ value: x }`.
+    class Ledger
+      # Accepts the arguments every driven adapter is built with and keeps none of them.
+      #
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] unused
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil); end
+
+      # Seals every chained journal of a domain at its present end.
+      #
+      # @param held [Hash] the `Era` record of a compaction: `domain`
+      # @return [Hash{Symbol => Hash}] `domain:` as asked, `through:` the entries sealed in all,
+      #   `head:` one digest for the journals' sealed heads and `previous:` the same for the seals
+      #   before them
+      # @raise [Runtime::NotFound] if the domain directory does not exist
+      # @raise [Runtime::WiringError] if the domain has no chained journal with entries
+      def capture(**held)
+        domain = plain(held[:domain])
+        points = journals(domain).filter_map(&:seal)
+        raise Runtime::WiringError, "no journal entries to seal" if points.empty?
+
+        {
+          domain:   { value: domain },
+          through:  { value: points.sum { |point| point[:through] } },
+          head:     { value: Chain.summary(points, :head) },
+          previous: { value: Chain.summary(points, :previous) }
+        }
+      end
+
+      # Walks every chained journal from its first seal and compares each seal with the journal.
+      #
+      # @param held [Hash] the `Audit` record: `domain`
+      # @return [Hash{Symbol => Hash}] `checked:` the seals and entries compared, `report:` what
+      #   was found
+      # @raise [Runtime::NotFound] if the domain directory does not exist
+      # @raise [Runtime::WiringError] if nothing is sealed, or a seal does not match its journal
+      def walk(**held)
+        sealed = journals(plain(held[:domain])).select(&:sealed?)
+        raise Runtime::WiringError, "nothing is sealed yet: the chain cannot be shown intact" if sealed.empty?
+
+        counts = sealed.map(&:verify)
+        report(sealed.size, counts.sum { |count| count[:seals] }, counts.sum { |count| count[:entries] })
+      end
+
+      private
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+
+      def report(journals, seals, entries)
+        text = "#{journals} journal#{"s" unless journals == 1}: #{seals} seals held, #{entries} entries re-walked"
+        { checked: { value: seals + entries }, report: { value: text } }
+      end
+
+      def journals(path)
+        raise Runtime::NotFound, "no such domain #{path.inspect}" unless Dir.exist?(path.to_s)
+
+        registry = Hecks.boot(File.expand_path(path), install_driving: false).registry
+        registry.bluebooks.flat_map do |domain_name, bluebook|
+          bluebook.aggregates.filter_map { |aggregate| journal(registry, domain_name, aggregate) }
+        end
+      end
+
+      def journal(registry, domain_name, aggregate)
+        repository = registry.repository(domain_name, aggregate)
+        return unless repository.is_a?(Ports::Persistence::AppendOnly)
+
+        Journal.of(aggregate, repository.adapter)
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/local_files.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require_relative "console_capture"
+require_relative "rails_app_files"
 require "hecks/cli/project_cli"
 require "hecks/cli/domain_stub"
 
@@ -28,7 +29,7 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` one line per launcher written
       # @raise [ConsoleCapture::Failure] when no launcher was written
       def write(**held)
-        domains = plain(held[:domains]).to_s.split(",").map(&:strip).reject(&:empty?)
+        domains = Text.comma_list(plain(held[:domains]))
         text = ConsoleCapture.answer do
           CLI::ProjectCli.call(domains, program: "hecks project_cli", root: Dir.pwd, remove_stale_bin: false)
         end
@@ -60,6 +61,19 @@ module Hecks
         { output: { value: report } }
       end
 
+      # Writes the controllers and routes a Rails app drives its domain through,
+      # leaving every file the app already has alone.
+      #
+      # @param held [Hash] the `Launch` record: optionally `dir`, the app's directory (the current
+      #   one when absent)
+      # @return [Hash{Symbol => Hash}] `output:` one line per file, written or kept
+      # @raise [ConsoleCapture::Failure] when the app has no `bluebook/` or it declares no bluebook
+      def write_rails(**held)
+        report = RailsAppFiles.new(File.expand_path(plain(held[:dir]) || ".", Dir.pwd)).call
+        puts report
+        { output: { value: report } }
+      end
+
       private
 
       # The directory the stub is written into: the named one, or the snake-cased name under the

data/lib/hecks/hecks/adapters/pg_admin.rb

@@ -131,12 +131,18 @@ module Hecks
       def configured_databases
         named = CONFIGURED_DATABASES.filter_map { |variable| ENV.fetch(variable, nil) }
         url = ENV.fetch("DATABASE_URL", nil)
-        named << URI.parse(url).path.to_s.delete_prefix("/") if url && !url.empty?
+        named << database_name(url) if url && !url.empty?
         named.reject(&:empty?)
       rescue URI::InvalidURIError
         named
       end
 
+      # The database a `postgres://` URL names: its path, without the leading slash.
+      def database_name(url)
+        path = URI.parse(url).path
+        path.to_s.delete_prefix("/")
+      end
+
       def named(held)
         database = plain(held[:database])
         raise ConsoleCapture::Failure, "no database named" if database.to_s.empty?

data/lib/hecks/hecks/adapters/rails_app_files.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "console_capture"
+
+module Hecks
+  module Adapters
+    # Writes the `:rails_app` projection of a Rails app's domain into the app, for the
+    # `Workspace` port's `ProjectRails` question.
+    #
+    # The domain is read from the app's `bluebook/` without binding an adapter or opening a store.
+    # Each of the app's own bluebooks gives its controllers; a bluebook a hecksagon only attaches
+    # (Governance, Identity) gives none. A file already in the app is the app's own, so it is
+    # reported and left alone.
+    class RailsAppFiles
+      # @param root [String] the Rails app's directory, holding `bluebook/`
+      def initialize(root)
+        @root = root
+      end
+
+      # Writes every file the app does not have yet and reports each one.
+      #
+      # @return [String] one line per file: `wrote <path>` or `kept <path>`
+      # @raise [ConsoleCapture::Failure] when the app has no `bluebook/` or it declares no bluebook
+      def call
+        files = projected_files
+        raise ConsoleCapture::Failure, "no bluebook declared under #{bluebook_dir}" if files.empty?
+
+        files.sort.map { |path, text| write(path, text) }.join("\n")
+      end
+
+      private
+
+      def bluebook_dir = File.join(@root, "bluebook")
+
+      def projected_files
+        raise ConsoleCapture::Failure, "no bluebook/ in #{@root}" unless File.directory?(bluebook_dir)
+
+        declarations = own_bluebooks
+        declarations.each_with_object({}) do |declaration, files|
+          files.merge!(Projector.call(:rails_app, bluebook: declaration, options: { route_bluebooks: declarations }))
+        end
+      end
+
+      # The app's bluebooks: every bluebook the boot loaded except a framework member or another
+      # bluebook a hecksagon only attaches.
+      def own_bluebooks
+        registry = Hecks.describe(bluebook_dir, environment: nil).registry
+        registry.bluebooks.values.reject do |declaration|
+          registry.bounded?(declaration.name) || Hecks::Framework.members.key?(declaration.name)
+        end
+      end
+
+      def write(path, text)
+        full = File.join(@root, path)
+        return "kept #{path}" if File.exist?(full)
+
+        FileUtils.mkdir_p(File.dirname(full))
+        File.write(full, text)
+        "wrote #{path}"
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/rehearsal/audit_report.rb

@@ -10,6 +10,9 @@ module Hecks
         # The limit a clean verdict carries when no stored row was read.
         UNAUDITED = "the stored rows"
 
+        # The record a refusal names: everything before its first colon.
+        REFUSED_RECORD = /\A[^:]+/
+
         # The wording that explains a Rust-only refusal: the Ruby audit's first layer does not hold
         # a stored value to a closed set, a required field or an undeclared value-object key.
         RUST_ONLY = "The Rust audit also holds a stored value to its closed set, a required field and an " \
@@ -82,7 +85,7 @@ module Hecks
 
         def rust_records = records(@rust.violations)
 
-        def records(refusals) = refusals.map { |text| text[/\A[^:]+/] }.uniq.sort
+        def records(refusals) = refusals.map { |text| text[REFUSED_RECORD] }.uniq.sort
 
         def agreed = "ruby refused #{ruby_records.size} records, rust #{rust_records.size}; rust read #{@rust.rows} rows"
 

data/lib/hecks/hecks/adapters/rehearsal/inquiry.rb

@@ -35,7 +35,7 @@ module Hecks
         # @return [Hash] `booted`, `host_version`, `store`, `mode`, `before`, `after`, `minting`,
         #   the schema and environment that were read, and what the copy holds
         def survey
-          shape.merge(environment_loaded: @subject.environment.facts, copy_note: plain(copy_note)).merge(copy_facts)
+          shape.merge(environment_loaded: @subject.environment_facts, copy_note: plain(copy_note)).merge(copy_facts)
         end
 
         # @return [Hash] the edge facts, every refused row and its total, what was read, the parity
@@ -53,8 +53,8 @@ module Hecks
         def plain(value) = { value: value }
 
         def shape
-          { booted: flag(true), host_version: plain(Rehearsal.host_version), store: plain(@subject.declaration.kind),
-            mode: plain(@subject.declaration.mode), before: plain(before), after: plain(@subject.label),
+          { booted: flag(true), host_version: plain(Rehearsal.host_version), store: plain(@subject.store_kind),
+            mode: plain(@subject.copy_mode), before: plain(before), after: plain(@subject.label),
             minting: plain(minting) }
         end
 
@@ -69,12 +69,12 @@ module Hecks
         def census = @census ||= @store.census(@subject)
 
         def copy_note
-          domain = @subject.bluebook.name
+          domain = @subject.bluebook_name
           copy_empty? ? census.refusal(domain) : census.summary(domain)
         end
 
         def copy_empty?
-          census.empty? && @subject.declaration.mode != "empty" && @subject.bluebook.aggregates.any?
+          census.empty? && @subject.copy_mode != "empty" && @subject.aggregates.any?
         end
 
         # The copy is empty when a dump or a readonly copy was asked for and it holds no row of a
@@ -115,18 +115,18 @@ module Hecks
           census.head_rows == census.journal_rows ? "." : ": they differ, and only the journal's are audited."
         end
 
-        # The chapters loaded beside the domain's own (a vendored package): the host holds eras
+        # The bluebooks loaded beside the domain's own (a vendored package): the host holds eras
         # for the domain's own aggregates only, so theirs can neither mint nor be refused.
         def attached_limits
-          names = @subject.held.registry.bluebooks.values.map(&:name) - [@subject.bluebook.name]
+          names = @subject.bluebook_names - [@subject.bluebook_name]
           return [] if names.empty?
 
-          [{ what: "the shape of the attached chapters (#{names.sort.join(", ")})",
+          [{ what: "the shape of the attached bluebooks (#{names.sort.join(", ")})",
              why:  "their aggregates have no era row of their own, so a change to them is not a mint" }]
         end
 
         def binding_note
-          { what: "that a boot would mint", why: "the domain is bound to #{@subject.held.adapter_name}, which holds no eras " \
+          { what: "that a boot would mint", why: "the domain is bound to #{@subject.adapter_name}, which holds no eras " \
                                                  "in this environment" }
         end
       end

data/lib/hecks/hecks/adapters/rehearsal/memory_store.rb

@@ -38,7 +38,7 @@ module Hecks
         # @param subject [Subject] the loaded domain
         # @return [Census] the counts
         def census(subject)
-          counts = subject.bluebook.aggregates.map do |aggregate|
+          counts = subject.aggregates.map do |aggregate|
             held = records(aggregate.name).size
             Census::Count.new(aggregate: aggregate.name, head: held, journal: held)
           end
@@ -54,7 +54,7 @@ module Hecks
         #   by aggregate name and id
         def audit(subject, edge)
           refusals = []
-          after = subject.bluebook.aggregates.to_h do |aggregate|
+          after = subject.aggregates.to_h do |aggregate|
             declared = edge.for_aggregate(aggregate.name)
             before = records(declared&.was || aggregate.name)
             translated = translate(aggregate, declared, before)