hecks 5.0.0 → 7.0.0

data/lib/hecks/runtime/registry/{chapter_verification.rb → bluebook_verification.rb}

@@ -1,50 +1,50 @@
 module Hecks
   module Runtime
     class Registry
-      # Checks the chapters a boot loaded: no reserved name from outside the gem, and no two
+      # Checks the bluebooks a boot loaded: no reserved name from outside the gem, and no two
       # unrelated packages sharing a name. Mixed into {Verification}.
-      module ChapterVerification
-        # The directory holding the gem's own Hecks chapter, the only place a chapter named
+      module BluebookVerification
+        # The directory holding the gem's own Hecks bluebook, the only place a bluebook named
         # `Hecks` may be declared from.
-        GEM_CHAPTER_DIR = File.expand_path("../../hecks", __dir__).freeze
+        GEM_BLUEBOOK_DIR = File.expand_path("../../hecks", __dir__).freeze
 
-        # The chapter names only the gem itself may declare (ADR 0080, section 9).
-        RESERVED_CHAPTER_NAMES = %w[Hecks].freeze
+        # The bluebook names only the gem itself may declare (ADR 0080, section 9).
+        RESERVED_BLUEBOOK_NAMES = %w[Hecks].freeze
 
         private
 
-        # Refuses a chapter whose name is reserved unless every file that declared it sits under
-        # the gem's own chapter directory. A rename is the only fix, so the message says so.
+        # Refuses a bluebook whose name is reserved unless every file that declared it sits under
+        # the gem's own bluebook directory. A rename is the only fix, so the message says so.
         #
         # @raise [WiringError] naming the reserved word and the offending file(s)
-        def refuse_reserved_chapter_names!
-          RESERVED_CHAPTER_NAMES.each do |reserved|
+        def refuse_reserved_bluebook_names!
+          RESERVED_BLUEBOOK_NAMES.each do |reserved|
             next unless @declared.bluebooks.key?(reserved)
 
             sources = Array(@declared.bluebook_sources[reserved]).compact
-            foreign = sources.reject { |path| gem_chapter_source?(path) }
+            foreign = sources.reject { |path| gem_bluebook_source?(path) }
             next if foreign.empty? && !sources.empty?
 
-            raise WiringError, reserved_chapter_message(reserved, foreign)
+            raise WiringError, reserved_bluebook_message(reserved, foreign)
           end
         end
 
-        def reserved_chapter_message(reserved, foreign)
+        def reserved_bluebook_message(reserved, foreign)
           where = foreign.empty? ? "" : " (declared in #{foreign.join(", ")})"
-          "a chapter named #{reserved.inspect} is refused: #{reserved.inspect} is a reserved " \
-            "word, the name of the gem's own chapter, and only the gem may declare it#{where}. " \
-            "Rename the chapter (for example to your app's name) in its " \
+          "a bluebook named #{reserved.inspect} is refused: #{reserved.inspect} is a reserved " \
+            "word, the name of the gem's own bluebook, and only the gem may declare it#{where}. " \
+            "Rename the bluebook (for example to your app's name) in its " \
             "`Hecks.bluebook #{reserved.inspect}` line and in its hecksagon."
         end
 
-        # Whether `path` is a file of the gem's own chapter directory.
-        def gem_chapter_source?(path)
-          File.expand_path(path.to_s).start_with?("#{GEM_CHAPTER_DIR}/")
+        # Whether `path` is a file of the gem's own bluebook directory.
+        def gem_bluebook_source?(path)
+          File.expand_path(path.to_s).start_with?("#{GEM_BLUEBOOK_DIR}/")
         end
 
-        # Two packages can share a chapter name by coincidence (a stale vendored
+        # Two packages can share a bluebook name by coincidence (a stale vendored
         # fork of Governance/Identity/Deploy still on an app's load paths).
-        # Intentional accumulation (several files declaring the same chapter on
+        # Intentional accumulation (several files declaring the same bluebook on
         # purpose) is distinguished by package root, not file identity, and is left
         # untouched here — checked once, after every file has loaded.
         def refuse_cross_package_bluebook_merge!
@@ -54,8 +54,8 @@ module Hecks
 
             raise WiringError,
                   "#{name.inspect} is declared by more than one package: #{roots.join(" and ")} — " \
-                  "these are two unrelated sources sharing a chapter name by coincidence, not one " \
-                  "domain split across files, and merging their declarations into one chapter is " \
+                  "these are two unrelated sources sharing a bluebook name by coincidence, not one " \
+                  "domain split across files, and merging their declarations into one bluebook is " \
                   "almost certainly a stale/vendored copy left on the load path (paths: " \
                   "#{paths.join(", ")})"
           end

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

