hecks 5.0.0 → 7.0.0

data/lib/hecks/hecks/adapters/qa_quiescing.adapter

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

data/lib/hecks/hecks/adapters/qa_quiescing.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "console_capture"
+require "hecks/quality_control/adapters/qa_quiesce_marker"
+
+module Hecks
+  module Adapters
+    # The `Quiescing` port's adapter: writes, removes and reads the QA quiet marker
+    # (`QaQuiesceMarker`). It touches no ledger and no git state.
+    class QaQuiescing
+      # @param aggregate [Object, nil] unused
+      # @param settings [Hash] `marker:` a `QaQuiesceMarker`, for a spec
+      # @param root [String, nil] unused
+      def initialize(aggregate: nil, settings: {}, root: nil)
+        @marker = settings[:marker] || QaQuiesceMarker.new
+      end
+
+      # Writes the marker.
+      #
+      # @param held [Hash] the `QaQuiesce` record: `reason`, optional `owner` and `force`
+      # @return [Hash{Symbol => Hash}] `output:` what was held
+      # @raise [ConsoleCapture::Failure] when another owner holds a fresh marker
+      def mark(**held)
+        hold = @marker.hold!(owner: owner(held), reason: plain(held[:reason]), force: plain(held[:force]) == true)
+        { output: { value: "quiesced: #{@marker.describe(hold)}" } }
+      rescue QaQuiesceMarker::Refused => e
+        raise ConsoleCapture::Failure, e.message
+      end
+
+      # Removes the marker.
+      #
+      # @param held [Hash] the `QaQuiesce` record: optional `owner` and `force`
+      # @return [Hash{Symbol => Hash}] `output:` what was released
+      # @raise [ConsoleCapture::Failure] when another owner holds a fresh marker
+      def clear(**held)
+        removed = @marker.release!(owner: owner(held), force: plain(held[:force]) == true)
+        { output: { value: removed ? "released: #{@marker.describe(removed)}" : "released: no marker was held" } }
+      rescue QaQuiesceMarker::Refused => e
+        raise ConsoleCapture::Failure, e.message
+      end
+
+      # @return [Hash{Symbol => String}] `text:` owner, reason and age of the marker
+      def status(**)
+        { text: @marker.status }
+      end
+
+      private
+
+      # The caller's name for the hold: the argument, else `HECKS_QUIESCE_OWNER`, else "unnamed".
+      def owner(held)
+        plain(held[:owner]) || ENV["HECKS_QUIESCE_OWNER"] || "unnamed"
+      end
+
+      def plain(argument) = argument.is_a?(Hash) ? argument[:value] : argument
+    end
+  end
+end

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

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

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

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

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

@@ -20,7 +20,6 @@ module Hecks
         ALWAYS = [
           { what: "the mint itself",
             why:  "no era was written: the edge, its approval and the audit were evaluated, nothing minted" },
-          { what: "an edge's coverage of every change in the shape", why: "the mint checks it; the rehearsal does not yet" },
           { what: "commands, policies and requests", why: "no traffic was run: only the stored data and the shape were read" },
           { what: "data written after the copy was made", why: "a copy is a moment; the mint sees the data of its own" }
         ].freeze
@@ -35,14 +34,15 @@ module Hecks
         # @return [Hash] `booted`, `host_version`, `store`, `mode`, `before`, `after`, `minting`,
         #   the schema and environment that were read, and what the copy holds
         def survey
-          shape.merge(environment_loaded: @subject.environment.facts, copy_note: plain(copy_note)).merge(copy_facts)
+          shape.merge(environment_loaded: @subject.environment_facts, copy_note: plain(copy_note)).merge(copy_facts)
         end
 
         # @return [Hash] the edge facts, every refused row and its total, what was read, the parity
         #   of the two engines, and what was not checked
         def examine
-          edge = minting == "next" ? @subject.edge_from(before) : nil
+          edge = decided_edge
           refusals, after = edge ? @store.audit(@subject, edge) : [[], {}]
+          refusals = coverage_refusals(edge) + refusals
           rust = RustAudit.call(@subject, after)
           report = AuditReport.new(minting: minting, edge: edge, states: after, ruby: refusals, rust: rust)
           answer(edge, report, (refusals + rust.violations).uniq, limits(rust, report))
