hecks 5.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/in_process_undo.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    # The answer to `Introspection.Undo`, mixed into the in-process boot adapter: the command
+    # that undoes a declared command, from the bluebook's compensations (`Projections::Undo`).
+    module InProcessUndo
+      # @param domain [Hash, String] a domain directory
+      # @param bluebook [Hash, String] the bluebook's name
+      # @param command [Hash, String] the command's verb form, e.g. "Account.Debit"
+      # @return [Hash] `text:` the command that undoes it, or that none is declared
+      def undo(domain:, bluebook:, command:)
+        report(Projector.call(:undo, bluebook: bluebook_of(domain, bluebook), options: { command: plain(command) }).join("\n"))
+      end
+    end
+  end
+end

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

@@ -42,11 +42,20 @@ module Hecks
         def apply_hold_first(held)
           domain = HeldDomain.open(plain(held[:domain]), mode: :bare)
           domain.writing do |lineage|
-            raise Runtime::WiringError, "#{domain.bluebook.name} already holds an era" unless lineage.eras.empty?
+            lineage.hold_first_era!(domain.source_text, projection: domain.shape, aggregates: domain.aggregates,
+                                                         role: domain.app_role)
+          end
+          "#{domain.domain_name} holds era 1 now."
+        end
 
-            lineage.hold_first!(domain.source_text, projection: domain.shape)
+        # Moves the history held under the former name to the current one, in one transaction. A
+        # failure rolls it back whole, so the old name still holds everything.
+        def apply_rename_domain(held)
+          domain = HeldDomain.open(plain(held[:domain]), mode: :bare)
+          moved = domain.renaming do |lineage|
+            lineage.rename_domain!(storage_names: domain.aggregates.map(&:storage_name), cache_fields: domain.cache_fields)
           end
-          "#{domain.bluebook.name} holds era 1 now."
+          "#{domain.domain_name} holds the #{moved} era#{"s" unless moved == 1} of #{domain.former_name} now."
         end
 
         def apply_merge_tail(held)
@@ -55,7 +64,7 @@ module Hecks
           diverged = domain.writing { |lineage| diverged_writes(domain, lineage) }
           PostgresEra::LineageManager.merge!(registry: domain.registry, bluebook: domain.bluebook,
                                              settings: domain.settings, winners: named)
