hecks 5.0.0 → 6.0.0

data/lib/hecks/runtime/registry/providers.rb

@@ -1,153 +1,88 @@
 module Hecks
   module Runtime
     class Registry
-      # Finds the loaded chapter that provides a capability for a domain: authorization, identity,
-      # membership, newsletters, registrations and payments.
+      # Finds the loaded bluebook that provides a capability for a domain: authorization, identity
+      # and membership by name, any other capability through `vendored_provider_for`.
       module Providers
-        # The chapter that answers a role check for `domain`: the domain's own chapter, or
-        # a chapter its hecksagon attaches, that declares `provides "authorization"`.
+        # The bluebook that answers a role check for `domain`: the domain's own bluebook, or
+        # a bluebook its hecksagon attaches, that declares `provides "authorization"`.
         #
         # @param domain [String, Symbol] the domain whose role checks are being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s role
+        # @return [Bluebook::Declaration, nil] the bluebook that answers `domain`'s role
         #   checks, or nil if none does
         def authorization_provider_for(domain)
-          names = [domain.to_s, *Array(hecksagon(domain)&.member_chapters)]
+          names = [domain.to_s, *Array(hecksagon(domain)&.member_bluebooks)]
           names.filter_map { |name| bluebook(name) }
-               .find { |chapter| chapter.provides?(Bluebook::Capabilities::AUTHORIZATION) }
+               .find { |declaration| declaration.provides?(Bluebook::Capabilities::AUTHORIZATION) }
         end
 
-        # Every loaded chapter declaring `provides "authorization"`.
+        # Every loaded bluebook declaring `provides "authorization"`.
         #
-        # @return [Array<Bluebook::Chapter>] every loaded chapter that provides
+        # @return [Array<Bluebook::Declaration>] every loaded bluebook that provides
         #   authorization
         def authorization_providers
-          bluebooks.values.select { |chapter| chapter.provides?(Bluebook::Capabilities::AUTHORIZATION) }
+          bluebooks.values.select { |declaration| declaration.provides?(Bluebook::Capabilities::AUTHORIZATION) }
         end
 
-        # The chapter that answers "who is this authenticated pair" for `domain`: the
-        # domain's own chapter, or a framework member its hecksagon attaches, that
+        # The bluebook that answers "who is this authenticated pair" for `domain`: the
+        # domain's own bluebook, or a framework member its hecksagon attaches, that
         # declares `provides "identity"`.
         #
-        # @param domain [String, Symbol] the domain whose identity chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s identity
+        # @param domain [String, Symbol] the domain whose identity bluebook is being resolved
+        # @return [Bluebook::Declaration, nil] the bluebook that answers `domain`'s identity
         #   questions, or nil if none does
         def identity_provider_for(domain)
-          names = [domain.to_s, *Array(hecksagon(domain)&.member_chapters)]
+          names = [domain.to_s, *Array(hecksagon(domain)&.member_bluebooks)]
           attached = names.filter_map { |name| bluebook(name) }
-                          .find { |chapter| chapter.provides?(Bluebook::Capabilities::IDENTITY) }
+                          .find { |declaration| declaration.provides?(Bluebook::Capabilities::IDENTITY) }
           return attached if attached
 
-          # Falls back to any loaded chapter: a consuming domain often wires Identity as
+          # Falls back to any loaded bluebook: a consuming domain often wires Identity as
           # Hecks.hecksagon "Identity" rather than via `attaches`, so it's loaded but
           # not listed on the consumer's own hecksagon.
-          bluebooks.values.find { |chapter| chapter.provides?(Bluebook::Capabilities::IDENTITY) }
+          bluebooks.values.find { |declaration| declaration.provides?(Bluebook::Capabilities::IDENTITY) }
         end
 
