hecks 6.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/in_process_operations.rb

@@ -4,11 +4,11 @@ require "json"
 require "time"
 require_relative "console_capture"
 require_relative "in_process_operations/tailing"
-require "hecks/cli/run"
-require "hecks/cli/model_check"
-require "hecks/cli/smoke_test"
-require "hecks/cli/behaviors"
-require "hecks/cli/refresh_projections"
+require "hecks/tools/run"
+require "hecks/tools/model_check"
+require "hecks/tools/smoke_test"
+require "hecks/tools/behaviors"
+require "hecks/tools/refresh_projections"
 
 module Hecks
   module Adapters
@@ -16,7 +16,7 @@ module Hecks
     # the asks of `ModelCheckRun` and `Operation`, plus the `Follow` query.
     #
     # An ask is handed the whole record it was made on (its `held_state`), so each method reads the
-    # record's fields, runs the existing `Hecks::CLI::*` entry point captured, and answers the text
+    # record's fields, runs the existing `Hecks::Tools::*` entry point captured, and answers the text
     # it printed. An answer records a success; a raise records a refusal, so a check that finds
     # something, or a run that fails, is refused with the report as its reason.
     module InProcessOperations
@@ -43,7 +43,7 @@ module Hecks
         argv = check_argv(held)
 
         text = ConsoleCapture.answer do
-          CLI::ModelCheck.call(argv, program: "hecks model_check", root: checkout_root)
+          Tools::ModelCheck.call(argv, program: "hecks model_check", root: checkout_root)
         end
         { report: { value: text }, checked: { value: text.scan(REPORT_HEADER).size } }
       end
@@ -59,7 +59,7 @@ module Hecks
         script = plain(held[:script])
         argv += script ? [script] : [plain(held[:verb]), *words(held[:arguments])].compact
 
-        output(ConsoleCapture.answer_apart { CLI::Run.call(argv, program: "hecks run") })
+        output(ConsoleCapture.answer_apart { Tools::Run.call(argv, program: "hecks run") })
       end
 
       # Forces every read-model projection the domain declares to catch up.
