hecks 4.0.0 → 6.0.0

data/lib/hecks/projector/cli_projector/listing.rb

@@ -33,7 +33,8 @@ module Hecks
 
         # A lambda that renders one spec at an indent: its name padded to the widest, then its text.
         def row_formatter(named, &)
-          width = named.values.map(&:length).max.to_i
+          lengths = named.values.map(&:length)
+          width = lengths.max.to_i
           ->(spec, indent) { "#{indent}#{named[spec].ljust(width)}  #{yield(spec)}#{alias_note(spec)}" }
         end
 
@@ -53,20 +54,30 @@ module Hecks
 
         # The aggregate's own name as a heading: the prefix of every call to the lines under it.
         def heading(group)
-          "#{Naming.snake(group)}:"
+          "#{group}:"
+        end
+
+        # A launcher name in the bluebook's verb form: the aggregate as the bluebook spells it, then
+        # the rest of the name (`push_train.board` as `PushTrain.board`). A name that does not start
+        # with its aggregate, such as a short name a bluebook gave a command, is left as it is.
+        def verb_form(spec, name)
+          group = spec[:group]
+          return name unless group && name.start_with?("#{Naming.snake(group)}.")
+
+          "#{group}#{name.delete_prefix(Naming.snake(group))}"
         end
 
         # A spec's name as listed: under its aggregate's heading the aggregate prefix is left out.
-        # A command the chapter gives a short name (`mcp`) is listed by its real name, so the
+        # A command the bluebook gives a short name (`mcp`) is listed by its real name, so the
         # heading and the line still spell a call; `alias_note` says the short name.
         def entry_name(spec, grouped)
           name = label(spec, real: true)
           return name unless grouped && spec[:group]
 
-          name.delete_prefix("#{Naming.snake(spec[:group])}.")
+          name.delete_prefix("#{spec[:group]}.")
         end
 
-        # " (also: mcp!)" for a spec the chapter gave a short name, else nothing. A short name that
+        # " (also: mcp!)" for a spec the bluebook gave a short name, else nothing. A short name that
         # is only the command's own name (`init` for `launch.init`) is already in the line.
         def alias_note(spec)
           return "" if spec[:short_was].nil? || spec[:short_was].split(".").last == spec[:short]
@@ -74,10 +85,11 @@ module Hecks
           " (also: #{label(spec)})"
         end
 
-        # A command is written with the `!` that marks it; a query without one.
-        # With `real:`, a short name the chapter gave it gives way to the name it was given for.
+        # A command is written with the `!` that marks it; a query without one. Both are in the
+        # verb form. With `real:`, a short name the bluebook gave it gives way to the name it was
+        # given for.
         def label(spec, real: false)
-          name = real && spec.key?(:short_was) ? spec[:short_was] : spec[:short]
+          name = verb_form(spec, real && spec.key?(:short_was) ? spec[:short_was] : spec[:short])
           spec[:kind] == :command ? "#{name}!" : name
         end
 

data/lib/hecks/projector/cli_projector/option_specs.rb

@@ -72,7 +72,7 @@ module Hecks
         # The option of an attribute that references another record, which is given by its id.
         def reference_option(attribute)
           { path: attribute.name.to_s, type: "String", required: !attribute.optional?,
-            note: "id of a #{attribute.type.target_name}" }
+            note: "id of a #{attribute.target_name}" }
         end
 
         # A `list_of` scalar carries `list: true, words: true`: the launcher reads a comma-separated

data/lib/hecks/projector/cli_projector/query_specs.rb

@@ -43,7 +43,7 @@ module Hecks
         # The fields that are the aggregate's own bookkeeping: its identity and its
         # lifecycle status.
         def own_fields(aggregate)
-          Array(aggregate.identified_by).map(&:to_s) + [aggregate.lifecycle&.field.to_s]
+          Array(aggregate.identified_by).map(&:to_s) + [aggregate.lifecycle_field&.to_s]
         end
 
         # The spec of one query of an aggregate or of one of its entities.

data/lib/hecks/projector/cli_projector/usage.rb

@@ -5,6 +5,9 @@ module Hecks
     module CliProjector
       # The usage text of a projection: the command and query tables, or one command's help.
       module Usage