-        # The chapter that answers "who may sign in" for `domain`: the domain's own
-        # chapter, a framework member, or a vendored embryonaut bluebook it attaches,
+        # The bluebook that answers "who may sign in" for `domain`: the domain's own
+        # bluebook, a framework member, or a vendored embryonaut bluebook it attaches,
         # that declares `provides "membership"`.
         #
         # Vendored packages are included, since membership ships as a vendored
-        # embryonaut_bluebooks chapter, not a framework member.
+        # embryonaut_bluebooks bluebook, not a framework member.
         #
         # @param domain [String, Symbol] the domain whose sign-in aggregate is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s membership
+        # @return [Bluebook::Declaration, nil] the bluebook that answers `domain`'s membership
         #   questions, or nil if none does
         def membership_provider_for(domain)
           vendored_provider_for(domain, Bluebook::Capabilities::MEMBERSHIP)
         end
 
-        # The chapter that answers the guest newsletter signup for `domain`: the domain's
-        # own chapter, a framework member, or a vendored embryonaut bluebook it attaches,
-        # that declares `provides "newsletter"`.
-        #
-        # @param domain [String, Symbol] the domain whose newsletter chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s newsletter
-        #   signup, or nil if none does
-        def newsletter_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::NEWSLETTER)
-        end
-
-        # The chapter that answers sending a newsletter issue for `domain` —
-        # resolved the same way as `newsletter_provider_for`, by what it
-        # declares (`provides "newsletter_issues"`). Nil when none does.
-        #
-        # @param domain [String, Symbol] the domain whose issue-sending chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s issue sending,
-        #   or nil if none does
-        def newsletter_issues_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::NEWSLETTER_ISSUES)
-        end
-
-        # The chapter that answers scheduling sessions and registrations for `domain`,
-        # resolved the same way as `payments_provider_for`, by declaring `provides "registrations"`.
-        #
-        # @param domain [String, Symbol] the domain whose registrations chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that answers `domain`'s registrations,
-        #   or nil if none does
-        def registrations_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::REGISTRATIONS)
-        end
-
-        # The chapter that owns the business's payment-processor connection for
-        # `domain` — resolved by what it declares (`provides "payment_connection"`).
-        # Nil when none does.
-        #
-        # @param domain [String, Symbol] the domain whose payment-connection chapter is
-        #   being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that owns `domain`'s payment connection,
-        #   or nil if none does
-        def payment_connection_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::PAYMENT_CONNECTION)
-        end
-
-        # The chapter that owns the checkout boundary for `domain` — resolved by what it
-        # declares (`provides "checkout"`). Nil when none does.
-        #
-        # @param domain [String, Symbol] the domain whose checkout chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that owns `domain`'s checkout windows,
-        #   or nil if none does
-        def checkout_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::CHECKOUT)
-        end
-
-        # The chapter that takes payments for `domain`: the domain's own chapter, a
-        # framework member, or a vendored embryonaut bluebook it attaches, that
-        # declares `provides "payments"`.
-        #
-        # @param domain [String, Symbol] the domain whose payments chapter is being resolved
-        # @return [Bluebook::Chapter, nil] the chapter that takes `domain`'s payments, or nil
-        #   if none does
-        def payments_provider_for(domain)
-          vendored_provider_for(domain, Bluebook::Capabilities::PAYMENTS)
-        end
-
-        # The first loaded chapter that declares `capability`, whichever domain asks.
+        # The first loaded bluebook that declares `capability`, whichever domain asks.
         #
         # @param capability [String] a `Bluebook::Capabilities` name
-        # @return [Bluebook::Chapter, nil] the providing chapter, or nil if none loaded does
-        def provider_of(capability) = bluebooks.values.find { |chapter| chapter.provides?(capability) }
+        # @return [Bluebook::Declaration, nil] the providing bluebook, or nil if none loaded does
+        def provider_of(capability) = bluebooks.values.find { |declaration| declaration.provides?(capability) }
 
-        # The chapter that provides `capability` for `domain`: the domain's own chapter,
+        # The bluebook that provides `capability` for `domain`: the domain's own bluebook,
         # a framework member its hecksagon attaches, or a vendored embryonaut bluebook
         # it attaches, that declares it.
         #
