hecks 3.10.0 → 3.11.0

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

@@ -0,0 +1,35 @@
+require_relative "../../bluebook/ask_resolution"
+
+module Hecks
+  module Runtime
+    class Registry
+      # The boot gate for `ask`: every policy's ask must resolve to one declared port operation,
+      # so a name the hecksagon never declared stops the boot instead of firing at nothing.
+      # Mixed into {Verification}.
+      module AskVerification
+        private
+
+        # A port operation a chapter provides, and an ask a policy makes, each name a port
+        # operation the hecksagon declared.
+        def refuse_unresolved_ports!
+          refuse_unresolved_port_operations!
+          refuse_unresolved_asks!
+        end
+
+        # Binds each ask to the operation it resolves to, refusing the first that resolves to none.
+        #
+        # @raise [WiringError] naming the policy, the ask and what the hecksagon would need
+        def refuse_unresolved_asks!
+          @declared.bluebooks.each_value do |chapter|
+            chapter.policies.select(&:asks?).each do |policy|
+              outcome = Bluebook::AskResolution.call(chapter, policy)
+              raise WiringError, outcome.detail unless outcome.resolved?
+
+              policy.resolve_ask!(outcome.verb)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,16 @@ module Hecks
                 "without that it is silent decoration, the exact defect this refusal exists to catch"
         end
 
+        # `driven_by` names a driving adapter; a name none answers to would silently admit nothing.
+        def refuse_unknown_driving!(hecksagon)
+          unknown = hecksagon.driving - Bluebook::Hecksagon::DRIVING_ADAPTERS
+          return if unknown.empty?
+
+          raise WiringError,
+                "#{hecksagon.domain} is driven_by #{unknown.map(&:inspect).join(", ")}, which no driving " \
+                "adapter answers to — the adapters are #{Bluebook::Hecksagon::DRIVING_ADAPTERS.join(", ")}"
+        end
+
         # `attaches` loads a bounded context; the consumer must declare the sibling hecksagon
         # that is its ACL (Governance/Identity/Privacy already do). A vendored package only
         # loads its `.bluebook` files, so persistence, Governance and the `translates` ACL live

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

@@ -17,7 +17,7 @@ module Hecks
         def merge_hecksagons(base, overlay)
           # Order-independent: list facts uniq, so loading context_map before or after the
           # domain file yields the same merged hecksagon.