+        # The space after a sentence's closing full stop.
+        SENTENCE_BREAK = /(?<=\.)\s/
+
         # Renders the full command/question table, or one command's `--help` text when
         # `options[:command]` names one.
         def usage(bluebook, commands, questions, options)
@@ -21,7 +24,7 @@ module Hecks
           return unless only
 
           spec = help_spec(only, commands, questions, options[:ask])
-          command_help(program, spec[:short], spec, ask: options[:ask]) if spec
+          command_help(program, verb_form(spec, spec[:short]), spec, ask: options[:ask]) if spec
         end
 
         # `ask` picks the namespace when both hold the name; without it a
@@ -32,12 +35,12 @@ module Hecks
           pool[key] || questions[key]
         end
 
-        # The whole help: the two tables, the chapters, then the hints.
+        # The whole help: the two tables, the bluebooks, then the hints.
         def full_usage(bluebook, commands, questions, options, program)
           shown = [commands, questions].map { |specs| CliAudience.audience_specs(specs, options) }
           [usage_header(bluebook, program),
            tables(*shown, all: options[:all], notes: aggregate_notes(bluebook)),
-           CliAudience.chapter_lines(program, options[:chapters]),
+           CliAudience.bluebook_lines(program, options[:declarations]),
            usage_footer(program, shown, options, left_out(commands, questions, shown))].flatten(1).join("\n")
         end
 
@@ -46,7 +49,7 @@ module Hecks
           commands.size + questions.size - shown.sum(&:size)
         end
 