-        # Falls back to any loaded chapter, since a consuming domain often wires a
-        # vendored chapter as its own `Hecks.hecksagon "Name"` rather than via
+        # Falls back to any loaded bluebook, since a consuming domain often wires a
+        # vendored bluebook as its own `Hecks.hecksagon "Name"` rather than via
         # `attaches ... from: :vendor`, so it's loaded but not listed on the consumer's hecksagon.
         #
         # @param domain [String, Symbol] the domain the provider is resolved for
-        # @param capability [String] the capability's name, such as
-        #   `Bluebook::Capabilities::MEMBERSHIP`
-        # @return [Bluebook::Chapter, nil] the providing chapter, or nil if none loaded does
+        # @param capability [String] the capability's name: `Bluebook::Capabilities::MEMBERSHIP`,
+        #   or one a package declares
+        # @return [Bluebook::Declaration, nil] the providing bluebook, or nil if none loaded does
         def vendored_provider_for(domain, capability)
           hecksagon = hecksagon(domain)
-          names = [domain.to_s, *Array(hecksagon&.member_chapters)]
+          names = [domain.to_s, *Array(hecksagon&.member_bluebooks)]
           attached = names.filter_map { |name| bluebook(name) }
-                          .find { |chapter| chapter.provides?(capability) }
+                          .find { |declaration| declaration.provides?(capability) }
           return attached if attached
 
-          bluebooks.values.find { |chapter| chapter.provides?(capability) }
+          bluebooks.values.find { |declaration| declaration.provides?(capability) }
         end
       end
     end

data/lib/hecks/runtime/registry/query_verification.rb

@@ -14,13 +14,13 @@ module Hecks
         # adapter behind its port that implements it, found here so it fails at boot rather than
         # on the first ask.
         def refuse_unanswerable_queries!
-          @declared.bluebooks.each_value do |chapter|
-            chapter.aggregates.each do |aggregate|
-              refuse_misbound_queries!(chapter, aggregate)
+          @declared.bluebooks.each_value do |declaration|
+            declaration.aggregates.each do |aggregate|
+              refuse_misbound_queries!(declaration, aggregate)
 
-              aggregate.queries.each { |query| refuse_answer_paths!(chapter, aggregate, query) }
+              aggregate.queries.each { |query| refuse_answer_paths!(declaration, aggregate, query) }
               aggregate.entities.each do |entity|
-                entity.queries.each { |query| refuse_entity_answer_path!(chapter, aggregate, entity, query) }
+                entity.queries.each { |query| refuse_entity_answer_path!(declaration, aggregate, entity, query) }
               end
             end
           end
@@ -28,19 +28,28 @@ module Hecks
 
         # Counts the query's answer paths (the bindings, plus the derived answer when it exists)
         # and refuses any count but one, then checks a bound query's shape and adapter.
-        def refuse_answer_paths!(chapter, aggregate, query)
-          where  = "#{chapter.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
+        def refuse_answer_paths!(declaration, aggregate, query)
+          where  = "#{declaration.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
           ports  = aggregate.query_bindings(query.hecks_name)
           paths  = ports.size + (derivable?(query) ? 1 : 0)
 
-          if paths > 1
-            raise WiringError, "#{where} has two answer paths: #{answer_path_names(query, ports)} — " \
-                               "a query is answered from records or from outside, not both"
-          end
-          return check_bound_query!(chapter, aggregate, query, ports.first) if ports.any?
+          refuse_two_answer_paths!(where, query, ports) if paths > 1
+          return check_bound_query!(declaration, aggregate, query, ports.first) if ports.any?
           return if paths == 1
 