-          lists = %i[subscriptions attachments translates].to_h do |facet|
+          lists = %i[subscriptions attachments translates driving].to_h do |facet|
             [facet, (base.public_send(facet) + overlay.public_send(facet)).uniq]
           end
           Bluebook::Hecksagon.new(domain: base.domain, binds: base.binds + overlay.binds,

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

@@ -101,6 +101,16 @@ module Hecks
           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"`.
@@ -112,6 +122,12 @@ module Hecks
           vendored_provider_for(domain, Bluebook::Capabilities::PAYMENTS)
         end
 
+        # The first loaded chapter 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) }
+
         # The chapter that provides `capability` for `domain`: the domain's own chapter,
         # a framework member its hecksagon attaches, or a vendored embryonaut bluebook
         # it attaches, that declares it.

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

@@ -1,3 +1,5 @@
+require_relative "../best_effort"
+
 module Hecks
   module Runtime
     class Registry
@@ -37,10 +39,10 @@ module Hecks
         #   `authoritative`, in the same order; false on any mismatch, or if comparing
         #   them raises
         def projection_current?(projection, authoritative)
-          entries_match?(projection.entries, authoritative.entries) &&
-            sorted_rows(projection) == sorted_rows(authoritative)
-        rescue StandardError
-          false
+          BestEffort.call(false) do
+            entries_match?(projection.entries, authoritative.entries) &&
+              sorted_rows(projection) == sorted_rows(authoritative)
+          end
         end
 
         private

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

@@ -1,5 +1,6 @@
 require_relative "../../bluebook/hecksagon"
 require_relative "hecksagon_rules"
+require_relative "ask_verification"
 require_relative "query_verification"
 require_relative "chapter_verification"
 require_relative "durability_warnings"
@@ -11,6 +12,7 @@ module Hecks
       # port's verb, and every world default is usable. `verify!` runs it all at boot.
       module Verification
         include HecksagonRules
+        include AskVerification
         include QueryVerification
         include ChapterVerification
         include DurabilityWarnings
@@ -24,7 +26,7 @@ module Hecks
           refuse_cross_package_bluebook_merge!
           refuse_reserved_chapter_names!
           refuse_membership_without_identity!
-          refuse_unresolved_port_operations!
+          refuse_unresolved_ports!
           refuse_unanswerable_queries!
 
           @declared.hecksagons.each_value { |hecksagon| verify_hecksagon!(hecksagon) }
@@ -126,6 +128,7 @@ module Hecks
         # warnings for its chapter.
         def verify_hecksagon!(hecksagon)
           refuse_ungoverned_roles!(hecksagon)
+          refuse_unknown_driving!(hecksagon)
           refuse_unwired_attachments!(hecksagon)
           refuse_bounded_without_acl!(hecksagon)
           hecksagon.binds.each { |bind| verify_bind!(hecksagon, bind) }

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

@@ -28,8 +28,37 @@ module Hecks
           self
         end
 
+        # The defaults an adapter's `.adapter` declares for its fields, with each `{name}` or
+        # `{storage_name}` in a string filled from `aggregate`. A world's own setting always wins.
+        #
+        # @param adapter [String, Symbol] the adapter's name
+        # @param aggregate [Bluebook::Aggregate] the aggregate the adapter is built for
+        # @return [Hash{Symbol => Object}] the defaults, empty when the adapter declares none
+        def adapter_defaults(adapter, aggregate)
+          declared = @declared.adapters[adapter.to_s]&.declared_defaults || {}
+          declared.transform_values { |value| fill_placeholders(value, aggregate) }
+        end
+
+        # `settings` laid over the adapter's declared defaults. A field a world gives as `:default`
+        # asks for the declared default, so it is left out and the default shows through.
+        #
+        # @param adapter [String, Symbol] the adapter's name
+        # @param aggregate [Bluebook::Aggregate] the aggregate the adapter is built for
+        # @param settings [Hash{Symbol => Object}] the settings the world gave
+        # @return [Hash{Symbol => Object}] the defaults, overridden by the settings given
+        def with_adapter_defaults(adapter, aggregate, settings)
+          adapter_defaults(adapter, aggregate).merge(settings.reject { |_, value| value == :default })
+        end
+
         private
 
+        # A string default with its placeholders filled from the aggregate; any other value as is.
+        def fill_placeholders(value, aggregate)
+          return value unless value.is_a?(String)
+
+          value.gsub(/\{(name|storage_name)\}/) { aggregate.public_send(Regexp.last_match(1)) }
+        end
+
         # The chapter'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)

data/lib/hecks/runtime/registry.rb

@@ -45,7 +45,7 @@ module Hecks
       #   against; nil for a registry with no such root
       def initialize(root: nil)
         @root         = root
-        # Recorded at hecksagon-build time (AggregateDoor#mark_sensitive), Loader.boot's
+        # Recorded at hecksagon-build time (AggregateModule#mark_sensitive), Loader.boot's
         # post-dispatch step turns each pending privacy marking into a real Privacy::Marking.Mark,
         # idempotently. `resolved_eras` and `superseded_eras` are eager, not lazy, so no two
         # dispatching threads race to create them; all writes still happen at boot,

data/lib/hecks/runtime/saga_interpreter/compensation.rb

@@ -7,7 +7,7 @@ module Hecks
       module Compensation
         private
 
-        # Recorded before dispatching, not after `@door.reenter` returns —
+        # Recorded before dispatching, not after `@dispatcher.reenter` returns —
         # reenter can recursively re-enter this interpreter and refuse
         # before ever returning here, and recording only on success would
         # be too late for that nested refusal to see this leg's own

data/lib/hecks/runtime/saga_interpreter/delivery.rb

@@ -24,7 +24,7 @@ module Hecks
           record = { process_manager: process_manager.name, instance: correlation, dispatch: spec.command_name }
 
           log_dispatch_inputs(leg, spec, args) unless spec.with_spec.to_a.empty?
-          return refuse_at_depth_ceiling(leg, record) if @door.reaction_depth_reached?
+          return refuse_at_depth_ceiling(leg, record) if @dispatcher.reaction_depth_reached?
 
           attempt_dispatch(leg, spec, args, record)
         end
@@ -46,7 +46,7 @@ module Hecks
         # it unwinds like a refusal rather than stranding the instance.
         def refuse_at_depth_ceiling(leg, record)
           @registry.saga_log << record.merge(delivered: false,
-                                             reason:    "reaction depth #{@door.max_reaction_depth} reached")
+                                             reason:    "reaction depth #{@dispatcher.max_reaction_depth} reached")
           unwind(leg)
         end
 