-        # The chapter's vision and the two ways to call it.
+        # The bluebook's vision and the two ways to call it.
         def usage_header(bluebook, program)
           ["#{bluebook.name} — #{bluebook.vision}", "",
            "  #{program} <command>! [name=value …]       do something",
@@ -96,15 +99,16 @@ module Hecks
                   .reject { |_, note| note.empty? }
         end
 
-        # An example call, `aggregate.command!`, from the first command, or `""` when there is none.
+        # An example call, `Aggregate.command!`, from the first command, or `""` when there is none.
         def example_qualified(commands)
-          name = commands.keys.first
-          name ? "#{name}!" : ""
+          spec = commands.values.first
+          spec ? label(spec, real: true) : ""
         end
 
         # The command table wants a query description's first sentence; `--help` prints all.
         def first_sentence(text)
-          text.to_s.split(/(?<=\.)\s/).first.to_s
+          sentences = text.to_s.split(SENTENCE_BREAK)
+          sentences.first.to_s
         end
       end
     end

data/lib/hecks/projector/cli_projector.rb

@@ -18,9 +18,9 @@ module Hecks
       module_function
 
       # Projects the command and question tables and the usage text. Commands and queries are
-      # separate namespaces (a chapter may declare both under one name); ask a query with `ask`.
+      # separate namespaces (a bluebook may declare both under one name); ask a query with `ask`.
       #
-      # @param bluebook [Bluebook::Chapter] the booted domain to project
+      # @param bluebook [Bluebook::Declaration] the booted domain to project
       # @param options [Hash{Symbol => Object}] `:program` (default `"hecks run"`) for the usage
       #   text; `:command` and `:ask` select one command's `--help` text; `:names` maps a launcher
       #   name to the command it stands for (`{ "mcp" => "serve_mcp" }`); `:mint_run_keys` makes a

data/lib/hecks/projector/docs_projector/behaviour.rb

@@ -67,7 +67,7 @@ module Hecks
 
         def command_argument_rows(arguments, holder)
           arguments.map do |attribute|
-            shape = attribute.reference? ? "id of a `#{attribute.type.target_name}`" : Attributes.shape_of(attribute, holder)
+            shape = attribute.reference? ? "id of a `#{attribute.target_name}`" : Attributes.shape_of(attribute, holder)
             ["`#{attribute.name}`", shape, attribute.optional? ? "" : "required"]
           end
         end
@@ -82,9 +82,10 @@ module Hecks
         def lifecycle_refusals(command, lifecycle)
           return [] unless lifecycle
 
-          froms = lifecycle.transitions.filter_map do |name, transition|
+          sources = lifecycle.transitions.filter_map do |name, transition|
             Array(transition.from) if name.to_s == command.hecks_name
-          end.flatten.uniq
+          end
+          froms = sources.flatten.uniq
           return [] if froms.empty?
 
           ["`#{lifecycle.field}` is anything other than #{froms.map { |f| "`#{f}`" }.join(" or ")}"]
@@ -93,7 +94,7 @@ module Hecks
         # The refusal for each referenced record that may not exist.
         def reference_refusals(command)
           command.attributes.select(&:reference?).map do |reference|
-            "no `#{reference.type.target_name}` exists for the id given as `#{reference.name}`"
+            "no `#{reference.target_name}` exists for the id given as `#{reference.name}`"
           end
         end
 

data/lib/hecks/projector/docs_projector/closing.rb

@@ -1,19 +1,19 @@
 module Hecks
   module Projector
     module DocsProjector
-      # The sections that close a chapter's document: the reactions its policies cause and the
+      # The sections that close a bluebook's document: the reactions its policies cause and the
       # sagas it runs.
       module Closing
         module_function
 
-        # The closing sections, or `nil` when the chapter has neither policies nor sagas.
+        # The closing sections, or `nil` when the bluebook has neither policies nor sagas.
         def call(bluebook, depth)
           out = reaction_lines(bluebook, depth)
           bluebook.process_managers.each { |saga| out.concat(saga_lines(saga, depth)) }
           out.empty? ? nil : out.join("\n")
         end
 
-        # The table of policies, or no lines when the chapter has none.
+        # The table of policies, or no lines when the bluebook has none.
         def reaction_lines(bluebook, depth)
           return [] if bluebook.policies.empty?
 

data/lib/hecks/projector/docs_projector.rb

@@ -9,11 +9,11 @@ module Hecks
 
       # Projects `bluebook` as Markdown usage documentation.
       #
-      # @param bluebook [Bluebook::Behaviour::Chapter] the chapter to document
+      # @param bluebook [Bluebook::Behaviour::Bluebook] the bluebook to document
       # @param options [Hash] optional inputs
       # @option options [Integer, String] :heading the top heading level; defaults to 1
       # @option options [String, Symbol, nil] :aggregate narrows the document to one
-      #   aggregate, omitting the chapter header and closing sections
+      #   aggregate, omitting the bluebook header and closing sections
       # @return [String] the document, ending in a newline
       # @raise [Runtime::NotFound] if `options[:aggregate]` names no declared aggregate
       def call(bluebook:, options: {})
@@ -21,7 +21,7 @@ module Hecks
         only  = options[:aggregate]
 
         out = []
-        out << chapter_header(bluebook, depth) unless only
+        out << bluebook_header(bluebook, depth) unless only
         out.concat(aggregate_sections(bluebook, only, depth))
         out << Closing.call(bluebook, depth + 1) unless only
         "#{out.compact.join("\n").rstrip}\n"
@@ -39,12 +39,17 @@ module Hecks
         bluebook.aggregates.find { |aggregate| aggregate.hecks_name == only.to_s } ||
           raise(Runtime::NotFound,
                 "#{bluebook.name} declares no aggregate named #{only.to_s.inspect} — " \
-                "it declares #{bluebook.aggregates.map(&:hecks_name).sort.join(", ")}")
+                "it declares #{declared_aggregates(bluebook)}")
+      end
+
+      def declared_aggregates(bluebook)
+        names = bluebook.aggregates.map(&:hecks_name)
+        names.sort.join(", ")
       end
 
       def h(depth, text) = "#{"#" * depth} #{text}"
 
-      def chapter_header(bluebook, depth)
+      def bluebook_header(bluebook, depth)
         out = [h(depth, bluebook.name), ""]
         out += ["> #{bluebook.vision}", ""] if bluebook.vision
         out.concat(classification_lines(bluebook))
@@ -54,7 +59,7 @@ module Hecks
         out.join("\n")
       end
 
-      # What kind of domain the chapter is and the name it is also known by, when declared.
+      # What kind of domain the bluebook is and the name it is also known by, when declared.
       def classification_lines(bluebook)
         out = []
         out << "#{bluebook.classification.to_s.capitalize} domain." if bluebook.classification
@@ -91,7 +96,7 @@ module Hecks
         out = []
         out << "Identified by `#{aggregate.identity_heads.join("`, `")}`." unless aggregate.identity_heads.empty?
         refs = aggregate.attributes.select(&:reference?)
