hecks 4.0.0 → 6.0.0

data/lib/hecks/hecks/adapters/git_train.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "git"
+require_relative "console_capture"
+require_relative "git_train/reading"
+require_relative "git_train/bench"
+require_relative "git_train/local_branch"
+require_relative "git_train/carriage"
+require_relative "git_train/survey"
+
+module Hecks
+  module Adapters
+    # The `Train` port's adapter: pushes a checkout's branch one push at a time per repository.
+    #
+    # A boarding takes an exclusive `flock` on a file in the repository's common git directory, so
+    # every worktree of one repository waits in the same line, and holds it until its push ends.
+    # Waiting costs nothing: the pre-push checks of one push run at a time instead of all at once.
+    class GitTrain
+      include Reading
+
+      # The lock's file, in the repository's common git directory.
+      LOCK_FILE = "hecks-push-train.lock"
+
+      # 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)
+        @git = Git.new
+      end
+
+      # Waits for the push ahead in the same repository, then carries the boarded commit.
+      #
+      # @param held [Hash] the `PushTrain` record: `branch`, `remote`, `checkout` (a directory
+      #   inside the repository; the current directory when none is named) and `full_gate` (the
+      #   push runs the whole pre-push stage, which the hook reads as `hecks.fullGate`)
+      # @return [Hash{Symbol => Hash}] `outcome:` (`pushed` or `carried`), `checkout:`, `boarded:`,
+      #   `pushed:` and `report:`
+      # @raise [ConsoleCapture::Failure] when the checkout is not a repository, the branch and the
+      #   remote's conflict, or the push is refused
+      def carry(**held)
+        @checkout = toplevel(plain(held[:checkout]) || Dir.pwd)
+        carriage = Carriage.new(@git, @checkout, branch: plain(held[:branch]) || "main",
+                                                 remote: plain(held[:remote]) || "origin",
+                                                 config: gate_config(held))
+        boarded = carriage.local_head
+        in_turn { carriage.carry(boarded) }
+      end
+
+      # Lists every checkout under a directory whose default branch has commits its remote does
+      # not, fetching each first.
+      #
+      # @param held [Hash] the `PushTrain` record: `checkout` (the directory whose children are
+      #   surveyed; the current directory when none is named) and `remote`
+      # @return [Hash{Symbol => Hash}] `report:` one line per checkout with unpushed commits
+      # @raise [ConsoleCapture::Failure] when the directory does not exist
+      def tally(**held)
+        root = plain(held[:checkout]) || Dir.pwd
+        raise ConsoleCapture::Failure, "#{root} is not a directory" unless File.directory?(root)
+
+        { report: { value: Survey.new(@git, root, remote: plain(held[:remote]) || "origin").report } }
+      end
+
+      private
+
+      # A git hook takes no arguments, so the argument reaches the pre-push hook as git
+      # configuration, for this push only (`git -c`).
+      def gate_config(held) = plain(held[:full_gate]) == true ? ["-c", "hecks.fullGate=true"] : []
+
+      def in_turn
+        path = File.join(read("rev-parse", "--path-format=absolute", "--git-common-dir"), LOCK_FILE)
+        File.open(path, File::RDWR | File::CREAT) do |lock|
+          lock.flock(File::LOCK_EX)
+          yield
+        end
+      end
+
+      def toplevel(dir)
+        raise ConsoleCapture::Failure, "#{dir} is not a directory" unless File.directory?(dir)
+
+        read("rev-parse", "--show-toplevel", dir: dir)
+      end
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/git_worktrees.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "git"
+require_relative "console_capture"
+require_relative "git_train/reading"
+
+module Hecks
+  module Adapters
+    # What the `Checkout` and `Landing` adapters share: finding a repository from any directory in
+    # it, listing its worktrees, and telling a clean tree from a dirty one.
+    #
+    # An includer sets `@git` (the `Git` adapter) before calling anything here, and `settle` sets
+    # `@checkout` (a repository's top level). Every branch or ref that reaches a command is
+    # checked against `GitRefs::REF_PATTERN` first, so a name cannot carry a flag.
+    module GitWorktrees
+      include GitTrain::Reading
+
+      # One worktree of a repository, as `git worktree list --porcelain` describes it.
+      #
+      # @!attribute [r] path
+      #   @return [String] where it is checked out
+      # @!attribute [r] head
+      #   @return [String, nil] the commit it stands on
+      # @!attribute [r] branch
+      #   @return [String, nil] the branch it has checked out, nil when detached
+      Worktree = Struct.new(:path, :head, :branch)
+
+      # The blank line between two worktrees in `git worktree list --porcelain`.
+      BLOCK_BREAK = /\n\n+/
+
+      private
+
+      # Points the adapter at the repository a directory is in.
+      #
+      # @param held [Hash] the arguments of a command or query; `checkout` names the directory
+      # @return [String] the repository's top level
+      # @raise [ConsoleCapture::Failure] when the directory is not there or not in a repository
+      def settle(held)
+        dir = plain(held[:checkout]) || Dir.pwd
+        raise ConsoleCapture::Failure, "#{dir} is not a directory" unless File.directory?(dir)
+
+        @checkout = read("rev-parse", "--show-toplevel", dir: dir)
+      end
+
+      def worktrees
+        read("worktree", "list", "--porcelain").split(BLOCK_BREAK).map { |block| worktree_of(block) }
+      end
+
+      def worktree_of(block)
+        fields = block.lines.to_h { |line| line.strip.split(" ", 2).then { |key, value| [key, value] } }
+        Worktree.new(fields["worktree"], fields["HEAD"], fields["branch"]&.delete_prefix("refs/heads/"))
+      end
+
+      def primary = worktrees.first
+
+      def worktree_on(branch) = worktrees.find { |tree| tree.branch == branch }
+
+      def current_branch
+        result = @git.capture("symbolic-ref", "--quiet", "--short", "HEAD", chdir: @checkout)
+        return result.out.strip if result.ok?
+
+        raise ConsoleCapture::Failure, "#{@checkout} has no branch checked out"
+      end
+
+      # The paths git lists as changed or untracked in a tree, one porcelain line each.
+      def dirty(dir = @checkout) = read("status", "--porcelain", dir: dir).lines.map(&:rstrip)
+
+      def ref(name)
+        return name if name.to_s.match?(GitRefs::REF_PATTERN)
+
+        raise ConsoleCapture::Failure, "#{name.inspect} is not a branch or ref name"
+      end
+
+      def branch_tip(branch) = read("rev-parse", "--verify", "refs/heads/#{ref(branch)}^{commit}")
+
+      def count(range) = read("rev-list", "--count", range).to_i
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