-          raise WiringError, no_answer_path_message(chapter, aggregate, query, where)
+          check_unbound_query!(declaration, aggregate, query, where)
+        end
+
+        # A query neither its records nor a hecksagon answers is a plugin's, or has no answer path.
+        def check_unbound_query!(declaration, aggregate, query, where)
+          return check_plugin_query!(aggregate, query, where) if plugin_for(query, where)
+
+          raise WiringError, no_answer_path_message(declaration, aggregate, query, where)
+        end
+
+        def refuse_two_answer_paths!(where, query, ports)
+          raise WiringError, "#{where} has two answer paths: #{answer_path_names(query, ports)} — " \
+                             "a query is answered from records or from outside, not both"
         end
 
         # A query that returns nothing and says something about which records it wants, or wants
@@ -58,10 +67,10 @@ module Hecks
           names.join(" and ")
         end
 
-        def no_answer_path_message(chapter, aggregate, query, where)
+        def no_answer_path_message(declaration, aggregate, query, where)
           if query.returns
             "#{where} has no answer path: it returns #{query.returns}, which only an adapter can " \
-              "answer, and no hecksagon port binds it. Bind it: `#{chapter.name}::#{aggregate.hecks_name}" \
+              "answer, and no hecksagon port binds it. Bind it: `#{declaration.name}::#{aggregate.hecks_name}" \
               ".port \"Port\" do answers_query \"#{query.hecks_name}\" end`."
           else
             "#{where} has no answer path: it declares no where and returns nothing, and no hecksagon " \
@@ -72,8 +81,8 @@ module Hecks
 
         # Checks what a binding needs to be answerable: a returned value object the aggregate
         # declares, and one adapter behind the port that implements the query's method.
-        def check_bound_query!(chapter, aggregate, query, port)
-          where = "#{chapter.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
+        def check_bound_query!(declaration, aggregate, query, port)
+          where = "#{declaration.name}::#{aggregate.hecks_name}.#{query.hecks_name}"
           refuse_unanswerable_binding!(where, port, query)
           refuse_authorized_binding!(where, port, query)
           unless Value.value_object_for(aggregate, query.returns_name)
@@ -107,8 +116,8 @@ module Hecks
 
         # An entity's query reads the elements of its aggregate's list, and nothing outside can
         # be bound to one, so declaring a value object to return leaves it no answer.
-        def refuse_entity_answer_path!(chapter, aggregate, entity, query)
-          where = "#{chapter.name}::#{aggregate.hecks_name}.#{entity.hecks_name}.#{query.hecks_name}"
+        def refuse_entity_answer_path!(declaration, aggregate, entity, query)
+          where = "#{declaration.name}::#{aggregate.hecks_name}.#{entity.hecks_name}.#{query.hecks_name}"
           if query.returns
             raise WiringError, "#{where} has no answer path: it returns #{query.returns}, but " \
                                "only an aggregate's queries can be bound to a port"
@@ -121,11 +130,11 @@ module Hecks
 
         # Refuses a binding that names a query its aggregate does not declare, or names one twice
         # on a single port (the DSL already refuses that, so this guards a hand-built port).
-        def refuse_misbound_queries!(chapter, aggregate)
+        def refuse_misbound_queries!(declaration, aggregate)
           aggregate.ports.each do |port|
             names = port.answered_queries.map(&:name)
             names.each do |name|
-              where = "#{chapter.name}::#{aggregate.hecks_name}.#{name}"
+              where = "#{declaration.name}::#{aggregate.hecks_name}.#{name}"
               unless aggregate.query(name)
                 raise WiringError, "the #{port.name} port binds #{where}, which the aggregate does not declare"
               end

data/lib/hecks/runtime/registry/runtime_state.rb

@@ -4,15 +4,16 @@ module Hecks
       # What dispatching produces: the event log, the reaction and saga logs, and the saga
       # instances in flight.
       #