-        out << "References #{refs.map { |r| "`#{r.type.target_name}`" }.join(", ")}." unless refs.empty?
+        out << "References #{refs.map { |r| "`#{r.target_name}`" }.join(", ")}." unless refs.empty?
         out
       end
 

data/lib/hecks/projector/exporter/adapters.rb

@@ -16,7 +16,8 @@ module Hecks
         end
 
         # Exports one adapter with string keys in the fixed order name, port, fields, secrets,
-        # defaults.
+        # defaults; an adapter that provides capabilities adds `provides`, and a plugin adds
+        # `answers` and `runs` after it.
         #
         # @param adapter [Bluebook::Hecksagon::Adapter] the adapter to export
         # @return [Hash{String => Object}] `"name"` (String), `"port"` (String, nil when never
@@ -29,7 +30,19 @@ module Hecks
             "fields"   => (adapter.fields || []).map(&:to_s),
             "secrets"  => (adapter.secrets || []).map(&:to_s),
             "defaults" => adapter.declared_defaults.to_h { |field, value| [field.to_s, value] }
-          }
+          }.merge(optional_adapter_keys(adapter))
+        end
+
+        # The keys only some adapters carry: `provides` when it names a capability, and a
+        # plugin's `answers` and `runs`.
+        #
+        # @param adapter [Bluebook::Hecksagon::Adapter] the adapter to export
+        # @return [Hash{String => Object}] the keys it carries beyond the five every adapter has
+        def optional_adapter_keys(adapter)
+          keys = adapter.capabilities.empty? ? {} : { "provides" => adapter.capabilities }
+          return keys unless adapter.plugin?
+
+          keys.merge("answers" => adapter.answered_queries, "runs" => adapter.runs)
         end
 
         # Loads each `.adapter` file into its own fresh registry and exports what it declared,

data/lib/hecks/projector/exporter/bindings.rb

@@ -1,38 +1,30 @@
-require_relative "capability_values"
-
 module Hecks
   module Projector
     module Exporter
-      # Which chapter of a registry answers each capability a domain attaches (authorization,
-      # membership, identity, newsletter, registrations, payments): a per-deployment binding fact,
-      # not part of the declared IR. Each answers `{}` when nothing the domain attaches provides it.
+      # Which bluebook of a registry answers each capability a domain attaches (authorization,
+      # membership, identity, and every capability a package declares): a per-deployment binding
+      # fact, not part of the declared IR. Each answers `{}` when nothing the domain attaches
+      # provides it.
       module Bindings
-        include CapabilityValues
-
-        # Which chapter this domain's role checks resolve against
+        # Which bluebook this domain's role checks resolve against
         # (`Registry#authorization_provider_for`); `{}` if none does.
         #
         # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
         # @param domain_name [String] the domain to export the authorization binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:grant`, `:assignments`
-        #   (both provided-verb names), and `:assignment_aggregate` (`:assignments`' own
-        #   leading aggregate name); `{}` if nothing this domain attaches provides
+        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:grant`, `:assignments` and
+        #   `:live_assignments` (provided-verb names), and `:assignment_aggregate`
+        #   (`:assignments`' own leading aggregate name); `{}` if nothing this domain attaches
+        #   provides
         #   authorization
         def authorization(registry, domain_name)
           provider = registry.authorization_provider_for(domain_name)
           return {} unless provider
 
-          capability = Bluebook::Capabilities::AUTHORIZATION
-          assignments = provider.provided_verb(capability, :assignments)
-          {
-            provider:             provider.name,
-            grant:                provider.provided_verb(capability, :grant),
-            assignments:          assignments,
-            assignment_aggregate: aggregate_of(assignments)
-          }
+          verbs = verbs_of(provider, Bluebook::Capabilities::AUTHORIZATION, :grant, :assignments, :live_assignments)
+          { provider: provider.name, **verbs, assignment_aggregate: aggregate_of(verbs[:assignments]) }
         end
 
-        # Which chapter answers "who may sign in" (`Registry#membership_provider_for`),
+        # Which bluebook answers "who may sign in" (`Registry#membership_provider_for`),
         # with the membership aggregate named off `admit`; `{}` if none does.
         #
         # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