data/lib/hecks/hecks/adapters/host_http.rb

@@ -44,15 +44,16 @@ module Hecks
       #   `mismatch`) and `report:` (the sentence `hecks check_era` prints)
       # @raise [ArgumentError] if no allow-list file or timeout was given
       # @raise [Errno::ENOENT] if the allow-list file cannot be read
-      # @raise [Runtime::EraCheck::ExpectedEra::Unreachable] if the host cannot be reached
-      # @raise [Runtime::EraCheck::ExpectedEra::BadResponse] if it answers no era
+      # @raise [CLI::ExpectedEra::Unreachable] if the host cannot be reached
+      # @raise [CLI::ExpectedEra::BadResponse] if it answers no era
       def fetch(**held)
         file = required(held[:expected], "no allow-list file to compare the era with")
         timeout = required(held[:timeout], "no timeout to wait for the host with")
         finding = CLI::CheckEra.assess(plain(held[:host]), file, timeout: timeout.to_f)
+        verdict = finding.verdict
 
-        { era: { value: finding.verdict.era }, version: { value: finding.version },
-          verdict: { value: finding.verdict.status.to_s }, report: { value: finding.line } }
+        { era: { value: verdict.era }, version: { value: finding.version },
+          verdict: { value: verdict.status.to_s }, report: { value: finding.line } }
       end
 
       private

data/lib/hecks/hecks/adapters/in_process_access.rb

@@ -7,12 +7,13 @@ module Hecks
     # What the `DomainRuntime` port's adapter does when an `Operation` asks it to give a domain its
     # first administrator.
     module InProcessAccess
-      # Boots the domain and grants the first administrator through its membership chapter.
+      # Boots the domain and grants the first administrator through its membership bluebook.
       #
       # @param held [Hash] the `Operation` record: `subject` (the domain), `email`, and optionally
       #   `name` and `role`
       # @return [Hash{Symbol => Hash}] `output:` the sentence saying who now holds which role