@@ -95,14 +95,14 @@ module Hecks
           nil
         end
 
-        # Dispatches `command_name` through the door, stamped with this saga's correlation.
+        # Dispatches `command_name` through the dispatcher, stamped with this saga's correlation.
         def reenter_command(leg, command_name, projected, explicit:, source_receiver:)
           head = leg.process_manager.correlation_head
           verb = qualified(command_name, leg.domain)
           invocation = ReactionInvocation.build(registry: @registry, verb: verb, projected: projected,
                                                 explicit: explicit, passthrough: [head],
                                                 source_receiver: source_receiver)
-          @door.reenter(verb, saga_correlation: { head.to_s => leg.correlation }, **invocation)
+          @dispatcher.reenter(verb, saga_correlation: { head.to_s => leg.correlation }, **invocation)
         end
 
         # Unlike a refusal, a crash isn't a domain decision, so it

data/lib/hecks/runtime/saga_interpreter/transitions.rb

@@ -21,7 +21,7 @@ module Hecks
 
         # The mutex covers only the check-mutate-checkpoint step, never the
         # dispatch cascade that follows — `deliver_saga_dispatch`'s
-        # `@door.reenter` can recursively re-enter this interpreter on the
+        # `@dispatcher.reenter` can recursively re-enter this interpreter on the
         # same thread, and `Mutex` is not reentrant.
         def remembered_leg_taken?(leg)
           leg.instance = @registry.saga_instances[leg.process_manager.name][leg.correlation]

data/lib/hecks/runtime/saga_interpreter.rb

@@ -55,11 +55,11 @@ module Hecks
 
       # @param registry [Runtime::Registry] the booted registry whose declared
       #   process managers and saga persistence this interpreter runs against
-      # @param door [Runtime::Dispatcher] the dispatcher a saga leg's own dispatch
+      # @param dispatcher [Runtime::Dispatcher] the dispatcher a saga leg's own dispatch
       #   re-enters through
-      def initialize(registry, door:)
+      def initialize(registry, dispatcher:)
         @registry = registry
-        @door     = door
+        @dispatcher = dispatcher
       end
 
       # Runs `domain`'s declared process managers against `event`: begins,

data/lib/hecks/runtime/tenant_check.rb

@@ -1,4 +1,5 @@
 require_relative "../ports/persistence/binding_policy"
+require_relative "best_effort"
 
 module Hecks
   module Runtime
@@ -37,10 +38,10 @@ module Hecks
       # Same defensive shape as EraCheck#lineage_capable? — a class that
       # doesn't respond at all, or whose lookup raises, is false, not an error.
       def tenant_capable?(registry, adapter_name)
-        adapter_class = registry.adapters[adapter_name] && registry.adapter_class(adapter_name)
-        adapter_class.respond_to?(:tenant_capable?) && adapter_class.tenant_capable?
-      rescue StandardError
-        false
+        BestEffort.call(false) do
+          adapter_class = registry.adapters[adapter_name] && registry.adapter_class(adapter_name)
+          adapter_class.respond_to?(:tenant_capable?) && adapter_class.tenant_capable?
+        end
       end
     end
   end