@@ -48,7 +40,7 @@ module Hecks
           { provider: provider.name, **verbs, aggregate: aggregate_of(verbs[:admit]) }
         end
 
-        # Which chapter answers "who is this authenticated pair"; `{}` if none does.
+        # Which bluebook answers "who is this authenticated pair"; `{}` if none does.
         # Breaking in 2.0: Link's reference field is `identity`, never `identity_id`.
         #
         # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
@@ -68,118 +60,24 @@ module Hecks
           }
         end
 
-        # Which chapter answers the guest newsletter signup
-        # (`Registry#newsletter_provider_for`); `{}` if none does.
-        #
-        # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the newsletter binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:subscribe`, `:add_name`,
-        #   `:confirm`, `:unsubscribe` (qualified verbs), `:aggregate` (`:subscribe`'s own
-        #   leading qualified aggregate name) and, when declared, `:awaiting_confirmation`,
-        #   `:receives_issues` and `:left` (the states of the lifecycle marks they name) and
-        #   `:confirm_window` and `:unsubscribe_window` (seconds); `{}` if nothing this domain
-        #   attaches provides newsletter
-        def newsletter(registry, domain_name)
-          provider = registry.newsletter_provider_for(domain_name)
-          return {} unless provider
-
-          verbs = verbs_of(provider, Bluebook::Capabilities::NEWSLETTER,
-                           :subscribe, :add_name, :confirm, :unsubscribe)
-          { provider: provider.name, **verbs, aggregate: aggregate_of(verbs[:subscribe]),
-            **all_marked_states(provider, Bluebook::Capabilities::NEWSLETTER),
-            **all_durations(provider, Bluebook::Capabilities::NEWSLETTER) }
-        end
-
-        # Which chapter answers sending a newsletter issue
-        # (`Registry#newsletter_issues_provider_for`); `{}` if none does.
-        #
-        # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the issue-sending binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:send_issue`,
-        #   `:record_delivery` (qualified verbs), `:issue_aggregate` and `:delivery_aggregate`
-        #   (each verb's own leading qualified aggregate name); `{}` if nothing this domain
-        #   attaches provides newsletter_issues
-        def newsletter_issues(registry, domain_name)
-          provider = registry.newsletter_issues_provider_for(domain_name)
-          return {} unless provider
-
-          verbs = verbs_of(provider, Bluebook::Capabilities::NEWSLETTER_ISSUES, :send_issue, :record_delivery)
-          { provider: provider.name, **verbs,
-            **aggregates_of(verbs, issue_aggregate: :send_issue, delivery_aggregate: :record_delivery) }
-        end
-
-        # Which chapter answers scheduling sessions and taking registrations
-        # (`Registry#registrations_provider_for`); `{}` if none does.
-        #
-        # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the registrations binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:schedule`, `:request`
-        #   (qualified verbs), `:event_aggregate` and `:registration_aggregate` (each verb's own
-        #   leading qualified aggregate name) and, when declared, `:frees_seat` (the states of the
-        #   lifecycle mark it names) and `:registered_at` (the attribute that stamps a request);
-        #   `{}` if nothing this domain attaches provides registrations
-        def registrations(registry, domain_name)
-          provider = registry.registrations_provider_for(domain_name)
-          return {} unless provider
-
-          verbs = verbs_of(provider, Bluebook::Capabilities::REGISTRATIONS, :schedule, :request)
-          { provider: provider.name, **verbs,
-            **aggregates_of(verbs, event_aggregate: :schedule, registration_aggregate: :request),
-            **all_marked_states(provider, Bluebook::Capabilities::REGISTRATIONS),
-            **all_words(provider, Bluebook::Capabilities::REGISTRATIONS) }
-        end
-
-        # Which chapter owns the payment-processor connection
-        # (`Registry#payment_connection_provider_for`); `{}` if none does.
+        # Every capability a package declares (one the language defines no contract for), as the
+        # bluebook that provides it for this domain resolves each key: the qualified verb of a
+        # command, query or port operation, the states of a lifecycle mark, or an attribute's
+        # `{ attribute:, default: }`. The reader of a capability checks the keys it needs.
         #
         # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the payment-connection binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), one qualified verb per