-      # `saga_dispatch_log` and `policy_dispatch_log` are Ruby-only; unlike `saga_log` and
+      # `saga_dispatch_log`, `policy_dispatch_log` and `cross_domain_log` are Ruby-only; unlike
+      # `saga_log` and
       # `reaction_log` (ported byte-for-byte to rust/src/kernel/orchestrate.rs, per
       # spec/rust_conformance_spec.rb), they carry the raw dispatch-binding inputs
       # Properties.dispatch_binding_fidelity re-derives.
       RuntimeState = Struct.new(:event_log, :reaction_log, :reaction_events, :saga_log,
-                                :saga_dispatch_log, :policy_dispatch_log, :saga_instances) do
+                                :saga_dispatch_log, :policy_dispatch_log, :cross_domain_log, :saga_instances) do
         # @return [RuntimeState] every log empty and no saga instances
         def self.fresh
-          new([], [], {}.compare_by_identity, [], [], [], Hash.new { |hash, key| hash[key] = {} })
+          new([], [], {}.compare_by_identity, [], [], [], [], Hash.new { |hash, key| hash[key] = {} })
         end
 
         # Empties every log and drops every saga instance.

data/lib/hecks/runtime/registry/saga_persistence.rb

@@ -24,7 +24,7 @@ module Hecks
               pending = memory.delete(SAGA_PENDING_DISPATCH_KEY)
               @state.saga_instances[process_manager][correlation] =
                 { state: state, memory: memory, completed_compensations: completed_compensations || [] }
-              warn_stalled_saga(domain, process_manager, correlation, state, pending) if pending
+              stall_saga(process_manager, correlation, pending) if pending
             end
           end
           self
@@ -32,21 +32,12 @@ module Hecks
 
         private
 
-        # A pending dispatch marker left by a crash: state was checkpointed but the dispatch
-        # cascade it justifies may never have run. Surfaced as a warning, never auto-redriven.
-        # rubocop:disable-next Hecks/ThreadSharedIvarMutation -- same
-        def warn_stalled_saga(domain, process_manager, correlation, state, pending)
-          # Heki's each_saga only symbolizes memory's top-level keys, not nested values;
-          # Postgres/SQLite/D1 already return symbol keys. Normalize here once for all adapters.
-          pending    = pending.transform_keys(&:to_sym)
-          dispatches = Array(pending[:dispatches]).join(", ")
-          warn "[hecks] #{domain} rehydrated #{process_manager} instance #{correlation.inspect} in state " \
-               "#{state.inspect} with a dispatch left pending from before the last crash/restart — " \
-               "#{dispatches} (on #{pending[:on].inspect}, #{pending[:from].inspect} -> #{pending[:to].inspect}) " \
-               "may or may not have actually run. hecks does not auto-redrive a pending saga dispatch (that " \
-               "needs idempotent delivery, which this pipeline doesn't have yet); reconcile this instance by hand."
-          @state.saga_log << { process_manager: process_manager, instance: correlation, rehydrated_stalled: true,
-                               state: state, pending: pending }
+        # A pending marker left by a crash: state was checkpointed but the leg's dispatches did
+        # not all settle. Held on the instance for `SagaInterpreter#redrive_stalled`, which runs
+        # once the dispatcher exists; Heki's each_saga only symbolizes memory's top-level keys,
+        # so the marker is normalized here once for all adapters.
+        def stall_saga(process_manager, correlation, pending)
+          @state.saga_instances[process_manager][correlation][:stalled] = pending.transform_keys(&:to_sym)
         end
 
         def resolve_saga_persistence(domain)

data/lib/hecks/runtime/registry/verification.rb

@@ -1,8 +1,10 @@
 require_relative "../../bluebook/hecksagon"
+require_relative "../adapter_namespace"
 require_relative "hecksagon_rules"
 require_relative "ask_verification"
 require_relative "query_verification"
-require_relative "chapter_verification"
+require_relative "plugin_query_verification"
+require_relative "bluebook_verification"
 require_relative "durability_warnings"
 
 module Hecks
@@ -14,7 +16,8 @@ module Hecks
         include HecksagonRules
         include AskVerification
         include QueryVerification