@@ -0,0 +1,26 @@
+module Hecks
+  module Runtime
+    class Registry
+      # The context maps a boot loaded from `.contextmap` files, one per system.
+      module ContextMaps
+        # Boot-time-only, single-threaded: it runs from Hecks.collect while a `.contextmap` file is
+        # being Kernel.loaded, before the registry reaches a live, multi-threaded caller.
+        # Registers a declared context map under its system's name, a later one of the same name
+        # replacing the earlier (a map is one declaration, not a layered overlay).
+        #
+        # @param item [Bluebook::ContextMap] the declared map
+        # @return [Bluebook::ContextMap] the map
+        def add_context_map(item) = @declared.store(:context_maps, item.name, item)
+
+        # Finds a system's declared context map by name.
+        #
+        # @param name [String, Symbol] the system the map covers
+        # @return [Bluebook::ContextMap, nil] the map, or nil if none is registered under `name`
+        def context_map(name) = @declared.context_maps[name.to_s]
+
+        # @return [Array<Bluebook::ContextMap>] every declared context map
+        def context_maps = @declared.context_maps.values
+      end
+    end
+  end
+end

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

@@ -1,16 +1,48 @@
 module Hecks
   module Runtime
     class Registry
-      # What a boot gathers while the `.bluebook`, `.hecksagon` and `.world` files load: the
-      # chapters and their builders, the wiring, ports, adapters, worlds, translations, the
-      # eras the boot gate resolved, and the privacy markings still to be dispatched.
-      Declarations = Struct.new(:bluebooks, :bluebook_sources, :hecksagons, :bounded_chapters, :ports,
+      # What a boot gathers while the `.bluebook`, `.hecksagon`, `.world` and `.contextmap` files
+      # load: the bluebooks and their builders, the wiring, ports, adapters, worlds, translations,
+      # context maps, the eras the boot gate resolved, the domains whose booted shape no era holds
+      # yet, the domains whose unheld shape one recorded move leads to, and the privacy markings
+      # still to be dispatched.
+      Declarations = Struct.new(:bluebooks, :bluebook_sources, :hecksagons, :bounded_bluebooks, :ports,
                                 :adapters, :worlds, :translations, :bluebook_builders,
-                                :pending_privacy_markings, :resolved_eras, :superseded_eras) do
+                                :pending_privacy_markings, :resolved_eras, :superseded_eras,
+                                :context_maps, :unminted_eras, :behind_eras) do
         # @return [Declarations] every collection empty
         def self.empty
-          new({}, {}, {}, {}, {}, {}, {}, [], {}, [], {}, {})
+          new({}, {}, {}, {}, {}, {}, {}, [], {}, [], {}, {}, {}, {}, {})
         end
+
+        # Stores a value under a key in a keyed collection, and answers the value.
+        #
+        # @param collection [Symbol] the member holding the keyed collection
+        # @param key [Object] the key
+        # @param value [Object] the value to store
+        # @return [Object] `value`
+        def store(collection, key, value) = self[collection][key] = value
+
+        # Removes a key from a keyed collection.
+        #
+        # @param collection [Symbol] the member holding the keyed collection
+        # @param key [Object] the key to remove
+        # @return [Object, nil] the value removed, or nil when the key was absent
+        def remove(collection, key) = self[collection].delete(key)
+
+        # Appends a value to a list collection.
+        #
+        # @param collection [Symbol] the member holding the list
+        # @param value [Object] the value to append
+        # @return [Array] the list, `value` last
+        def append(collection, value) = self[collection] << value
+
+        # Records that a `.bluebook` file contributed to a bluebook name.
+        #
+        # @param name [String] the bluebook name
+        # @param path [String] the file that declared it
+        # @return [Array<String>] every path recorded for that name, `path` last
+        def record_source(name, path) = (bluebook_sources[name] ||= []) << path
       end
     end
   end

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

@@ -44,10 +44,26 @@ module Hecks
 
         # The name of every event the aggregates' commands and port operations announce.
         def emitted_event_names(bluebook_ir)
-          bluebook_ir.aggregates.flat_map do |aggregate|
+          names = bluebook_ir.aggregates.flat_map do |aggregate|
             aggregate.commands.flat_map(&:emits) +
               aggregate.ports.flat_map { |port| port.operations.flat_map { |op| [*op.emits, op.answers, op.refuses] } }
-          end.compact.map(&:to_s)
+          end
+          names.compact.map(&:to_s)
+        end
+
+        # A hecksagon that never mentions persistence wires none, so its aggregates are in Memory:
+        # the default, and nothing to say. The one case worth saying is a world that names a store
+        # (a database or persistence settings) that no bind uses, which is a forgotten decision.
+        def warn_unwired_persistence!(hecksagon)
+          domain = hecksagon.domain
+          return unless Ports::Persistence::BindingPolicy.unwired?(self, domain) && store_named?(domain)
+
+          warn "[hecks] #{domain} names a store but binds no persistence, so its aggregates are in Memory " \
+               "and keep nothing across a restart. Add `persisted_by \"<adapter>\"` to its hecksagon."
+        end
+
+        def store_named?(domain)
+          !default_database_for(domain).nil? || !world(domain)&.for_verb("persistence").to_h.empty?
         end
 
         # A warning, not a refusal: running sagas on a store with no `save_saga` is

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