-        #   contract key (`:connect`, `:reconnect`, `:disconnect`, `:suspend`, `:resume`,
-        #   `:enable`, `:disable`) and `:aggregate` (`:connect`'s own leading qualified
-        #   aggregate name); `{}` if nothing this domain attaches provides payment_connection
-        def payment_connection(registry, domain_name)
-          provider = registry.payment_connection_provider_for(domain_name)
-          return {} unless provider
-
-          capability = Bluebook::Capabilities::PAYMENT_CONNECTION
-          verbs = verbs_of(provider, capability, *Bluebook::Capabilities::CONTRACTS.fetch(capability).keys)
-          { provider: provider.name, **verbs, aggregate: aggregate_of(verbs[:connect]) }
-        end
-
-        # Which chapter takes payments (`Registry#payments_provider_for`);
-        # `{}` if none does.
-        #
-        # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the payments binding for
-        # @return [Hash{Symbol => String, nil}] `:provider` (name), `:initiate`, `:succeeded`,
-        #   `:failed` (qualified verbs), `:aggregate` (`:initiate`'s own leading qualified
-        #   aggregate name) and, when declared, `:holds_seat` (the states of the lifecycle mark
-        #   it names) and `:lapse_reason` (the word a lapsed hold
-        #   records); `{}` if nothing this domain attaches provides payments
-        def payments(registry, domain_name)
-          provider = registry.payments_provider_for(domain_name)
-          return {} unless provider
-
-          verbs = verbs_of(provider, Bluebook::Capabilities::PAYMENTS, :initiate, :succeeded, :failed)
-          { provider: provider.name, **verbs, aggregate: aggregate_of(verbs[:initiate]),
-            **marked_states(provider, Bluebook::Capabilities::PAYMENTS, :holds_seat),
-            **all_words(provider, Bluebook::Capabilities::PAYMENTS) }
-        end
-
-        # Which chapter owns the checkout boundary (`Registry#checkout_provider_for`); `{}` if
-        # none does.
-        #
-        # @param registry [Runtime::Registry] the booted registry `domain_name` is loaded in
-        # @param domain_name [String] the domain to export the checkout binding for
-        # @return [Hash{Symbol => Object}] `:provider` (name) and, when declared,
-        #   `:webhook_tolerance` and `:session_hold` (whole seconds); `{}` if nothing this
-        #   domain attaches provides checkout
-        def checkout(registry, domain_name)
-          provider = registry.checkout_provider_for(domain_name)
-          return {} unless provider
-
-          { provider: provider.name, **all_durations(provider, Bluebook::Capabilities::CHECKOUT) }
+        # @param domain_name [String] the domain to export the capabilities for
+        # @return [Hash{String => Hash{Symbol => Object}}] each capability's name, mapped to
+        #   `:provider` (the bluebook's name) and one resolved value per key; `{}` if nothing
+        #   loaded declares one
+        def provides(registry, domain_name)
+          package_capabilities(registry).to_h do |capability|
+            provider = registry.vendored_provider_for(domain_name, capability)
+            values = provider.provision(capability).transform_values do |verb|
+              Bluebook::Capabilities.resolved_value(provider, verb)
+            end
+            [capability, { provider: provider.name, **values }]
+          end
         end
 
         private
@@ -189,9 +87,16 @@ module Hecks
           keys.to_h { |key| [key, provider.provided_verb(capability, key)] }
         end
 
-        # Each name in `names` mapped to the leading aggregate of the verb its key names in `verbs`.
-        def aggregates_of(verbs, names)
-          names.transform_values { |key| aggregate_of(verbs[key]) }
+        # Every capability name a loaded bluebook provides that the language defines no contract
+        # for.
+        def package_capabilities(registry)
+          provided_capabilities(registry).reject { |capability| Bluebook::Capabilities.language_defined?(capability) }
+        end
+
+        # Every capability name a loaded bluebook provides, once each, sorted.
+        def provided_capabilities(registry)
+          declarations = registry.bluebooks.values
+          declarations.flat_map { |declaration| declaration.provides.map(&:capability) }.uniq.sort
         end
 
         # The leading aggregate name of a qualified verb, or `nil` when there is no verb.

data/lib/hecks/projector/exporter/plugins.rb