data/lib/hecks/runtime/value/coercion.rb

@@ -37,9 +37,9 @@ module Hecks
         # Coerces `value` for a single, already-resolved `attribute`, branching on
         # its declared shape (list, reference, composite, or bare scalar).
         #
-        # `boundary: false` is the query door, where a declared type documents the
+        # `boundary: false` is the query entry point, where a declared type documents the
         # argument for callers/generators rather than naming a shape to enforce.
-        # `argument: true` is the command/entity/port dispatch door, where a nil for
+        # `argument: true` is the command/entity/port dispatch entry point, where a nil for
         # a required attribute is a left-empty argument (C3.7), not ordinary state nil.
         #
         # @raise [Runtime::TypeMismatch] if `value` cannot be coerced, or a required

data/lib/hecks/runtime/value/validation.rb

@@ -34,7 +34,11 @@ module Hecks
           fields
         end
 
-        # Fills every declared attribute `fields` lacks with its own `default:`.
+        # Fills every declared attribute `fields` lacks with its own `default:`, and every required
+        # list it lacks with an empty one: a list left out reads as no members, the one shape the
+        # Rust runtime (a `Vec`) can hold, so a value object built from nothing (a required
+        # argument left empty, C3.7) is `{blocks: []}` on both sides rather than `{}` here.
+        # An optional list stays absent, and an offered list, empty or not, is kept as offered.
         #
         # @param value_object [Class] the `Bluebook::ValueObject` subclass whose
         #   declared defaults are read
@@ -42,11 +46,11 @@ module Hecks
         # @return [Hash{Symbol => Object}] `fields`, with defaults filled in
         def apply_defaults(value_object, fields)
           value_object.attributes.each_with_object(fields) do |attribute, completed|
-            completed[attribute.name] = attribute.default unless completed.key?(attribute.name) || attribute.default.nil?
+            fill_absent(completed, attribute) unless completed.key?(attribute.name)
           end
         end
 
-        # The full door a value object's own fields pass through — shared by
+        # The full entry point a value object's own fields pass through — shared by
         # `build` and `normalize_composite_fields`, so a nested field refuses
         # exactly like the same type declared directly on a command.
         #
@@ -85,6 +89,13 @@ module Hecks
 
         private
 
+        # The default an absent attribute declares, else an empty list for a required list.
+        def fill_absent(fields, attribute)
+          return fields[attribute.name] = attribute.default unless attribute.default.nil?
+
+          fields[attribute.name] = [] if attribute.list? && !attribute.optional?
+        end
+
         def normalize_composite_field(aggregate, attribute, fields)
           # A list member hydrates the same as a top-level list, so a value
           # read back from the store matches the shape a live dispatch wrote.
@@ -109,7 +120,8 @@ module Hecks
           validate_input_list(aggregate, attribute, fields)
         end
 
-        # Runs each value-object member of an input list through the same door a nested single
+        # Runs each value-object member of an input list through the same entry point a nested
+        # single
         # value goes through, so a member's own invariants and nested lists refuse on dispatch
         # exactly as they do when the list sits directly on a command. The members stay as offered.
         def validate_input_list(aggregate, attribute, fields)

data/lib/hecks/runtime.rb

@@ -42,12 +42,12 @@ module Hecks
       #
       # @param path [String] path to a domain directory, or a file inside one
       # @param shared [String, nil] a shared-root override
-      # @param install_doors [Boolean] whether to install the Ruby facade constants
+      # @param install_driving [Boolean] whether to install the Ruby facade constants
       # @param environment [String, nil] the environment name for `Adapters::Folder#load_domain`
       # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the dispatcher bound
       #   to the booted domain