-        include ChapterVerification
+        include PluginQueryVerification
+        include BluebookVerification
         include DurabilityWarnings
 
         # Runs every wiring check against this registry's loaded bluebooks, hecksagons, ports
@@ -24,7 +27,7 @@ module Hecks
           verify_world_defaults!
           verify_singleton_port_answers!
           refuse_cross_package_bluebook_merge!
-          refuse_reserved_chapter_names!
+          refuse_reserved_bluebook_names!
           refuse_membership_without_identity!
           refuse_unresolved_ports!
           refuse_unanswerable_queries!
@@ -116,7 +119,7 @@ module Hecks
         end
 
         def adapter_class(name)
-          Adapters.const_get(name)
+          AdapterNamespace.resolve(name)
         rescue NameError
           raise WiringError, "no Ruby adapter implementation for #{name.inspect} " \
                              "(expected Hecks::Adapters::#{name})"
@@ -125,7 +128,7 @@ module Hecks
         private
 
         # One hecksagon's checks: its roles, attachments and ACL, every bind, and the durability
-        # warnings for its chapter.
+        # warnings for its bluebook.
         def verify_hecksagon!(hecksagon)
           refuse_ungoverned_roles!(hecksagon)
           refuse_unknown_driving!(hecksagon)
@@ -134,6 +137,7 @@ module Hecks
           hecksagon.binds.each { |bind| verify_bind!(hecksagon, bind) }
           warn_undurable_sagas!(hecksagon)
           warn_undurable_outbox!(hecksagon)
+          warn_unwired_persistence!(hecksagon)
         end
 
         def verify_bind!(hecksagon, bind)

data/lib/hecks/runtime/registry/world_defaults.rb

@@ -1,11 +1,14 @@
 module Hecks
   module Runtime
     class Registry
-      # The `default_database`/`default_adapter` a `.world` declares once for every chapter;
+      # The `default_database`/`default_adapter` a `.world` declares once for every bluebook;
       # resolved most-specific-first (own bind, own world, project world) and never written back.
       module WorldDefaults
+        # A `{name}` or `{storage_name}` placeholder in a default, capturing the aggregate reader.
+        AGGREGATE_PLACEHOLDER = /\{(name|storage_name)\}/
+
         # The default database only reaches a persistence bind whose adapter declares a
-        # `database` field; a `database` the chapter's own settings name always wins.
+        # `database` field; a `database` the bluebook's own settings name always wins.
         def binding_settings(domain, verb, adapter)
           declared = world(domain)&.for_binding(verb, adapter) || {}
           database = default_database_for(domain)
@@ -56,15 +59,15 @@ module Hecks
         def fill_placeholders(value, aggregate)
           return value unless value.is_a?(String)
 
-          value.gsub(/\{(name|storage_name)\}/) { aggregate.public_send(Regexp.last_match(1)) }
+          value.gsub(AGGREGATE_PLACEHOLDER) { aggregate.public_send(Regexp.last_match(1)) }
         end
 
-        # The chapter's own world answers first; the project's world fills the gap.
+        # The bluebook's own world answers first; the project's world fills the gap.
         def world_default(domain, field)
           world(domain)&.public_send(field) || project_world&.public_send(field)
         end
 
-        # The world of the first chapter this registry loaded — the target of a boot, ahead of
+        # The world of the first bluebook this registry loaded — the target of a boot, ahead of
         # any framework member it attaches.
         def project_world = world(@declared.bluebooks.keys.first || @declared.worlds.keys.first)
 

data/lib/hecks/runtime/registry.rb

@@ -7,6 +7,8 @@ require_relative "registry/read_repository"
 require_relative "registry/verification"
 require_relative "registry/saga_persistence"
 require_relative "registry/world_defaults"
+require_relative "registry/context_maps"
+require_relative "registry/adapter_capabilities"
 require_relative "outbox"
 require_relative "../naming"
 
@@ -24,8 +26,10 @@ module Hecks
       include Verification
       include SagaPersistence
       include WorldDefaults