@@ -2,7 +2,7 @@ module Hecks
   module Runtime
     class Registry
       # The checks a loaded hecksagon owes: roles need an authorization provider, attachments need
-      # their sibling hecksagon, a bounded chapter needs its ACL, and a chapter's declared
+      # their sibling hecksagon, a bounded bluebook needs its ACL, and a bluebook's declared
       # capabilities need what they name. Mixed into {Verification}.
       module HecksagonRules
         private
@@ -43,61 +43,78 @@ module Hecks
         # on that sibling too, or cross-context field mapping has nowhere to be written.
         def refuse_unwired_attachments!(hecksagon)
           hecksagon.attachments.each do |attachment|
-            next if hecksagon(attachment.chapter_name)
+            next if hecksagon(attachment.declaration_name)
+            next if contextmap_declares?(hecksagon, attachment)
 
             raise WiringError, unwired_attachment_message(hecksagon, attachment)
           end
         end
 
+        # A gem bluebook that the system's `.contextmap` names as a context needs no sibling
+        # hecksagon: its wiring is the attach itself. A vendored package still needs one, since
+        # its persistence and `translates` ACL can only be written there.
+        #
+        # @return [Boolean] true if the system's context map names the attached gem bluebook
+        def contextmap_declares?(hecksagon, attachment)
+          return false if attachment.vendor?
+
+          map = context_map(hecksagon.domain)
+          !map.nil? && map.context_names.include?(attachment.declaration_name.to_s)
+        end
+
         def unwired_attachment_message(hecksagon, attachment)
-          chapter_name = attachment.chapter_name
-          what = attachment.vendor? ? "vendored bluebook #{attachment.name.inspect}" : chapter_name.inspect
+          declaration_name = attachment.declaration_name
+          what = attachment.vendor? ? "vendored bluebook #{attachment.name.inspect}" : declaration_name.inspect
           "#{hecksagon.domain} attaches #{what} " \
-            "(bounded context #{chapter_name}) but never declared " \
-            "Hecks.hecksagon #{chapter_name.inspect} — put that sibling " \
-            "(and any `translates` ACL) in context_map.hecksagon; " \
+            "(bounded context #{declaration_name}) but never declared " \
+            "Hecks.hecksagon #{declaration_name.inspect} — put that sibling " \
+            "(and any `translates` ACL) in context_map.hecksagon, or name the context in " \
+            "#{hecksagon.domain}'s `.contextmap` (gem bluebooks only); " \
             "same-name blocks merge, order-independent."
         end
 
-        # An explicit `bounded` mark on a consumer chapter always needs an ACL. `attaches`
-        # marks the attached chapter bounded and requires the sibling
+        # An explicit `bounded` mark on a consumer bluebook always needs an ACL. `attaches`
+        # marks the attached bluebook bounded and requires the sibling
         # hecksagon above; they don't require a `translates` on it unless the consumer also
         # wrote `bounded`.
         # rust/host Google sign-in reads ir.json's membership/identity keys, never a deploy-time
         # env var; Membership without Identity means provision cannot Register/Link an identity.
         def refuse_membership_without_identity!
-          return unless @declared.bluebooks.values.any? { |chapter| chapter.provides?(Bluebook::Capabilities::MEMBERSHIP) }
-          return if @declared.bluebooks.values.any? { |chapter| chapter.provides?(Bluebook::Capabilities::IDENTITY) }
+          unless @declared.bluebooks.values.any? { |declaration| declaration.provides?(Bluebook::Capabilities::MEMBERSHIP) }
+            return
+          end
+          return if @declared.bluebooks.values.any? { |declaration| declaration.provides?(Bluebook::Capabilities::IDENTITY) }
 
           raise WiringError,
-                "a chapter that provides \"membership\" is loaded, but none provides " \
+                "a bluebook that provides \"membership\" is loaded, but none provides " \
                 "\"identity\" — rust/host Google sign-in cannot register or link an " \
                 "identity from the hecksagon/world. Attach Identity (`attaches " \
                 "\"Identity\"` plus a sibling Hecks.hecksagon \"Identity\") so the " \
                 "identity verbs are exported onto ir.json, not guessed at deploy."
         end
 
-        # A hecksagon attaches after its chapter builds, so this is the first point a
-        # declared `:port_operation` capability can be checked against it.
+        # A hecksagon attaches after its bluebook builds, so this is the first point a
+        # `provides` key that names a port operation can be checked against it.
         def refuse_unresolved_port_operations!