-      def boot(path, shared: nil, install_doors: true, environment: Runtime::Loader::FROM_ENV)
-        Loader.boot(path, shared: shared, install_doors: install_doors, environment: environment)
+      def boot(path, shared: nil, install_driving: true, environment: Runtime::Loader::FROM_ENV)
+        Loader.boot(path, shared: shared, install_driving: install_driving, environment: environment)
       end
 
       # Loads a domain's declarations without binding any adapter. See Loader.describe.
@@ -63,23 +63,23 @@ module Hecks
       # Finishes a boot from declarations `describe` already loaded. See Loader.boot_described.
       #
       # @param described [Runtime::Loader::Described] what `describe` answered
-      # @param install_doors [Boolean] whether to install the Ruby facade constants
+      # @param install_driving [Boolean] whether to install the Ruby facade constants
       # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the dispatcher bound
       #   to the booted domain
-      def boot_described(described, install_doors: true)
-        Loader.boot_described(described, install_doors: install_doors)
+      def boot_described(described, install_driving: true)
+        Loader.boot_described(described, install_driving: install_driving)
       end
 
       # Loads only the given files of a domain; otherwise like `boot`. See Loader.boot_files.
       #
       # @param paths [String, Array<String>] one or more file paths within the domain
       # @param shared [String, nil] a shared-root override
-      # @param install_doors [Boolean] whether to install the Ruby facade constants
+      # @param install_driving [Boolean] whether to install the Ruby facade constants
       # @param environment [String, nil] the environment name for the selected-file loader
       # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the dispatcher bound
       #   to the booted domain
-      def boot_files(paths, shared: nil, install_doors: true, environment: Runtime::Loader::FROM_ENV)
-        Loader.boot_files(paths, shared: shared, install_doors: install_doors, environment: environment)
+      def boot_files(paths, shared: nil, install_driving: true, environment: Runtime::Loader::FROM_ENV)
+        Loader.boot_files(paths, shared: shared, install_driving: install_driving, environment: environment)
       end
 
       # Bind the ambient registry for the duration of the block, restoring

data/lib/hecks/rust_build/project_rust/target_ir.rb

@@ -11,7 +11,7 @@ module Hecks
         # The optional attachments `rust/host` reads from `ir.json`, each omitted when nothing
         # attached provides it: exporter method, then the key it is written under.
         SEAMS = %i[authorization membership identity newsletter newsletter_issues payments
-                   registrations payment_connection].freeze
+                   registrations payment_connection checkout].freeze
 
         # Round-trips a value through JSON so generators see the string-keyed shape a real
         # `ir.json` carries, never live Ruby symbols.

data/lib/hecks/rust_build/wasm.rb

@@ -60,7 +60,7 @@ module Hecks
       end
 
       def require_target!
-        return if system("rustup target list --installed 2>/dev/null | grep -qx #{TARGET}")
+        return if RustBuild.target_installed?(TARGET)
 
         raise Failure, <<~MSG
           #{TARGET} isn't installed for this toolchain. Install it once with:

data/lib/hecks/rust_build/wasm_browser.rb

@@ -52,7 +52,7 @@ module Hecks
       end
 
       def require_target!
-        return if system("rustup target list --installed 2>/dev/null | grep -qx #{TARGET}")
+        return if RustBuild.target_installed?(TARGET)
 
         raise Failure, <<~MSG
           #{TARGET} isn't installed for this toolchain. Install it once with:

data/lib/hecks/rust_build.rb

@@ -83,6 +83,17 @@ module Hecks
         raise Failure, "`#{command.join(" ")}` failed#{" in #{chdir}" if chdir}"
       end
 
+      # Asks rustup whether a compile target is installed for the active toolchain.
+      #
+      # @param target [String] the target triple, such as `wasm32-unknown-unknown`
+      # @return [Boolean] false when rustup is missing or does not list the target
+      def target_installed?(target)
+        listed = IO.popen(["rustup", "target", "list", "--installed", { err: File::NULL }], &:read)
+        listed.split("\n").include?(target)
+      rescue SystemCallError
+        false
+      end
+
       # Runs a tool and holds what it printed.
       #
       # @param tool [String] a key of `TOOLS`