+      include AdapterCapabilities
       include Providers
       include Merging
+      include ContextMaps
       include ReadRepository
 
       # The thread-local key under which open reaction collections are kept.
@@ -38,7 +42,7 @@ module Hecks
       def_delegators :@declared, :bluebooks, :hecksagons, :ports, :adapters, :worlds, :translations,
                      :bluebook_sources, :pending_privacy_markings
       def_delegators :@state, :event_log, :reaction_log, :saga_log, :saga_instances,
-                     :saga_dispatch_log, :policy_dispatch_log
+                     :saga_dispatch_log, :policy_dispatch_log, :cross_domain_log
 
       # @param root [String, nil] the booting project's root directory, the base
       #   a shared ports/adapters root and a `.world`'s own relative paths resolve
@@ -74,10 +78,10 @@ module Hecks
       # a Dispatcher attaches the interpreters that let it deliver (see Runtime::Outbox).
       attr_reader :outbox
 
-      # Stays open for the life of the registry, keyed by chapter name, so a chapter split
+      # Stays open for the life of the registry, keyed by bluebook name, so a bluebook split
       # across several files (language/bluebook/*.bluebook) accumulates into one builder.
       #
-      # @param name [String, Symbol] the chapter name the builder accumulates
+      # @param name [String, Symbol] the bluebook name the builder accumulates
       #   declarations for
       # @yield the block that mints a fresh builder, called only the first time
       #   `name` is asked for
@@ -92,30 +96,30 @@ module Hecks
       # .bluebook/.hecksagon/.world file is being Kernel.loaded, strictly during Loader.boot,
       # before dispatcher_for hands this registry to a live, multi-threaded caller.
       # rubocop:disable Hecks/ThreadSharedIvarMutation
-      # Registers a loaded chapter, keyed by its own declared name.
+      # Registers a loaded bluebook, keyed by its own declared name.
       #
-      # @param item [Bluebook::Chapter] the loaded, judged chapter
-      # @return [Bluebook::Chapter] `item`, unchanged
+      # @param item [Bluebook::Declaration] the loaded, judged bluebook
+      # @return [Bluebook::Declaration] `item`, unchanged
       def add_bluebook(item) = @declared.bluebooks[item.name] = item
 
-      # Drops a chapter and the open builder and source record that accumulated it, so the
-      # chapter can be loaded again from nothing.
+      # Drops a bluebook and the open builder and source record that accumulated it, so the
+      # bluebook can be loaded again from nothing.
       #
-      # @param name [String, Symbol] the chapter name to forget
+      # @param name [String, Symbol] the bluebook name to forget
       # @return [void]
-      def forget_chapter(name)
+      def forget_bluebook(name)
         @declared.bluebooks.delete(name.to_s)
         @declared.bluebook_builders.delete(name.to_s)
         @declared.bluebook_sources.delete(name.to_s)
       end
 
-      # Tracks which .bluebook file(s) contributed to a chapter name (a boot-time loading
+      # Tracks which .bluebook file(s) contributed to a bluebook name (a boot-time loading
       # fact, never Rust-mirrored) so refuse_cross_package_bluebook_merge! can catch two
       # unrelated packages accumulating into the same name by coincidence.
       #
-      # @param name [String, Symbol] the chapter name the file contributed to
+      # @param name [String, Symbol] the bluebook name the file contributed to
       # @param path [String] the `.bluebook` file that declared it
-      # @return [Array<String>] every path recorded for that chapter, `path` last
+      # @return [Array<String>] every path recorded for that bluebook, `path` last
       def record_bluebook_source(name, path)
         (@declared.bluebook_sources[name.to_s] ||= []) << path
       end
@@ -133,21 +137,21 @@ module Hecks
 
       # Marks `name` as a bounded context — called automatically by `attaches`, and by
       # `add_hecksagon` when the block itself declared `bounded`.
-      # A bounded chapter wraps in its own module (no Object shortcut)
+      # A bounded bluebook wraps in its own module (no Object shortcut)
       # and must have a `translates` ACL or boot refuses.
       #