@@ -68,7 +68,7 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` how many projections were refreshed
       # @raise [Runtime::NotFound] if the domain cannot be found
       def refresh(**held)
-        count = CLI::RefreshProjections.call(boot(held[:subject]))
+        count = Tools::RefreshProjections.call(boot(held[:subject]))
         output("refreshed #{count} projection(s)")
       end
 
@@ -105,7 +105,7 @@ module Hecks
       # @raise [ConsoleCapture::Failure] when any test failed, errored or did not parse
       def verify(**held)
         argv = [plain(held[:subject])].compact
-        output(ConsoleCapture.answer { CLI::Behaviors.call(argv, program: "hecks run_behaviors") })
+        output(ConsoleCapture.answer { Tools::Behaviors.call(argv, program: "hecks run_behaviors") })
       end
 
       # Boots a wired domain and dispatches one synthesized call per command and report.
@@ -118,11 +118,9 @@ module Hecks
         domain = plain(held[:subject]) || (checkout_root ? nil : Folder.new.domain_root)
         argv = [domain].compact
 
-        output(ConsoleCapture.answer { CLI::SmokeTest.call(argv, root: checkout_root || Dir.pwd) })
+        output(ConsoleCapture.answer { Tools::SmokeTest.call(argv, root: checkout_root || Dir.pwd) })
       end
 
-      # rubocop:disable Metrics/ParameterLists -- the keywords are the `Follow` query's declared arguments
-
       # A domain's event log past a cursor, answered once: what the stream yielded before it
       # ended. Pass the answered `cursor` back as `since` to keep tailing. `wait` bounds the stream
       # and it ends at the first entries, so a call returns as soon as there is something to say.
@@ -136,7 +134,6 @@ module Hecks
       # @return [Hash] the `Tail` row: `cursor:`, `events:` (payloads as JSON text) and `taken_at:`
       # @raise [Runtime::NotFound] if the domain cannot be found or keeps no event log
       def follow(domain:, aggregate: nil, since: nil, from_now: nil, wait: nil, interval: nil)
-        # rubocop:enable Metrics/ParameterLists
         registry = boot(domain).registry
         entries = []
         cursor = stream(domain: domain, aggregate: aggregate, since: since, from_now: from_now,
@@ -148,8 +145,6 @@ module Hecks
         { cursor: cursor, events: entries, taken_at: Time.at(Ports::Clock.now(registry)).utc.iso8601 }
       end
 
-      # rubocop:disable Metrics/ParameterLists -- the keywords are the caller-facing shape of a tail
-
       # Tails a domain's event log, handing each entry to the block as the log shows it, until
       # the block returns `:stop` (or `:batch`: after this check's entries), `limit` entries were
       # handed over, `timeout` seconds pass, or the reader goes away; unbounded, until interrupted.
@@ -164,7 +159,6 @@ module Hecks
       # @raise [Runtime::NotFound] if the domain cannot be found or keeps no event log
       def stream(domain:, aggregate: nil, since: nil, from_now: nil, limit: nil, timeout: nil, interval: nil,
                  registry: nil, &)
-        # rubocop:enable Metrics/ParameterLists
         repository = event_repository(domain, registry)
         tail = Tail.new(plain(since)&.to_i || (plain(from_now) ? repository.events.size : 0), 0, false)
         bounds = Bounds.new(plain(aggregate), plain(limit)&.to_i, deadline_for(timeout), plain(interval))

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,13 +42,22 @@ module Hecks
         def apply_hold_first(held)
           domain = HeldDomain.open(plain(held[:domain]), mode: :bare)
           domain.writing do |lineage|
-            raise Runtime::WiringError, "#{domain.domain_name} already holds an era" unless lineage.eras.empty?
-
-            lineage.hold_first!(domain.source_text, projection: domain.shape)
+            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
 
+        # 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.domain_name} holds the #{moved} era#{"s" unless moved == 1} of #{domain.former_name} now."
+        end
+
         def apply_merge_tail(held)
           domain = HeldDomain.open(plain(held[:domain]))
           named = winners(held)
@@ -100,7 +109,7 @@ module Hecks
         rescue Runtime::WiringError => e
           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/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,29 +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)
@@ -57,7 +62,7 @@ module Hecks
 
         # The shape already minted: the edge that arrives at the latest era.
         def settled(latest)
-          chain = @manager.edge_chain(@registry, @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
 
@@ -65,16 +70,23 @@ module Hecks
         def pending(latest)
           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(@registry, @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.
@@ -93,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

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?
@@ -102,7 +117,8 @@ 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])
+          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

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,6 +16,8 @@ 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
@@ -21,6 +25,9 @@ module Hecks
         # @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
 
@@ -79,11 +86,15 @@ module Hecks
 
         # @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.first_bluebook 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
@@ -109,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.
         #
@@ -146,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
 
@@ -161,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
@@ -183,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

@@ -30,7 +30,7 @@ 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.domain_name} era=#{ordinal} --confirm` accepts it."
+              "Read it, then `hecks era.reattest! #{held.domain_name} era=#{ordinal} --confirm` accepts it."
             ].join("\n")
           end
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "json"
+require "hecks/ports/persistence/plugins/era"
+require_relative "../../../../shape_ledger"
+
+module Hecks
+  module Adapters
+    class JournalStore
+      module Readings
+        # What a boot of each bluebook under a domain directory would resolve, answered by
+        # `Runtime::EraStatus`, the resolution the boot itself records, against the database each
+        # bluebook's own world declares. Both queries only read: the connection refuses writes.
+        module BootStatus
+          # Each bluebook's boot status: from its own database when it declares one, else from the
+          # committed ledger and its edges (`source` says which).
+          #
+          # @param domain [Hash, String] the domain directory
+          # @return [Hash] `text:` the status as JSON, one row per bluebook
+          # @raise [Runtime::NotFound] if the directory cannot be loaded or a database refuses
+          def boot_status(domain:)
+            answering do
+              directory = plain(domain)
+              registry = Hecks.describe(directory).registry
+              JSON.pretty_generate(with_ledger(directory, registry, Runtime::EraStatus.rows(registry, directory)))
+            end
+          end
+
+          # What a boot would resolve for each bluebook, from its own database only: status, held
+          # and current labels, the ordinal it reads, and the reason. A bluebook bound to a store
+          # that holds no eras answers `no_eras`.
+          #
+          # @param domain [Hash, String] the domain directory
+          # @return [Hash] `text:` the resolution as JSON, one row per bluebook
+          # @raise [Runtime::NotFound] if the directory cannot be loaded or a database refuses
+          def boot_resolution(domain:)
+            answering do
+              directory = plain(domain)
+              rows = Runtime::EraStatus.rows(Hecks.describe(directory).registry, directory)
+              JSON.pretty_generate({ "domain" => directory, "bluebooks" => rows })
+            end
+          end
+
+          private
+
+          # The rows, with each `no_eras` row answered by the ledger instead.
+          def with_ledger(directory, registry, rows)
+            ledger = ShapeLedger::Status.of(directory, registry: registry)["bluebooks"] if no_database?(rows)
+            bluebooks = rows.to_h { |name, row| [name, row["source"] == "none" ? ledger.fetch(name, row) : row] }
+            { "domain" => directory, "bluebooks" => bluebooks }
+          end
+
+          def no_database?(rows) = rows.each_value.any? { |row| row["source"] == "none" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    class JournalStore
+      module Readings
+        # The dry run of `write_translation`: the edge that would be written, and the files it would
+        # delete, answered as text and written nowhere.
+        module Composition
+          # The composed edge `write_translation` would write, under comments that say which files
+          # it would remove.
+          #
+          # @param domain [Hash, String] the domain directory
+          # @return [Hash] `text:` the edge file's text, or the sentence that says nothing is to be written
+          # @raise [Runtime::NotFound] if the domain holds no eras, cannot be loaded, or its chain
+          #   cannot be composed
+          def compose_translation(domain:)
+            answering do
+              held = HeldDomain.open(plain(domain))
+              refuse_incapable!(held)
+              held.reading { |lineage| composition_text(held, lineage) }
+            end
+          end
+
+          private
+
+          def composition_text(held, lineage)
+            plan = translation_plan(held, lineage)
+            return plan.message if plan.message
+
+            notes = ["# Would write #{plan.path}."]
+            notes += plan.removals.map { |path| "# Would delete #{path}." }
+            [*notes, plan.text.chomp].join("\n")
+          end
+        end
+      end
+    end
+  end
+end