-          @declared.bluebooks.each_value do |chapter|
-            chapter.provides.each { |row| refuse_unresolved_port_operation!(chapter, row) }
+          @declared.bluebooks.each_value do |declaration|
+            declaration.provides.each { |row| refuse_unresolved_port_operation!(declaration, row) }
           end
         end
 
-        def refuse_unresolved_port_operation!(chapter, row)
-          return unless Bluebook::Capabilities::CONTRACTS.dig(row.capability, row.key.to_sym) == :port_operation
-          return if port_operation_declared?(chapter, row.verb)
+        def refuse_unresolved_port_operation!(declaration, row)
+          return if Bluebook::Capabilities.language_defined?(row.capability)
+          return unless Bluebook::Capabilities.kinds_of(declaration, row.verb) == [:port_operation]
+          return if port_operation_declared?(declaration, row.verb)
 
           raise WiringError,
-                "#{chapter.name} provides #{row.capability.inspect} #{row.key}: #{row.verb.inspect}, " \
+                "#{declaration.name} provides #{row.capability.inspect} #{row.key}: #{row.verb.inspect}, " \
                 "but its hecksagon declares no such port operation — declare it with " \
-                "`#{chapter.name}::Aggregate.port \"Port\" do operation \"Operation\" ... end`."
+                "`#{declaration.name}::Aggregate.port \"Port\" do operation \"Operation\" ... end`."
         end
 
-        def port_operation_declared?(chapter, verb)
+        def port_operation_declared?(declaration, verb)
           aggregate_name, port_name, operation_name = verb.split(".", 3)
-          ports = chapter.aggregate(aggregate_name)&.ports || []
+          ports = declaration.aggregate(aggregate_name)&.ports || []
           ports.any? { |port| port.name == port_name && port.operations.any? { |op| op.hecks_name == operation_name } }
         end
 
@@ -107,7 +124,7 @@ module Hecks
 
           raise WiringError,
                 "#{hecksagon.domain} is marked bounded but never declared a " \
-                "translates ACL — a bounded chapter wraps in its own module and " \
+                "translates ACL — a bounded bluebook wraps in its own module and " \
                 "cross-context field mapping lives on the hecksagon, not in " \
                 "rust/host and not as a field list on the bluebook. " \
                 "Add `translates \"Name\" do on Foreign::Event; trigger Local::Command, " \
@@ -118,7 +135,7 @@ module Hecks
         # "authorization"` — never a hardcoded name.
         def authorization_attachment_hint
           providers = Framework.providers_of(Bluebook::Capabilities::AUTHORIZATION)
-          return "attaches a chapter that provides \"authorization\" (no framework member declares one)" if providers.empty?
+          return "attaches a bluebook that provides \"authorization\" (no framework member declares one)" if providers.empty?
 
           providers.map { |name| "attaches #{name.inspect}" }.join(" or ")
         end

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

@@ -0,0 +1,45 @@
+require_relative "../wasm_plugin"
+
+module Hecks
+  module Runtime
+    class Registry
+      # Holds a `returns` query no hecksagon binds to the one wasm plugin that says it answers it,
+      # and that plugin to a module that compiles. Mixed into {Verification}, beside
+      # {QueryVerification}, which asks it when a query has no other answer path.
+      module PluginQueryVerification
+        private
+
+        # The one plugin adapter that says it answers a query no hecksagon binds: a `returns` query
+        # is bound to it without a hecksagon line. Two plugins claiming one query is refused, since
+        # the runtime will not choose between them; a hecksagon binding still overrides either.
+        #
+        # @param query [Bluebook::Query] the declared query
+        # @param where [String] the qualified query, `"Bluebook::Aggregate.Query"`
+        # @return [Bluebook::Adapter, nil] the claiming plugin, or nil when none claims it
+        # @raise [WiringError] if more than one plugin claims the query
+        def plugin_for(query, where)
+          return nil unless query.returns
+
+          plugins = plugins_answering(where)
+          return plugins.first if plugins.size <= 1
+
+          raise WiringError, "#{plugins.size} plugins answer #{where} (#{plugins.map(&:name).join(", ")}) — " \
+                             "the runtime will not choose: bind one in the hecksagon"
+        end
+
+        # A plugin-answered query returns a value object the aggregate declares, and the plugin's
+        # module compiles, so a missing or broken module stops the boot rather than the first ask.
+        #
+        # @raise [WiringError] if the value object is undeclared or the module will not compile
+        def check_plugin_query!(aggregate, query, where)
+          unless Value.value_object_for(aggregate, query.returns_name)
+            raise WiringError, "#{where} returns #{query.returns_name}, but #{aggregate.hecks_name} " \
+                               "declares no such value object"
+          end
+
+          WasmPlugin.compile!(plugin_for(query, where))
+        end
+      end
+    end
+  end
+end

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