-      # @param name [String, Symbol] the chapter name to mark bounded
+      # @param name [String, Symbol] the bluebook name to mark bounded
       # @return [void]
       def mark_bounded(name)
-        @declared.bounded_chapters[name.to_s] = true
+        @declared.bounded_bluebooks[name.to_s] = true
       end
 
       # Says whether `name` is a bounded context — attached via `attaches`, or a consumer
-      # chapter that declared `bounded` on its own hecksagon.
+      # bluebook that declared `bounded` on its own hecksagon.
       #
-      # @param name [String, Symbol] the chapter name to check
-      # @return [Boolean] whether that chapter is bounded
-      def bounded?(name) = @declared.bounded_chapters[name.to_s] ? true : false
+      # @param name [String, Symbol] the bluebook name to check
+      # @return [Boolean] whether that bluebook is bounded
+      def bounded?(name) = @declared.bounded_bluebooks[name.to_s] ? true : false
 
       # Registers a loaded port, keyed by its own declared name.
       #
@@ -161,6 +165,14 @@ module Hecks
       # @return [Bluebook::Adapter] `item`, unchanged
       def add_adapter(item) = @declared.adapters[item.name] = item
 
+      # Finds the plugin adapters that say they answer a query.
+      #
+      # @param question [String] the qualified query, such as `"Calendar::Event.Occurrences"`
+      # @return [Array<Bluebook::Adapter>] every loaded plugin naming it, by name
+      def plugins_answering(question)
+        adapters.values.select { |adapter| adapter.answered_queries.include?(question) }.sort_by(&:name)
+      end
+
       # Merges into any world already registered for the domain, the same shape as
       # add_hecksagon. Settings merge shallow, keyed by verb (and "verb:adapter"); an
       # overlay key wins over the base's same key, and a key only the base declares
@@ -203,10 +215,10 @@ module Hecks
       # for an old checkout only. Stood up eagerly; plain readers, not memoizers.
       def_delegators :@declared, :resolved_eras, :superseded_eras
 
-      # Finds a loaded chapter by name.
+      # Finds a loaded bluebook by name.
       #
-      # @param name [String, Symbol] the chapter's declared name
-      # @return [Bluebook::Chapter, nil] the chapter, or nil if none is registered
+      # @param name [String, Symbol] the bluebook's declared name
+      # @return [Bluebook::Declaration, nil] the bluebook, or nil if none is registered
       #   under `name`
       def bluebook(name)  = @declared.bluebooks[name.to_s]
 
@@ -224,10 +236,23 @@ module Hecks
       #   registered under `name`
       def world(name)     = @declared.worlds[name.to_s]
 
-      # Every verb every loaded chapter declares, sorted.
+      # The first bluebook loaded: a one-domain boot's own bluebook.
+      #
+      # @return [Bluebook::Declaration, nil] the first loaded bluebook, or nil when none loaded
+      def first_bluebook = @declared.bluebooks.values.first
+
+      # The name of the first bluebook loaded: a one-domain boot's own domain.
+      #
+      # @return [String, nil] the name, or nil when none loaded
+      def first_domain_name = first_bluebook&.name
+
+      # Every verb every loaded bluebook declares, sorted.
       #
-      # @return [Array<String>] every declared verb, across every loaded chapter
-      def verbs = @declared.bluebooks.values.flat_map(&:verbs).sort
+      # @return [Array<String>] every declared verb, across every loaded bluebook
+      def verbs
+        declarations = @declared.bluebooks.values
+        declarations.flat_map(&:verbs).sort
+      end
 
       # Resolves and memoizes `aggregate`'s authoritative repository.
       #
@@ -295,7 +320,7 @@ module Hecks
         @state.clear
         @repositories = {}
         @projection_repositories = {}
-        @outbox.log.clear
+        @outbox.clear_log
         rehydrate_sagas!
         self
       end