@@ -0,0 +1,55 @@
+require "base64"
+require "digest"
+
+module Hecks
+  module Projector
+    module Exporter
+      # The wasm plugins a registry loaded, for the IR's `plugins` key: everything a host needs to
+      # answer a plugin's queries without the bluebook of the bluebook that declares them. The
+      # module itself rides in the IR, so every deploy that ships the IR ships the plugin too.
+      module Plugins
+        # Every plugin adapter in a registry, by name.
+        #
+        # @param registry [Runtime::Registry] the loaded registry
+        # @return [Array<Hash{String => Object}>] `"adapter"`, `"runs"`, `"sha256"` and `"module"`
+        #   (the module's bytes, base64), and `"queries"`: each answered question with
+        #   `"references"`, its `reference_to` arguments mapped to the qualified aggregate each
+        #   names
+        def plugins(registry)
+          found = registry.adapters.values.select(&:plugin?)
+          found.sort_by(&:name).map { |adapter| plugin_hash(registry, adapter) }
+        end
+
+        def plugin_hash(registry, adapter)
+          bytes = File.binread(adapter.plugin_path)
+          {
+            "adapter" => adapter.name,
+            "runs"    => adapter.runs,
+            "queries" => adapter.answered_queries.map { |question| plugin_query(registry, question) },
+            "sha256"  => Digest::SHA256.hexdigest(bytes),
+            "module"  => Base64.strict_encode64(bytes)
+          }
+        end
+
+        # One answered question and its reference arguments; a question no loaded bluebook declares
+        # carries none, and the host refuses it the way the runtime would.
+        def plugin_query(registry, question)
+          declaration_name, rest = question.split("::", 2)
+          aggregate_name, query_name = rest.split(".", 2)
+          aggregate = registry.bluebook(declaration_name)&.aggregate(aggregate_name)
+          query = aggregate&.query(query_name)
+          { "question" => question, "references" => references(declaration_name, aggregate, query) }
+        end
+
+        def references(declaration_name, aggregate, query)
+          return {} unless query
+
+          query.attributes.select(&:reference?).to_h do |attribute|
+            target = attribute.target_aggregate || aggregate
+            [attribute.name.to_s, "#{declaration_name}::#{target.hecks_name}"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projector/exporter.rb

@@ -2,6 +2,7 @@ require "json"
 require_relative "../ports/persistence"
 require_relative "exporter/adapters"
 require_relative "exporter/bindings"
+require_relative "exporter/plugins"
 require_relative "exporter/translations"
 require_relative "exporter/worlds"
 
@@ -76,6 +77,7 @@ module Hecks
 
       extend Adapters
       extend Bindings
+      extend Plugins
       extend Translations
       extend Worlds
     end

data/lib/hecks/projector/narrate_projector/commands.rb

@@ -61,7 +61,7 @@ module Hecks
           refs = command.attributes.select(&:reference?)
           return nil if refs.empty?
 
-          "It's aimed at one existing #{NarrateProjector.to_sentence_list(refs.map { |r| r.type.target_name })}, by id."
+          "It's aimed at one existing #{NarrateProjector.to_sentence_list(refs.map(&:target_name))}, by id."
         end
 
         def command_conditions_sentence(command, holder)
@@ -94,9 +94,10 @@ module Hecks
         def lifecycle_conditions(command, lifecycle)
           return [] unless lifecycle
 
-          froms = lifecycle.transitions.filter_map do |name, transition|
+          sources = lifecycle.transitions.filter_map do |name, transition|
             Array(transition.from) if name.to_s == command.hecks_name
-          end.flatten.uniq
+          end
+          froms = sources.flatten.uniq
           return [] if froms.empty?
 
           states = NarrateProjector.to_sentence_list(froms.map { |f| "`#{f}`" }, conj: "or")

data/lib/hecks/projector/narrate_projector/reactions.rb

@@ -1,11 +1,11 @@
 module Hecks
   module Projector
     module NarrateProjector
-      # The prose for what a chapter causes on its own: its policies and its sagas.
+      # The prose for what a bluebook causes on its own: its policies and its sagas.
       module Reactions
         module_function
 
-        # The "Reactions" section, or `nil` when the chapter has no policies or sagas.
+        # The "Reactions" section, or `nil` when the bluebook has no policies or sagas.
         def narrative(bluebook, depth)
           return nil if bluebook.policies.empty? && bluebook.process_managers.empty?