-      # @raise [Runtime::NotFound] if the domain cannot be found or has no membership chapter, or an
+      # @raise [Runtime::NotFound] if the domain cannot be found or has no membership bluebook, or
+      #   an
       #   administrator already exists
       def bootstrap(**held)
         result = FirstAdmin.new(boot(held[:subject])).call(

data/lib/hecks/hecks/adapters/in_process_boot.rb

@@ -8,6 +8,7 @@ require_relative "../../ports/persistence/plugins/era"
 require_relative "../../cli/stores"
 require_relative "../../cli/shape"
 require_relative "../../cli/history"
+require_relative "../../projections/context_map_diagram"
 require_relative "in_process_operations"
 require_relative "in_process_access"
 
@@ -19,7 +20,7 @@ module Hecks
     # Each method returns the text the matching tool prints, so the launcher shows the
     # same bytes; a projection that would have written files answers a map of file name to text
     # instead. Arguments arrive materialized, so a value object is `{ value: "x" }`. A domain or
-    # chapter that cannot be found raises `Runtime::NotFound`, which the launcher words as a
+    # bluebook that cannot be found raises `Runtime::NotFound`, which the launcher words as a
     # refusal.
     #
     # It also answers the asks of journaled commands (`InProcessOperations`): a model check, a run,
@@ -59,17 +60,16 @@ module Hecks
       end
 
       # @param domain [Hash, String] a domain directory
-      # @return [Hash] `text:` every aggregate's current records as one JSON document
-      # @raise [Runtime::NotFound] if the domain cannot be found
-      def stores(domain:)
+      # @param aggregate [Hash, String, nil] a storage name, to read only that aggregate
+      # @param record [Hash, String, nil] a record id within `aggregate`, to read only that record
+      # @param flat [Hash, Boolean, nil] true unwraps the value objects to their values
+      # @return [Hash] `text:` every aggregate's current records as one JSON document, or what
+      #   `aggregate` and `record` narrow it to
+      # @raise [Runtime::NotFound] if the domain, aggregate or record cannot be found
+      def stores(domain:, aggregate: nil, record: nil, flat: nil)
         registry = boot(domain).registry
-        stores = registry.bluebooks.each_with_object({}) do |(name, bluebook), all|
-          bluebook.aggregates.each do |aggregate|
-            all[aggregate.storage_name] = CLI::Stores.data_for(registry.repository(name, aggregate))
-          end
-        end
-
-        report(JSON.generate(stores))
+        CLI::PersistenceNotice.announce(registry, program: "hecks stores")
+        report(JSON.generate(CLI::Stores.read(registry, plain(aggregate), plain(record), flat: plain(flat) == true)))
       end
 
       # @param domain [Hash, String] a domain directory
@@ -77,15 +77,17 @@ module Hecks
       #   hold, as JSON
       # @raise [Runtime::NotFound] if the domain cannot be found
       def history(domain:)
-        report(JSON.generate(CLI::History.document(boot(domain).registry)))
+        registry = boot(domain).registry
+        CLI::PersistenceNotice.announce(registry, program: "hecks history")
+        report(JSON.generate(CLI::History.document(registry)))
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
-      # @return [Hash] `text:` the chapter's declared facts, one sentence a line
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def statements(domain:, chapter:)
-        report(Projector.call(:statements, bluebook: chapter_of(domain, chapter)).join("\n"))
+      # @param bluebook [Hash, String] the bluebook's name
+      # @return [Hash] `text:` the bluebook's declared facts, one sentence a line
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def statements(domain:, bluebook:)
+        report(Projector.call(:statements, bluebook: bluebook_of(domain, bluebook)).join("\n"))
       end
 
       # @param domain [Hash, String, nil] a domain directory; the nearest enclosing one when absent
@@ -96,6 +98,30 @@ module Hecks
         document(:narrate, domain, aggregate)
       end
 
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` one line per relationship between the contexts the domain holds
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def relationships(domain:)
+        report(Projections::ContextRelationships.text(registry: boot(domain).registry))
+      end
+
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` the declared context map drawn as Mermaid beside the wiring, with
+      #   each finding of holding the wiring to the map as a comment
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def context_map(domain:)
+        registry = boot(domain).registry
+        edges = Projections::ContextRelationships.call(registry: registry)
+        report(Projections::ContextMapDiagram.report(map: registry.context_maps.first, edges: edges))
+      end
+
+      # @param domain [Hash, String] a domain directory
+      # @return [Hash] `text:` a starting `.world` for the adapters the domain binds
+      # @raise [Runtime::NotFound] if the domain cannot be found
+      def world_skeleton(domain:)
+        report(Projections::WorldSkeleton.call(registry: boot(domain).registry))
+      end
+
       # @param domain [Hash, String, nil] a domain directory; the nearest enclosing one when absent
       # @param aggregate [Hash, String, nil] document only this aggregate
       # @return [Hash] `text:` the domain's usage document
@@ -105,29 +131,29 @@ module Hecks
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
+      # @param bluebook [Hash, String] the bluebook's name
       # @return [Array<Hash{Symbol => String}>] one `name:`/`text:` row per diagram file
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def project_diagrams(domain:, chapter:)
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def project_diagrams(domain:, bluebook:)
         runtime = boot(domain)
-        name    = plain(chapter)
-        options = { hecksagon: runtime.registry.hecksagon(name) }
+        name    = plain(bluebook)
+        options = { hecksagon: runtime.hecksagon(name) }
 
-        projected_files(Projector.call(:diagrams, bluebook: chapter_in(runtime, name), options: options))
+        projected_files(Projector.call(:diagrams, bluebook: bluebook_in(runtime, name), options: options))
       end
 
       # @param domain [Hash, String] a domain directory
-      # @param chapter [Hash, String] the chapter's name
+      # @param bluebook [Hash, String] the bluebook's name
       # @return [Array<Hash{Symbol => String}>] one `name:`/`text:` row per glossary file
-      # @raise [Runtime::NotFound] if the domain or chapter cannot be found
-      def glossary(domain:, chapter:)
+      # @raise [Runtime::NotFound] if the domain or bluebook cannot be found
+      def glossary(domain:, bluebook:)
         runtime = boot(domain)
-        name    = plain(chapter)
-        markings = runtime.registry.pending_privacy_markings.select do |marking|
+        name    = plain(bluebook)
+        markings = runtime.pending_privacy_markings.select do |marking|
           marking[:domain].to_s.start_with?("#{name}::")
         end
 
-        projected_files(Projector.call(:glossary, bluebook: chapter_in(runtime, name),
+        projected_files(Projector.call(:glossary, bluebook: bluebook_in(runtime, name),
                                                   options:  { markings: markings }))
       end
 
@@ -177,17 +203,18 @@ module Hecks
         Hecks.boot(File.expand_path(path), install_driving: false)
       end
 
-      def chapter_of(domain, chapter)
-        chapter_in(boot(domain), plain(chapter))
+      def bluebook_of(domain, declaration)
+        bluebook_in(boot(domain), plain(declaration))
       end
 
-      def chapter_in(runtime, name)
-        runtime.registry.bluebook(name) or raise Runtime::NotFound, "no chapter named #{name}"
+      def bluebook_in(runtime, name)
+        runtime.bluebook(name) or raise Runtime::NotFound, "no bluebook named #{name}"
       end
 
-      # The domain's own chapter, not a framework member it attached: insertion order.
+      # The domain's own bluebook, not a framework member it attached: insertion order.
       def document(projection, domain, aggregate)
-        bluebook = boot(domain).registry.bluebooks.values.first or raise Runtime::NotFound, "no bluebook loaded"
+        registry = boot(domain).registry
+        bluebook = registry.first_bluebook or raise Runtime::NotFound, "no bluebook loaded"
         name = plain(aggregate)
 
         report(Projector.call(projection, bluebook: bluebook, options: name ? { aggregate: name } : {}))

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

@@ -22,7 +22,7 @@ module Hecks
     module InProcessOperations
       include Tailing
 
-      # The chapters `hecks model_check` sweep when no domain is named need a
+      # The bluebooks `hecks model_check` sweep when no domain is named need a
       # checkout; an installed gem has none.
       CHECKOUT_MARKER = "hecks.gemspec"
 
@@ -59,7 +59,7 @@ module Hecks
         script = plain(held[:script])
         argv += script ? [script] : [plain(held[:verb]), *words(held[:arguments])].compact
 
-        output(ConsoleCapture.answer { CLI::Run.call(argv, program: "hecks run") })
+        output(ConsoleCapture.answer_apart { CLI::Run.call(argv, program: "hecks run") })
       end
 
       # Forces every read-model projection the domain declares to catch up.
@@ -72,6 +72,32 @@ module Hecks
         output("refreshed #{count} projection(s)")
       end
 
+      # Redelivers the reactions a domain's outbox left undelivered. A claimed row (one that
+      # stalled across a crash, whose effect may or may not have run) is redelivered only when
+      # `claimed` says so for every claimed row, or `row` names that one row's delivery id.
+      #
+      # @param held [Hash] the `Operation` record: `subject` (the domain), `claimed` (a switch)
+      #   and `row` (a delivery id)
+      # @return [Hash{Symbol => Hash}] `output:` how many rows were redriven
+      # @raise [Runtime::NotFound] if the domain cannot be found, or no claimed row has `row`
+      def redrive(**held)
+        outbox = Assembly.bind_ported_runtime(boot(held[:subject])).outbox
+        row = plain(held[:row])
+        rows = row ? outbox.redrive_row!(row) : outbox.redrive!(claimed: plain(held[:claimed]) == true)
+        output("redrove #{rows.size} outbox row(s)")
+      end
+
+      # Settles one stalled claimed outbox row as failed, without running its consumer.
+      #
+      # @param held [Hash] the `Operation` record: `subject` (the domain) and `row` (a delivery id)
+      # @return [Hash{Symbol => Hash}] `output:` the row that was abandoned
+      # @raise [Runtime::NotFound] if the domain cannot be found, or no claimed row has `row`
+      def abandon(**held)
+        outbox = boot(held[:subject]).outbox
+        rows = outbox.abandon_row!(plain(held[:row]))
+        output("abandoned #{rows.size} outbox row(s): #{rows.map(&:delivery_id).join(", ")}")
+      end
+
       # Runs a `.behaviors` file, or every one under a directory.
       #
       # @param held [Hash] the `Operation` record: `subject` (the file or directory)
@@ -164,7 +190,7 @@ module Hecks
       #
       # @raise [Runtime::NotFound] if one does not
       def named_domains(held)
-        argv = plain(held[:domains]).to_s.split(",").map(&:strip).reject(&:empty?)
+        argv = Text.comma_list(plain(held[:domains]))
         missing = argv.reject { |domain| File.exist?(domain) }
         raise Runtime::NotFound, "no such domain #{missing.first.inspect}" if missing.any?
 
@@ -197,7 +223,7 @@ module Hecks
 
       # Says whether `event` passes the aggregate filter: a bare name, case-insensitive, or exact.
       def followed?(event, filter)
-        filter.nil? || event.aggregate.to_s.split("::").last.casecmp?(filter) || event.aggregate == filter
+        filter.nil? || Naming.demodulise(event.aggregate).casecmp?(filter) || event.aggregate == filter
       end
     end
   end

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

@@ -42,11 +42,11 @@ 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?
+            raise Runtime::WiringError, "#{domain.domain_name} already holds an era" unless lineage.eras.empty?
 
             lineage.hold_first!(domain.source_text, projection: domain.shape)
           end
-          "#{domain.bluebook.name} holds era 1 now."
+          "#{domain.domain_name} holds era 1 now."
         end
 
         def apply_merge_tail(held)
@@ -55,7 +55,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 +73,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 +86,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,7 +98,7 @@ 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."
         end

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

@@ -34,6 +34,8 @@ module Hecks
         # @param eras [Array<Hash>] the held eras
         def initialize(held, lineage, eras)
           @held = held
+          @bluebook = held.bluebook
+          @registry = held.registry
           @lineage = lineage
           @eras = eras
           @manager = PostgresEra::LineageManager
@@ -55,16 +57,16 @@ 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])
           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)
+          chain = @manager.edge_chain(@registry, @bluebook, @eras[0..-2] + [latest], label)
           finding(chain, latest[:ordinal] + 1, leaving.size, edge)
         end
 
@@ -77,12 +79,12 @@ module Hecks
 
         # 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"),
@@ -113,7 +115,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

@@ -92,8 +92,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
@@ -103,7 +103,7 @@ module Hecks
         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|
+          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) }