-          ["#{domain.bluebook.name}: #{diverged} post-cut write#{"s" unless diverged == 1} in ancestor " \
+          ["#{domain.domain_name}: #{diverged} post-cut write#{"s" unless diverged == 1} in ancestor " \
            "eras before the merge",
            "merged — the head now interleaves both worlds by their recorded ordinals",
            *named.map { |id, side| "  winner #{id}=#{side} appended as the newest row" }].join("\n")
@@ -73,7 +82,7 @@ module Hecks
         end
 
         def reattest(domain, lineage, ordinal)
-          lineage.raw_era(ordinal) or raise Runtime::NotFound, "#{domain.bluebook.name} holds no era #{ordinal}"
+          lineage.raw_era(ordinal) or raise Runtime::NotFound, "#{domain.domain_name} holds no era #{ordinal}"
           fresh = lineage.reattest!(ordinal)
           "ATTESTED: era #{ordinal} re-frozen as #{fresh[0, 12]}… — the old and new digests are recorded."
         end
@@ -86,11 +95,11 @@ module Hecks
         def backfill(domain, lineage)
           missing = -> { missing_projections(lineage) }
           before = missing.call
-          return "#{domain.bluebook.name}: every held era already carries a projection — nothing to do." if before.zero?
+          return "#{domain.domain_name}: every held era already carries a projection — nothing to do." if before.zero?
 
           require_legacy_rows!(domain, lineage)
           done = before - missing.call
-          "#{domain.bluebook.name}: backfilled #{done} era#{"s" unless done == 1} — every row now carries a projection."
+          "#{domain.domain_name}: backfilled #{done} era#{"s" unless done == 1} — every row now carries a projection."
         end
 
         # Raises on the first row whose own digest check fails: a tampered row, not a merely
@@ -98,9 +107,9 @@ module Hecks
         def require_legacy_rows!(domain, lineage)
           lineage.eras
         rescue Runtime::WiringError => e
-          raise Runtime::WiringError, "#{domain.bluebook.name}: stopped at a row that isn't merely legacy — " \
+          raise Runtime::WiringError, "#{domain.domain_name}: stopped at a row that isn't merely legacy — " \
                                       "it fails its own integrity check: #{e.message} — resolve that first " \
-                                      "(`hecks reattest`), then run this again for the remaining rows."
+                                      "(`hecks era.reattest!`), then run this again for the remaining rows."
         end
 
         def missing_projections(lineage)

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

@@ -12,7 +12,14 @@ module Hecks
       # the snapshot keeping the current state. The database-level guard, that the
       # `compacted_through` floor only moves forward, stays in the adapter that owns the journal.
       class Compaction
-        Candidate = Struct.new(:domain_name, :aggregate, :adapter, keyword_init: true)
+        # One aggregate whose journal can be compacted, with the adapter that holds it.
+        Candidate = Struct.new(:domain_name, :aggregate, :adapter, keyword_init: true) do
+          # @return [String] the aggregate's storage name, as the journal is named
+          def storage_name = aggregate.storage_name
+        end
+
+        # A preview line that refuses its candidate.
+        REFUSAL_LINE = /^REFUSED/
 
         KINDS = { entries: %i[compact_entries! checkpoint], heki: %i[compact!] }.freeze
 
@@ -57,7 +64,7 @@ module Hecks
         # @raise [Runtime::WiringError] if a projection reads a journal that would be emptied, or
         #   the journal's own floor refuses the compaction
         def apply!
-          raise Runtime::WiringError, preview.grep(/^REFUSED/).join("\n") if bound.any?
+          raise Runtime::WiringError, preview.grep(REFUSAL_LINE).join("\n") if bound.any?
 
           candidates.map { |candidate| kind_apply(candidate) }
         end
@@ -85,12 +92,12 @@ module Hecks
         end
 
         def refusal_line(candidate)
-          "REFUSED #{candidate.aggregate.storage_name}: a projected_by binding reads its full journal — " \
+          "REFUSED #{candidate.storage_name}: a projected_by binding reads its full journal — " \
             "compacting would break its catch-up. Not compacted."
         end
 
         def entries_dry(candidate)
-          name = candidate.aggregate.storage_name
+          name = candidate.storage_name
           adapter = candidate.adapter
           through = adapter.checkpoint
           if through <= adapter.compacted_through
@@ -102,7 +109,7 @@ module Hecks
         end
 
         def compact_entries(candidate)
-          name = candidate.aggregate.storage_name
+          name = candidate.storage_name
           adapter = candidate.adapter
           through = adapter.checkpoint
           if through <= adapter.compacted_through
@@ -115,7 +122,7 @@ module Hecks
         end
 
         def heki_dry(candidate)
-          name = candidate.aggregate.storage_name
+          name = candidate.storage_name
           adapter = candidate.adapter
           return "SKIP #{name}: journal already empty" if adapter.entries.empty?
 
@@ -124,7 +131,7 @@ module Hecks
         end
 
         def compact_heki(candidate)
-          name = candidate.aggregate.storage_name
+          name = candidate.storage_name
           adapter = candidate.adapter
           entries = adapter.entries.length
           return "SKIP #{name}: journal already empty" if entries.zero?

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

@@ -2,6 +2,7 @@
 
 require "json"
 require_relative "held_domain"
+require_relative "../../../adapters/driven/postgres_era/lineage_manager/mint_decision"
 
 module Hecks
   module Adapters
@@ -22,27 +23,33 @@ module Hecks
         # @param held [HeldDomain] the loaded domain, translation edges included
         # @param lineage [Lineage] the domain's lineage
         # @param eras [Array<Hash>] the eras the lineage holds, at least one
+        # @param edge [Object, nil] the edge the shared decision named for the pending shape, when
+        #   the caller decided it already; nil makes the audit decide it
         # @return [Finding, nil] the finding; nil when the domain stands at era 1, with no edge
-        # @raise [Runtime::NotFound] if no edge leads the latest era to the current shape, or a
+        # @raise [Runtime::NotFound] if the shared decision names no edge to the current shape, or a
         #   preview query is refused by Postgres
-        def self.call(held, lineage, eras)
-          new(held, lineage, eras).call
+        def self.call(held, lineage, eras, edge: nil)
+          new(held, lineage, eras, edge: edge).call
         end
 
         # @param held [HeldDomain] the loaded domain
         # @param lineage [Lineage] the domain's lineage
         # @param eras [Array<Hash>] the held eras
-        def initialize(held, lineage, eras)
+        # @param edge [Object, nil] see `EdgeAudit.call`
+        def initialize(held, lineage, eras, edge: nil)
           @held = held
+          @bluebook = held.bluebook
+          @registry = held.registry
           @lineage = lineage
           @eras = eras
+          @edge = edge
           @manager = PostgresEra::LineageManager
         end
 
         # @return [Finding, nil] see `EdgeAudit.call`
         def call
           latest = @held.named(@eras.last)
-          if @held.shape == Runtime::StorageShape.project(@manager.shadow(latest[:held_text]))
+          if @held.shape == @manager.held_shape(latest)
             return nil if latest[:ordinal] == 1
 
             settled(latest)
@@ -55,34 +62,41 @@ module Hecks
 
         # The shape already minted: the edge that arrives at the latest era.
         def settled(latest)
-          chain = @manager.edge_chain(@held.registry, @held.bluebook, @eras[0..-2], latest[:label])
+          chain = @manager.edge_chain(@registry, @bluebook, @eras[0..-2], latest[:label], target: latest)
           finding(chain, latest[:ordinal], 1)
         end
 
         # The shape not yet minted: the edge that leaves the latest era for the current shape.
         def pending(latest)
-          label = Runtime::StorageShape.mint_hash(@held.bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
+          label = Runtime::StorageShape.mint_hash(@bluebook)[0, Runtime::StorageShape::LABEL_LENGTH]
           leaving = leaving_edges(latest)
-          edge = edge_to(leaving, latest, label)
-          chain = @manager.edge_chain(@held.registry, @held.bluebook, @eras[0..-2] + [latest], label)
+          edge = @edge || decided_edge(latest, label)
+          chain = @manager.edge_chain(@registry, @bluebook, @eras[0..-2] + [latest], label,
+                                      target: edge.is_a?(Translation::ImplicitEdge) ? edge.record : nil)
           finding(chain, latest[:ordinal] + 1, leaving.size, edge)
         end
 
-        # The leaving edge that arrives at the current shape.
-        def edge_to(leaving, latest, label)
-          leaving.find { |t| t.to == label } or
-            raise Runtime::NotFound, "no translation edge leads #{latest[:label]} to #{label} — " \
-                                     "run `hecks scaffold_translation` first"
+        # The edge the shared decision leads the latest era by. A decision that does not mint names
+        # the refusal, so the audit raises rather than audit an edge a mint would not take.
+        def decided_edge(latest, label)
+          verdict = PostgresEra::LineageManager::MintDecision.decide_latest(
+            latest, bluebook: @bluebook, translations: @registry.translations, directory: @held.directory,
+            watermark: @lineage.last_ordinal
+          )
+          return verdict.edge if verdict.verdict == "would_mint"
+
+          raise Runtime::NotFound, "no translation edge leads #{latest[:label]} to #{label} " \
+                                   "(the decision is #{verdict.verdict}) — run `hecks query era.scaffold_translation` first"
         end
 
         # The registered translations that leave the latest era.
         def leaving_edges(latest)
-          domain = @held.bluebook.name
-          @held.registry.translations.select { |t| t.domain == domain && t.from == latest[:label] }
+          domain = @bluebook.name
+          @registry.translations.select { |t| t.domain == domain && t.from == latest[:label] }
         end
 
         def finding(chain, era, leaving, edge = chain.last[:translation])
-          audits = @held.bluebook.aggregates.map { |aggregate| [aggregate, *verdict_for(aggregate, edge, era, chain)] }
+          audits = @bluebook.aggregates.map { |aggregate| [aggregate, *verdict_for(aggregate, edge, era, chain)] }
           lines = audits.flat_map { |aggregate, verdict, records, _| describe(aggregate, edge, verdict, records) }
           refusals = audits.flat_map { |_, verdict, _, _| verdict.violations }
           Finding.new(edge: edge, leaving: leaving, ok: refusals.empty?, report: lines.join("\n"),
@@ -91,8 +105,9 @@ module Hecks
 
         def verdict_for(aggregate, edge, era, chain)
           after = translated(aggregate, era, chain)
-          before = if chain.size > 1
-                     translated(aggregate, era, chain[0..-2])
+          before = @lineage.split_latest(aggregate, chain) ||
+                   if chain.size > 1
+                     @lineage.received_latest(aggregate, era, chain)
                    else
                      @lineage.ancestor_latest(aggregate, era, chain)
                    end
@@ -113,7 +128,7 @@ module Hecks
         end
 
         def heading_line(aggregate, edge, records)
-          "── #{@held.bluebook.name}::#{aggregate.name} (edge #{edge.from} → #{edge.to}, " \
+          "── #{@bluebook.name}::#{aggregate.name} (edge #{edge.from} → #{edge.to}, " \
             "#{records} record#{"s" unless records == 1})"
         end
 

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

@@ -41,6 +41,21 @@ module Hecks
           { capable: true, held: domain.reading { |lineage| domain.held_eras(lineage).size } }
         end
 
+        # The facts of a rename: `held` is the eras under the former name that would move, and 0
+        # unless the domain declares a former name, the current name holds none, and the former
+        # name holds some.
+        def examine_rename_domain(held)
+          domain = HeldDomain.open(plain(held[:domain]), mode: :bare)
+          return {} unless domain.capable?
+
+          { capable: true, held: domain.renaming { |lineage| lineage.rename_pending? ? former_eras(lineage) : 0 } }
+        end
+
+        def former_eras(lineage)
+          lineage.db.exec_params("SELECT count(*)::int AS n FROM hecks_eras WHERE domain = $1",
+                                 [lineage.formerly_known_as])[0]["n"].to_i
+        end
+
         def examine_merge_tail(held)
           domain = HeldDomain.open(plain(held[:domain]))
           return {} unless domain.capable?
@@ -92,8 +107,8 @@ module Hecks
         # How many eras, before the latest, do not have exactly one edge leading to the next.
         def forks_in(domain, eras)
           eras.each_cons(2).count do |from, to|
-            leaving = domain.registry.translations.select do |edge|
-              edge.domain == domain.bluebook.name && edge.from == from[:label]
+            leaving = domain.translations.select do |edge|
+              edge.domain == domain.domain_name && edge.from == from[:label]
             end
             leaving.size != 1 || leaving.first.to != to[:label]
           end
@@ -102,8 +117,9 @@ module Hecks
         # Records both worlds wrote since the cut that no winner was named for.
         def unresolved_conflicts(domain, lineage, eras, named)
           latest = eras.last
-          chain = PostgresEra::LineageManager.edge_chain(domain.registry, domain.bluebook, eras[0..-2], latest[:label])
-          conflicts = domain.bluebook.aggregates.flat_map do |aggregate|
+          chain = PostgresEra::LineageManager.edge_chain(domain.registry, domain.bluebook, eras[0..-2],
+                                                         latest[:label], target: latest)
+          conflicts = domain.aggregates.flat_map do |aggregate|
             lineage.conflict_ids(aggregate, chain, latest[:ordinal], latest[:watermark].to_i)
           end
           conflicts.count { |_, id| !named.key?(id) }

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class JournalStore
+      class HeldDomain
+        # How a held domain reaches the journal store to rename it: with its former name known,
+        # and nothing provisioned.
+        module Renaming
+          # Connects to the journal store and yields a lineage that knows the domain's former name,
+          # with nothing provisioned: the rename moves what is there and builds nothing, and a
+          # database that holds no eras is left as it is. A role that bypasses the write fence is
+          # refused unless the world allows it.
+          #
+          # @yield [Lineage] the domain's lineage, with `formerly_known_as` set
+          # @return [Object] the block's value
+          # @raise [Runtime::WiringError] on a superuser connection the world has not allowed
+          def renaming
+            db = PostgresEra.connect_for(bluebook.name, settings, provision: false)
+            lineage = PostgresEra::Lineage.new(db, bluebook.name, formerly_known_as: bluebook.formerly_known_as)
+            lineage.check_fence_applies!(allow_superuser: PostgresEra.setting(settings, :allow_superuser, default: false))
+            yield lineage
+          ensure
+            db&.close
+          end
+
+          # The where-fields each aggregate's queries narrow by, whose cache tables hash the
+          # domain's name and so are renamed with it. A superset of the fields actually cached:
+          # a table that does not exist is skipped.
+          #
+          # @return [Hash{String => Array<String>}] storage name to field names
+          def cache_fields
+            aggregates.to_h do |aggregate|
+              queries = aggregate.queries + aggregate.entities.flat_map(&:queries)
+              [aggregate.storage_name, queries.flat_map { |query| query.wheres.map { |clause| clause.field.to_s } }.uniq]
+            end
+          end
+
+          # @return [String, nil] the name the domain was known by before its rename
+          def former_name = bluebook.formerly_known_as
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@
 
 require "hecks"
 require "hecks/ports/persistence/plugins/era"
+require "hecks/indifferent_key"
+require_relative "held_domain/renaming"
 
 module Hecks
   module Adapters
@@ -14,10 +16,24 @@ module Hecks
       # text from being attested; `scaffold` loads everything but the edges, since an unresolved
       # edge file refuses to load and writing it is the point.
       class HeldDomain
+        include Renaming
+
         MODES = %i[translated bare scaffold].freeze
 
         attr_reader :registry, :bluebook, :directory, :adapter_name
 
+        # @return [String] the held domain's name
+        def domain_name = bluebook.name
+
+        # @return [Array<String>] the names of every bluebook the registry loaded
+        def bluebook_names = registry.bluebooks.keys
+
+        # @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 +64,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,19 +75,26 @@ 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
         # @param directory [String] the domain's bluebook directory
+        # @param name [String, nil] the bluebook to hold, by name; the registry's first when absent
         # @raise [Runtime::NotFound] if the registry holds no bluebook, or a bluebook no aggregate
-        def initialize(registry, directory)
+        def initialize(registry, directory, name = nil)
           @registry = registry
           @directory = directory
-          @bluebook = registry.bluebooks.values.first or raise Runtime::NotFound, "no bluebook in #{directory}"
+          @bluebook = name ? registry.bluebooks[name] : registry.first_bluebook
+
+          raise Runtime::NotFound, "no bluebook in #{directory}" unless @bluebook
+
           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
@@ -97,6 +120,11 @@ module Hecks
           @database ? declared.merge(database: @database) : declared
         end
 
+        # The app role the world names, which provisioning grants what the app needs to write.
+        #
+        # @return [String, nil] the role, or nil when the world names none
+        def app_role = IndifferentKey.read(settings, :role)
+
         # Names the schema its journal store is read in, over the world's and `HECKS_SCHEMA`, so a
         # rehearsal reads the schema it reports.
         #
@@ -134,7 +162,7 @@ module Hecks
         def named(era)
           return era if era[:hash]
 
-          hash = Runtime::StorageShape.mint_hash(PostgresEra::LineageManager.shadow(era[:held_text]))
+          hash = PostgresEra::LineageManager.held_hash(era)
           era.merge(hash: hash, label: hash[0, Runtime::StorageShape::LABEL_LENGTH])
         end
 
@@ -149,8 +177,8 @@ module Hecks
         # @yield [Lineage] the domain's lineage
         # @return [Object] the block's value
         def reading
-          db = PostgresEra.connect_for(bluebook.name, settings)
-          yield PostgresEra::Lineage.new(db, bluebook.name)
+          db = PostgresEra.connect_for(bluebook.name, settings, provision: false)
+          yield PostgresEra::Lineage.new(db, bluebook.name, reading: true)
         ensure
           db&.close
         end
@@ -171,6 +199,16 @@ module Hecks
           db&.close
         end
 
+        # What a boot of the held bluebook would resolve, read from its database over a connection
+        # that only reads: the resolution the boot records (`LineageManager::EraResolution`).
+        #
+        # @return [PostgresEra::LineageManager::EraResolution::Answer]
+        # @raise [Runtime::WiringError] if the connection is refused or a held text was altered
+        def resolution
+          PostgresEra::LineageManager::EraResolution.read(bluebook: bluebook, settings: settings,
+                                                          translations: translations, directory: directory)
+        end
+
         # The eras a lineage holds, without provisioning anything: none when the lineage tables do
         # not exist yet.
         #

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "held_domain"
+require_relative "../../../quality_control/adapters/qa_era_mint"
+require_relative "../../../quality_control/adapters/qa_auto_mint"
+require_relative "../../../adapters/driven/postgres_era"
+
+module Hecks
+  module Adapters
+    class JournalStore
+      # The Hecks domain's held mint, answered on the `JournalStore` port's `Mint`.
+      #
+      # It reads the domain's facts through the shared mint decision (`QaAutoMint.facts`, which
+      # runs `MintDecision.decide_latest`), refuses by name whatever the decision does not allow,
+      # and mints through `QaEraMint`, the mint transaction the QualityControl ledger uses. The
+      # reader and the minter are injected so a spec runs with no database.
+      class HeldMint
+        # The Hecks domain's bluebook directory, the one a checkout boots.
+        DOMAIN = File.expand_path("../..", __dir__)
+
+        # The domain name the mint is recorded under.
+        NAME = "Hecks"
+
+        # Reads the facts a mint decides on from a bluebook directory.
+        #
+        # @param directory [String] the domain's bluebook directory
+        # @return [Hash] `eraless:` alone, the adapter's name, for a domain bound to a store that
+        #   holds no eras (Memory, the default); `disposable: true` alone for a world that
+        #   declares `disposable_ledger true`; else `held` (the count of held eras), and when any
+        #   are held, `next_era`, `status` (the boot's resolution,
+        #   `LineageManager::EraResolution`), `watermark`, `from`, `to` and `verdict` (see
+        #   `QaAutoMint.facts`)
+        def self.read(directory)
+          domain = HeldDomain.open(directory, mode: :translated)
+          return { eraless: domain.adapter_name } unless domain.capable?
+          return { disposable: true } if PostgresEra::LineageManager::DisposableLedger.declared?(domain.settings)
+
+          resolution = domain.resolution
+          return { held: 0 } if resolution.status == "unheld"
+
+          QaAutoMint.facts(directory).merge(held: resolution.held_count, next_era: resolution.latest[:ordinal] + 1,
+                                            status: resolution.status)
+        end
+
+        # Mints the era through the QualityControl mint transaction, against the Hecks domain.
+        #
+        # @return [Array(String, Boolean)] the minted label or the refusal, and whether it minted
+        def self.mint(era, request)
+          QaEraMint.call(DOMAIN, domain: NAME, era: era, request: request, ledger: DOMAIN)
+        end
+
+        # @param directory [String] the bluebook directory a mint is for
+        # @param reader [#call] reads the facts of a directory; `HeldMint.read` when not given
+        # @param minter [#call] mints (era, request); `HeldMint.mint` when not given
+        def initialize(directory: DOMAIN, reader: nil, minter: nil)
+          @directory = directory
+          @reader = reader || ->(dir) { HeldMint.read(dir) }
+          @minter = minter || ->(era, request) { HeldMint.mint(era, request) }
+        end
+
+        # Answers a `MintHeld` request: a minted era, a shape that did not move, a store that holds
+        # no eras or a disposable ledger (neither needs a mint), or a named refusal.
+        #
+        # @param run [String] the run the mint belongs to
+        # @param confirm [Boolean, nil] whether the mint was confirmed
+        # @param rehearsal_verdict [String, nil] the verdict the caller read, when it read one
+        # @param watermark [Integer, nil] the watermark the caller read, when it read one
+        # @return [Hash{Symbol => Hash}] `run`, `outcome` (`minted`, `no_change` or `disposable`)
+        #   (also `eraless`) and `label` (the adapter's name for `eraless`, empty for `disposable`)
+        # @raise [Runtime::WiringError] naming why the mint was refused
+        def answer(run:, confirm: nil, rehearsal_verdict: nil, watermark: nil)
+          refuse!("the mint needs --confirm") unless confirm == true
+          facts = @reader.call(@directory)
+          passed = no_mint_needed(run, facts)
+          return passed if passed
+
+          refuse!("the Hecks domain holds no era; hold its first era before a mint") if facts[:held].zero?
+          return unchanged(run, facts) if facts[:status] == "current"
+
+          refuse!("the current shape is held by an era a later one superseded; nothing to mint") if facts[:status] == "superseded"
+          decide!(facts, rehearsal_verdict, watermark)
+          minted(run, facts)
+        end
+
+        private
+
+        # Refuses a mint whose decision is not `would_mint`, a rehearsal that disagrees with the
+        # decision, or a watermark that moved since the rehearsal.
+        def decide!(facts, rehearsal_verdict, watermark)
+          verdict = facts[:verdict]
+          refuse!("the decision is #{verdict.verdict}, not would_mint: #{verdict.reason}") unless verdict.verdict == "would_mint"
+          refuse_rehearsal!(rehearsal_verdict)
+          stale = watermark && QaAutoMint.stale_watermark(watermark, facts[:watermark])
+          refuse!(stale) if stale
+        end
+
+        # Refuses a rehearsal that said anything but would_mint; a caller that read none passes nil.
+        def refuse_rehearsal!(rehearsal_verdict)
+          return if rehearsal_verdict.nil? || rehearsal_verdict == "would_mint"
+
+          refuse!("the rehearsal said #{rehearsal_verdict}, not would_mint")
+        end
+
+        # A store that holds no eras (Memory) has no shape to move, and a disposable ledger's boot
+        # brings its own; neither needs a mint.
+        def no_mint_needed(run, facts)
+          outcome = { eraless: "eraless", disposable: "disposable" }.find { |fact, _| facts[fact] }&.last
+          return unless outcome
+
+          { run: { value: run }, outcome: { value: outcome }, label: { value: facts[:eraless] || "" } }
+        end
+
+        def unchanged(run, facts)
+          { run: { value: run }, outcome: { value: "no_change" }, label: { value: facts[:to] } }
+        end
+
+        def minted(run, facts)
+          request = { confirm: true, verdict: "would_mint", watermark: facts[:watermark] }
+          label, ran = @minter.call(facts[:next_era], request)
+          refuse!(label) unless ran
+          { run: { value: run }, outcome: { value: "minted" }, label: { value: label } }
+        end
+
+        def refuse!(reason) = raise(Runtime::WiringError, reason)
+      end
+    end
+  end
+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 era.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