@@ -52,9 +52,30 @@ module Hecks
 
         def plain(value) = { value: value }
 
+        # The edge a mint would use, as the shared decision names it; nil unless it would mint.
+        def decided_edge
+          return unless minting == "next" && latest[:held_text]
+
+          verdict = resolution.verdict
+          verdict&.verdict == "would_mint" ? verdict.edge : nil
+        end
+
+        # What the mint's coverage check would refuse of the decided edge, in the same words: a
+        # change in the shape that no rule of the edge explains. The mint raises it before it
+        # writes an era.
+        def coverage_refusals(edge)
+          return [] unless edge
+
+          held = PostgresEra::LineageManager.held_bluebook(latest)
+          PostgresEra::LineageManager.check_coverage!(@subject.registry, @subject.bluebook, held, edge)
+          []
+        rescue Runtime::WiringError => e
+          [e.message]
+        end
+
         def shape
-          { booted: flag(true), host_version: plain(Rehearsal.host_version), store: plain(@subject.declaration.kind),
-            mode: plain(@subject.declaration.mode), before: plain(before), after: plain(@subject.label),
+          { booted: flag(true), host_version: plain(Rehearsal.host_version), store: plain(@subject.store_kind),
+            mode: plain(@subject.copy_mode), before: plain(before), after: plain(@subject.label),
             minting: plain(minting) }
         end
 
@@ -69,12 +90,12 @@ module Hecks
         def census = @census ||= @store.census(@subject)
 
         def copy_note
-          domain = @subject.bluebook.name
+          domain = @subject.bluebook_name
           copy_empty? ? census.refusal(domain) : census.summary(domain)
         end
 
         def copy_empty?
-          census.empty? && @subject.declaration.mode != "empty" && @subject.bluebook.aggregates.any?
+          census.empty? && @subject.copy_mode != "empty" && @subject.aggregates.any?
         end
 
         # The copy is empty when a dump or a readonly copy was asked for and it holds no row of a
@@ -91,10 +112,16 @@ module Hecks
 
         def before = latest ? latest[:label] : "none"
 
+        # Which held era the shape resolves to, by the resolution a boot records; the latest era is
+        # named as it would be minted.
+        def resolution
+          @resolution ||= @subject.resolve([*eras[0...-1], latest]) { @store.watermark(@subject) }
+        end
+
         def minting
           return "first" unless latest
 
-          before == @subject.label ? "none" : "next"
+          resolution.status == "current" ? "none" : "next"
         end
 
         def limits(rust, report)
@@ -115,18 +142,18 @@ module Hecks
           census.head_rows == census.journal_rows ? "." : ": they differ, and only the journal's are audited."
         end
 
-        # The chapters loaded beside the domain's own (a vendored package): the host holds eras
+        # The bluebooks loaded beside the domain's own (a vendored package): the host holds eras
         # for the domain's own aggregates only, so theirs can neither mint nor be refused.
         def attached_limits
-          names = @subject.held.registry.bluebooks.values.map(&:name) - [@subject.bluebook.name]
+          names = @subject.bluebook_names - [@subject.bluebook_name]
           return [] if names.empty?
 
-          [{ what: "the shape of the attached chapters (#{names.sort.join(", ")})",
+          [{ what: "the shape of the attached bluebooks (#{names.sort.join(", ")})",
              why:  "their aggregates have no era row of their own, so a change to them is not a mint" }]
         end
 
         def binding_note
-          { what: "that a boot would mint", why: "the domain is bound to #{@subject.held.adapter_name}, which holds no eras " \
+          { what: "that a boot would mint", why: "the domain is bound to #{@subject.adapter_name}, which holds no eras " \
                                                  "in this environment" }
         end
       end

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

@@ -26,19 +26,36 @@ module Hecks
         # @return [void] there is nothing to drop
         def drop! = nil
 
+        # The document's eras as a lineage stores them, each with the storage shape a mint records:
+        # the document's own `projection` when it gives one, else the shape of its `held_text`,
+        # which a document holds whole, since it is written as the domain's source.
+        #
         # @param _subject [Subject] unused: the document holds its own eras
-        # @return [Array<Hash>] the eras, `ordinal` and `held_text`
+        # @return [Array<Hash>] the eras, `ordinal`, `held_text` and `projection`
         def eras(_subject)
-          Array(@document["eras"]).map { |era| { ordinal: era["ordinal"], held_text: era["held_text"] } }
+          Array(@document["eras"]).map do |era|
+            { ordinal: era["ordinal"], held_text: era["held_text"], projection: era["projection"] || shape_of(era["held_text"]) }
+          end
         end
 
+        # @return [Hash, nil] the storage shape a held text declares; nil for no text
+        def shape_of(text)
+          text && Runtime::StorageShape.project(PostgresEra::LineageManager.shadow(text))
+        end
+
+        # A document holds no ledger, so its watermark is zero and never moves.
+        #
+        # @param _subject [Subject] unused
+        # @return [Integer] the ledger watermark
+        def watermark(_subject) = 0
+
         # What the document holds: it keeps the latest state of each record only, so the head and
         # the journal counts are the same number.
         #
         # @param subject [Subject] the loaded domain
         # @return [Census] the counts
         def census(subject)
-          counts = subject.bluebook.aggregates.map do |aggregate|
+          counts = subject.aggregates.map do |aggregate|
             held = records(aggregate.name).size
             Census::Count.new(aggregate: aggregate.name, head: held, journal: held)
           end
@@ -54,9 +71,9 @@ module Hecks
         #   by aggregate name and id
         def audit(subject, edge)
           refusals = []
-          after = subject.bluebook.aggregates.to_h do |aggregate|
+          after = subject.aggregates.to_h do |aggregate|
             declared = edge.for_aggregate(aggregate.name)
-            before = records(declared&.was || aggregate.name)
+            before = split_before(edge, aggregate) || records(declared&.was || aggregate.name)
             translated = translate(aggregate, declared, before)
             refusals.concat(Translation::Audit.check(aggregate: aggregate, declared: declared, before: before,
                                                      after: translated).violations)
@@ -67,6 +84,49 @@ module Hecks
 
         private
 
+        # A split target's "before": its source's held records, fanned out one per key the split names,
+        # carrying the split's fields (ADR 0166). Nil when the aggregate is not a split target.
+        def split_before(edge, aggregate)
+          source, split = split_source_for(edge, aggregate)
+          source && fan_out(records(source.was || source.name), split)
+        end
+
+        # The source aggregate and the split that feeds `aggregate`, or nil.
+        def split_source_for(edge, aggregate)
+          edge.aggregates.each do |source|
+            split = source.splits.find { |candidate| candidate.into == aggregate.name }
+            return [source, split] if split
+          end
+          []
+        end
+
+        # One target record per source record that carries the split's key, holding the split's fields.
+        def fanned_out(held, split)
+          fields = split.fields.map(&:to_s)
+          held.filter_map do |_id, state|
+            key = split_key(state, split)
+            [key.to_s, state.slice(*fields)] if key
+          end.to_h
+        end
+
+        # A value object key is identified by its `value` member.
+        def split_key(state, split)
+          key = state[split.keyed_by.to_s]
+          key.is_a?(Hash) ? key["value"] : key
+        end
+
+        def fan_out(held, split)
+          fields = split.fields.map(&:to_s)
+          held.filter_map { |_id, state| fanned_row(state, split.keyed_by.to_s, fields) }.to_h
+        end
+
+        # One target row keyed by the held record's key, a value object's `value` member when it has one.
+        def fanned_row(state, key, fields)
+          value = state[key]
+          value = value["value"] if value.is_a?(Hash)
+          [value.to_s, state.slice(*fields)] if value
+        end
+
         def records(name) = @document.dig("records", name.to_s) || {}
 
         def translate(aggregate, declared, before)

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

@@ -59,17 +59,17 @@ module Hecks
                      counts: empty_counts, elsewhere: lineage)
         end
 
-        def empty_counts = @subject.bluebook.aggregates.map { |a| Census::Count.new(aggregate: a.name, head: 0, journal: 0) }
+        def empty_counts = @subject.aggregates.map { |a| Census::Count.new(aggregate: a.name, head: 0, journal: 0) }
 
         def counted(db, name, source, elsewhere)
-          lineage = PostgresEra::Lineage.new(db, @subject.bluebook.name)
+          lineage = PostgresEra::Lineage.new(db, @subject.bluebook_name)
           Census.new(schema: name, source: source, present: true, eras: eras(db), counts: counts(db, lineage),
                      journal_entries: rows(db, lineage.journal), elsewhere: elsewhere)
         end
 
         def counts(db, lineage)
           live = latest(db, lineage)
-          @subject.bluebook.aggregates.map do |aggregate|
+          @subject.aggregates.map do |aggregate|
             Census::Count.new(aggregate: aggregate.name, head: rows(db, lineage.head_view(aggregate.storage_name)),
                               journal: live.fetch(aggregate.storage_name, 0))
           end
@@ -78,7 +78,7 @@ module Hecks
         def eras(db)
           return 0 unless relation?(db, "hecks_eras")
 
-          db.exec_params("SELECT count(*) FROM hecks_eras WHERE domain = $1", [@subject.bluebook.name])[0]["count"].to_i
+          db.exec_params("SELECT count(*) FROM hecks_eras WHERE domain = $1", [@subject.bluebook_name])[0]["count"].to_i
         end
 
         def latest(db, lineage)

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

@@ -30,14 +30,23 @@ module Hecks
         end
 
         # @param subject [Subject] the loaded domain
-        # @param _edge [Bluebook::Translation] the edge leading to the shape
+        # @return [Integer] the ledger watermark the copy holds: zero when it holds no lineage
+        def watermark(subject)
+          return 0 unless census(subject).present
+
+          reading(subject, &:last_ordinal)
+        end
+
+        # @param subject [Subject] the loaded domain
+        # @param subject [Subject] the loaded domain
+        # @param edge [Object] the edge `Subject#decide` named for the shape, the one the mint takes
         # @return [Array(Array<String>, Hash)] what the audit's layers refuse over the stored
         #   records, and the records as translated, by aggregate name and id
-        def audit(subject, _edge)
+        def audit(subject, edge)
           return [[], {}] unless census(subject).present
 
           reading(subject) do |lineage|
-            finding = JournalStore::EdgeAudit.call(subject.held, lineage, subject.held.held_eras(lineage))
+            finding = JournalStore::EdgeAudit.call(subject.held, lineage, subject.held.held_eras(lineage), edge: edge)
             finding ? [finding.refusals, finding.after] : [[], {}]
           end
         end
@@ -48,17 +57,31 @@ module Hecks
           return [[@declaration.schema, "world"]] if @declaration.schema
           return [[ENV.fetch("HECKS_SCHEMA"), "HECKS_SCHEMA"]] if ENV.fetch("HECKS_SCHEMA", "") != ""
 
-          [[Naming.snake(subject.bluebook.name), "derived"], %w[public default]]
+          [[Naming.snake(subject.bluebook_name), "derived"], %w[public default]]
         end
 
         def reading(subject)
           subject.held.read_from(url)
-          db = PostgresEra.connect_for(subject.bluebook.name, subject.held.settings)
-          db.exec("SET default_transaction_read_only = on") if @declaration.mode == "readonly_copy"
-          yield PostgresEra::Lineage.new(db, subject.bluebook.name)
+          db = connect(subject)
+          yield PostgresEra::Lineage.new(db, subject.bluebook_name, reading: reads_only?)
         ensure
           db&.close
         end
+
+        # A copy somebody else made is opened read-only before any statement runs: the schema is
+        # selected, never created, and a digest the copy lacks is left unwritten. A database the run
+        # made is its own to touch, so it is opened as a PostgresEra boot opens it.
+        def connect(subject)
+          return PostgresEra.connect_for(subject.bluebook_name, subject.settings) unless reads_only?
+
+          require "pg"
+          PG.connect(url).tap do |db|
+            db.exec("SET default_transaction_read_only = on")
+            db.exec("SET search_path TO #{db.quote_ident(subject.settings[:schema])}") if subject.settings[:schema]
+          end
+        end
+
+        def reads_only? = @declaration.mode == "readonly_copy"
       end
     end
   end

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

@@ -22,6 +22,9 @@ module Hecks
         PREFIX = "hecks_rehearsal_"
         NAME = /\A#{PREFIX}[0-9a-f]{16}\z/
 
+        # A Postgres connection URL, by its scheme.
+        POSTGRES_URL = %r{\Apostgres(ql)?://}
+
         # @param declaration [Declaration] a `postgres` declaration
         # @param run [String] the rehearsal's key
         # @param protected_databases [Array<String>] databases the domain's own world names
@@ -85,7 +88,7 @@ module Hecks
 
         def server_url
           value = @declaration.connection
-          return value if value.match?(%r{\Apostgres(ql)?://})
+          return value if value.match?(POSTGRES_URL)
 
           raise Refused, "#{@declaration.connection_env} must hold a postgres:// URL"
         end

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

@@ -68,7 +68,7 @@ module Hecks
           Result.new(ran: true, violations: refusals(out), note: "ran over #{rows} rows", rows: rows)
         end
 
-        def ir = Projector::Exporter.call(@subject.held.registry).fetch(@subject.bluebook.name)
+        def ir = Projector::Exporter.call(@subject.registry).fetch(@subject.bluebook_name)
 
         def case_for(name, id, state)
           { "aggregate" => name, "id" => id, "state" => JSON.parse(JSON.generate(state)) }

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

@@ -4,6 +4,7 @@ require_relative "declaration"
 require_relative "environment"
 require_relative "../journal_store/edge_audit"
 require_relative "../journal_store/held_domain"
+require_relative "../../../adapters/driven/postgres_era/lineage_manager/era_resolution"
 
 module Hecks
   module Adapters
@@ -23,7 +24,8 @@ module Hecks
         def self.open(path)
           environment = choose_environment(path)
           held = load(path, environment)
-          new(held, Declaration.from_world(held.registry.world(held.bluebook.name), held.directory), environment)
+          bluebook = held.bluebook
+          new(held, Declaration.from_world(held.registry.world(bluebook.name), held.directory), environment)
         end
 
         # Whatever stops a domain from loading is a reason it cannot boot, a script error included.
@@ -60,7 +62,8 @@ module Hecks
             loading.load_library
             loading.load_each(directory, %w[*.world])
           end
-          registry.worlds.values.filter_map { |world| world.for_verb("rehearsed_by")[:environment] }.first
+          worlds = registry.worlds.values
+          worlds.filter_map { |world| world.for_verb("rehearsed_by")[:environment] }.first
         rescue StandardError, ScriptError
           nil
         end
@@ -75,27 +78,59 @@ module Hecks
           @environment = environment
         end
 
-        # @return [Bluebook::Chapter] the domain's bluebook as it stands
+        # @return [Bluebook::Declaration] the domain's bluebook as it stands
         def bluebook = held.bluebook
 
+        # @return [String] the name of the domain's bluebook
+        def bluebook_name = bluebook.name
+
+        # @return [Array<Bluebook::Behaviour::Aggregate>] the aggregates the bluebook declares
+        def aggregates = bluebook.aggregates
+
+        # @return [Runtime::Registry] the registry the domain was loaded into
+        def registry = held.registry
+
+        # @return [Array<String>] the names of every bluebook the registry holds
+        def bluebook_names = registry.bluebooks.values.map(&:name)
+
+        # @return [String] the persistence adapter the domain's journal store is bound to
+        def adapter_name = held.adapter_name
+
+        # @return [Hash] the settings the domain's journal store is connected with
+        def settings = held.settings
+
+        # @return [Hash] what the rehearsal reports about the overlay it loaded
+        def environment_facts = environment.facts
+
+        # @return [String] the kind of store the world's `rehearsed_by` names
+        def store_kind = declaration.kind
+
+        # @return [String] the copy mode the world's `rehearsed_by` names
+        def copy_mode = declaration.mode
+
         # @return [String] the label the shape a mint would hold has
         def label = Runtime::StorageShape.mint_label(bluebook)
 
         # @return [String] the domain's bluebook directory
         def directory = held.directory
 
-        # The edge that leads one era's label to the shape's label.
+        # Which held era the subject's shape resolves to, and the verdict a mint from the latest one
+        # would reach, by the resolution a boot records (`LineageManager::EraResolution`). It reads
+        # only the eras it is handed.
         #
-        # @param from [String] the held era's label
-        # @return [Bluebook::Translation, nil] the edge; nil when none is declared
-        def edge_from(from)
-          held.registry.translations.find { |t| t.domain == bluebook.name && t.from == from && t.to == label }
+        # @param eras [Array<Hash>] the copy's held eras, oldest first: `label`, `held_text`
+        # @yieldreturn [Integer] the copy's ledger watermark, read only when no held era matches
+        # @return [PostgresEra::LineageManager::EraResolution::Answer]
+        def resolve(eras, &)
+          PostgresEra::LineageManager::EraResolution.resolve(
+            eras: eras, bluebook: bluebook, translations: registry.translations, directory: directory, &
+          )
         end
 
         # @return [Array<String>] the persisted databases the domain's own world names, which a
         #   rehearsal must never be pointed at
         def declared_databases
-          blocks = held.registry.world(bluebook.name)&.settings || {}
+          blocks = registry.world(bluebook.name)&.settings || {}
           blocks.select { |key, _| key.to_s.start_with?("persisted_by") }.values.filter_map { |block| block[:database] }
         end
       end

data/lib/hecks/hecks/adapters/rust_toolchain.rb

@@ -21,7 +21,7 @@ module Hecks
       # The `Hecks::RustBuild` tool each ask runs.
       TOOLS = { generate: "project_rust", wasm: "project_wasm", host: "project_host",
                 browser_wasm: "project_wasm_browser", conform: "rust_conformance",
-                replay: "rust_conformance_fuzz", coverage: "rust_coverage" }.freeze
+                replay: "rust_conformance_fuzz", coverage: "rust_coverage", parser: "build_parser" }.freeze
 
       # The load path the benchmark child runs with: this checkout's or gem's `lib/`.
       LIB = File.expand_path("../../..", __dir__)
@@ -70,7 +70,9 @@ module Hecks
       # @return [Hash{Symbol => Hash}] `output:` where the module was written
       # @raise [ConsoleCapture::Failure] when the wasm target or the build is missing
       def wasm(**held)
-        child(:wasm, [plain(held[:domain])])
+        argv = [plain(held[:domain])]
+        argv << "--profile=#{plain(held[:profile])}" if plain(held[:profile])
+        child(:wasm, argv)
       end
 
       # Generates the domain, compiles it to a `wasm32-wasip1` module, builds the host binary from
@@ -85,6 +87,7 @@ module Hecks
         argv = [plain(held[:domain])]
         argv << "--target=#{plain(held[:target])}" if plain(held[:target])
         argv << "--stage=#{plain(held[:stage_dir])}" if plain(held[:stage_dir])
+        argv << "--no-prebuilt" if plain(held[:prebuilt]) == false
         child(:host, argv)
       end
 
@@ -130,6 +133,15 @@ module Hecks
         child(:coverage, ["--check-allowlist"])
       end
 
+      # Builds the `hecks-parse` binary the parser specs run, in `rust/parser`.
+      #
+      # @param _held [Hash] the `Build` record, which holds nothing this needs
+      # @return [Hash{Symbol => Hash}] `output:` what cargo reported
+      # @raise [ConsoleCapture::Failure] when cargo cannot build the crate
+      def parser(**_held)
+        child(:parser, [])
+      end
+
       # Measures command throughput and latency for each target, building the Rust binary in the
       # workspace when it is a target and none was named. The benchmark can run for minutes, so it
       # starts through `ProcessPool`, which passes an interrupt on to it.
@@ -185,8 +197,7 @@ module Hecks
 
       def run(ask, argv)
         space = self.class.workspace || RustWorkspace.new
-        env = space.environment
-        (self.class.runner || RustBuild).capture(TOOLS.fetch(ask), argv, env: env)
+        (self.class.runner || RustBuild).capture(TOOLS.fetch(ask), argv, env: space.environment)
       rescue RustWorkspace::Unavailable => e
         raise ConsoleCapture::Failure, e.message
       end

data/lib/hecks/hecks/adapters/rust_workspace.rb

@@ -22,7 +22,7 @@ module Hecks
       CHECKOUT_MARKER = "hecks.gemspec"
 
       # What a copy holds: the workspace manifest, the kernel and every crate a domain build uses.
-      PACKAGED = %w[Cargo.toml Cargo.lock src codegen parser
+      PACKAGED = %w[Cargo.toml Cargo.lock src codegen parser expr
                     host build web lsp].freeze
 
       # Left out of a copy: build output anywhere, the corpus tests, and the corpus domains.