data/lib/hecks/served_options.rb

@@ -0,0 +1,53 @@
+require "rack"
+
+module Hecks
+  # What a domain's world file says it is served by: each `served_by("Adapter") { ... }` line
+  # names an inbound adapter and the per-environment values it needs. The route is derived,
+  # never written: a driving adapter answers at `/webhooks/<adapter name, snake-cased>` unless
+  # its `path` says otherwise, so a world holds only what the domain cannot know (secret,
+  # path override) and the same domain can be served differently in each environment.
+  #
+  # A secret is named by the environment variable that holds it, never inline.
+  module ServedOptions
+    VERB = "served_by".freeze
+
+    module_function
+
+    # @param world [Bluebook::World, nil] a domain's judged world
+    # @return [Array<Hash>] one entry per `served_by` line: `adapter`, `path` and its settings
+    def entries(world)
+      return [] unless world
+
+      world.settings.filter_map do |key, values|
+        next unless key.to_s.start_with?("#{VERB}:")
+
+        adapter = values.fetch(:adapter)
+        values.merge(adapter: adapter, path: values.fetch(:path) { "/webhooks/#{snake(adapter)}" })
+      end
+    end
+
+    # A Rack app mounting every `served_by` adapter the world names at its derived path.
+    #
+    # @param world [Bluebook::World, nil]
+    # @param adapters [Hash{String => Class}] driving adapter classes by the name a world uses;
+    #   each is built with `secret:` read from the environment variable the line names
+    # @param env [#fetch] where secrets are read from (`ENV` in production)
+    # @return [Rack::URLMap]
+    # @raise [KeyError] when a line names an adapter no class answers for
+    # @raise [ArgumentError] when a line names a secret variable the environment does not hold
+    def rack_app(world, adapters:, env: ENV)
+      routes = entries(world).to_h do |entry|
+        klass = adapters.fetch(entry[:adapter])
+        [entry[:path], klass.new(secret: secret_for(entry, env))]
+      end
+      Rack::URLMap.new(routes)
+    end
+
+    def secret_for(entry, env)
+      name = entry.fetch(:secret) { raise ArgumentError, "#{entry[:adapter]} names no secret" }
+      env.fetch(name) { raise ArgumentError, "#{entry[:adapter]}: environment variable #{name} is not set" }
+    end
+
+    def snake(name) = name.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+  end
+end

data/lib/hecks/site/bluebook/site.bluebook

@@ -167,6 +167,7 @@ Hecks.bluebook "Site" do
     end
 
     lifecycle :status, default: "requested" do
+      mark :failure, "faulted"
       transition "Complete" => "projected", from: "requested"
       transition "Fault"    => "faulted",   from: "requested"
     end

data/lib/hecks/storehouse/audit.rb

@@ -33,7 +33,7 @@ module Hecks
       end
 
       # Tails this bus's own dispatch/query/state audit log — a pull-based
-      # substitute for a push subscription, since a stdio door answers one
+      # substitute for a push subscription, since a stdio server answers one
       # request at a time with no channel to push through.
       #
       # @param runtime [Runtime::Registry] the booted domain to tail

data/lib/hecks/storehouse/dispatching.rb

@@ -34,9 +34,9 @@ module Hecks
 
       # :nodoc:
       def command_envelope(args, spec)
-        Doors::CommandRequest.normalize(Doors::JsonDoor.deep_symbolize(args),
-                                        receiver:        spec[:receiver],
-                                        legacy_receiver: spec[:legacy_receiver])
+        Adapters::Driving::CommandRequest.normalize(Adapters::Driving::Json.deep_symbolize(args),
+                                                    receiver:        spec[:receiver],
+                                                    legacy_receiver: spec[:legacy_receiver])
       end
 
       # :nodoc:
@@ -52,7 +52,9 @@ module Hecks
         ok(summary: summary,
            id:      result.id,
            state:   settled_state(runtime, spec, result),
-           events:  result.events.map { |event| { name: event.name, payload: Doors::JsonDoor.materialize(event.payload) } })
+           events:  result.events.map do |event|
+             { name: event.name, payload: Adapters::Driving::Json.materialize(event.payload) }
+           end)
       end
 
       # The record as its repository holds it once every reaction has run, which is the state the
@@ -65,7 +67,7 @@ module Hecks
       def settled_state(runtime, spec, result)
         return if result.state.nil?
 
-        Doors::JsonDoor.materialize(settled_record(runtime, spec, result) || result.state)
+        Adapters::Driving::Json.materialize(settled_record(runtime, spec, result) || result.state)
       end
 
       # :nodoc:
@@ -141,7 +143,7 @@ module Hecks
 
       # :nodoc:
       def batch_step(runtime, raw, summary, options)
-        step = Doors::JsonDoor.deep_symbolize(raw)
+        step = Adapters::Driving::Json.deep_symbolize(raw)
         dispatch(runtime: runtime, command: step[:command], args: step[:args] || {}, summary: summary, **options)
       end
     end

data/lib/hecks/storehouse/introspection.rb

@@ -68,7 +68,7 @@ module Hecks
       # @return [Hash] {ok: true, domain:, valid: true} plus :findings when deep;
       #   {ok: false, domain:, valid: false, error:} if the boot itself failed
       def validate(domain:, deep: false)
-        runtime = Hecks.boot(confine!(domain, "domain"), install_doors: false)
+        runtime = Hecks.boot(confine!(domain, "domain"), install_driving: false)
         result  = { ok: true, domain: domain, valid: true }
         result[:findings] = model_findings(runtime) if deep
         result
@@ -103,7 +103,7 @@ module Hecks
 
       # :nodoc:
       def journal_entries(repository)
-        repository.entries.map { |entry| { operation: entry.operation, id: entry.id, state: Doors::JsonDoor.materialize(entry.state) } }
+        repository.entries.map { |entry| { operation: entry.operation, id: entry.id, state: Adapters::Driving::Json.materialize(entry.state) } }
       end
 
       # Runs a domain's hand-curated .behaviors examples and reports the results.

data/lib/hecks/storehouse/querying.rb

@@ -27,12 +27,14 @@ module Hecks
         spec = resolve!(cli_for(request.bluebook), request.name, asking: true)
         rows = with_caller(request.role, request.actor_id) { answer(request, spec) }
 
-        ok(summary: request.summary, rows: rows.map { |row| Doors::JsonDoor.materialize(row) }).merge(verb: spec[:command])
+        ok(summary: request.summary, rows: rows.map do |row|
+          Adapters::Driving::Json.materialize(row)
+        end).merge(verb: spec[:command])
       end
 
       # :nodoc:
       def answer(request, spec)
-        request.runtime.query(spec[:command], **Doors::JsonDoor.deep_symbolize(request.args))
+        request.runtime.query(spec[:command], **Adapters::Driving::Json.deep_symbolize(request.args))
       end
 
       # Reads one aggregate's stored records directly, bypassing any declared
@@ -63,7 +65,7 @@ module Hecks
         repository = runtime.registry.repository(bluebook.name, ir)
         return ok(summary: summary, record: single_record(repository, ir, id)) if id
 
-        records = repository.all.map { |instance| Doors::JsonDoor.materialize(instance.to_h) }
+        records = repository.all.map { |instance| Adapters::Driving::Json.materialize(instance.to_h) }
         ok(summary: summary, count: records.length, records: records)
       end
 
@@ -71,7 +73,7 @@ module Hecks
       def single_record(repository, aggregate_ir, identity)
         instance = repository.find(identity) or
           raise Runtime::NotFound, "no #{aggregate_ir.hecks_name} found for id #{identity.inspect}"
-        Doors::JsonDoor.materialize(instance.to_h)
+        Adapters::Driving::Json.materialize(instance.to_h)
       end
     end
   end