hecks 3.13.0 → 4.0.0

data/lib/hecks/runtime/remote_dispatcher.rb

@@ -117,8 +117,8 @@ module Hecks
         [domain, aggregate]
       end
 
-      # Not every aggregate in a routed domain is Lambda-bound (a `compute` rule can
-      # only run against Postgres). Test the adapter's capability, not its name.
+      # Not every aggregate in a routed domain is Lambda-bound (a persistence binding
+      # may name another adapter). Test the adapter's capability, not its name.
       def remote_bound?(domain, aggregate)
         adapter_name = Ports::Persistence::BindingPolicy.resolve(@registry, domain, aggregate).adapter
         @registry.adapter_class(adapter_name) <= Ports::Persistence::RemoteRuntime

data/lib/hecks/runtime/value.rb

@@ -102,6 +102,19 @@ module Hecks
         end
       end
 
+      # Converts every Hash key to a Symbol, at every depth of parsed JSON.
+      #
+      # @param value [Hash, Array, Object] a Hash or Array is walked; any other value is a leaf
+      # @return [Hash{Symbol => Object}, Array, Object] a new structure of the same shape with
+      #   Symbol keys; a leaf is returned as it came
+      def self.deep_symbolize(value)
+        case value
+        when Hash then value.to_h { |key, item| [key.to_sym, deep_symbolize(item)] }
+        when Array then value.map { |item| deep_symbolize(item) }
+        else value
+        end
+      end
+
       # `materialize`, but a single-attribute value object unwraps to its bare field.
       # Opt-in for `group_by` rows; `materialize` keeps the wrapped shape callers depend on.
       #

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

@@ -36,6 +36,7 @@ module Hecks
           ir = shaped(exporter.call(@registry).fetch(@domain_name))
           ir[:lineage] = shaped(exporter.lineage(@registry, @domain_name))
           ir[:persistence] = shaped(exporter.persistence(@registry, @domain_name))
+          add_persistence_wiring(ir, exporter)
           add_seams(ir, exporter)
           add_edges_and_source(ir)
           ir
@@ -43,8 +44,28 @@ module Hecks
 
         private
 
+        # The adapters and the world that the host checks the persistence against.
+        def add_persistence_wiring(document, exporter)
+          document[:adapters] = adapters(exporter, document[:persistence])
+          document[:world] = world(exporter)
+        end
+
         def shaped(payload) = self.class.json_shaped(payload)
 
+        # The bound persistence adapters' declarations, from the `.adapter` files under the
+        # source root's `lib/` and the domain's own directory, so the host can look them up.
+        def adapters(exporter, persistence)
+          files = exporter.adapter_files_under([File.join(RustBuild::ROOT, "lib"), File.dirname(@bluebook_dir)])
+          shaped(exporter.persistence_adapters(persistence, files))
+        end
+
+        # The target's world persistence, from `<domain directory name>.world` beside the bluebooks
+        # (names only), so the host can check what the world binds against the adapters.
+        def world(exporter)
+          path = File.join(@bluebook_dir, "#{File.basename(File.dirname(@bluebook_dir))}.world")
+          shaped(exporter.persistence_world(path, @domain_name))
+        end
+
         def add_seams(document, exporter)
           seams = SEAMS.to_h { |seam| [seam, exporter.public_send(seam, @registry, @domain_name)] }
           seams.each { |seam, value| document[seam] = shaped(value) unless value.empty? }
@@ -56,14 +77,12 @@ module Hecks
                          "hecksagon, not a deploy-time guess, names the identity verbs."
         end
 
-        # Edges carry their own precompiled SQL, so a boot-time mint only executes it. Committed
-        # approvals sit beside the edges. The source text is verbatim: the era's integrity digest is
+        # Edges carry their own precompiled SQL, so a boot-time mint only executes it. The source
+        # text is verbatim: the era's integrity digest is
         # the SHA256 of it, not of anything re-derived from the parsed IR.
         def add_edges_and_source(document)
           edges = Hecks::Projector::Exporter.translations(@registry).select { |edge| edge[:domain] == @domain_name }
           document[:translations] = shaped(edges)
-          approvals = Hecks::Translation::ApprovalFile.read_all(@bluebook_dir)
-          document[:approvals] = shaped(approvals) unless approvals.empty?
           document[:source_text] = Hecks::Runtime::EraCheck.source_text_for(
             @registry.bluebooks.fetch(@domain_name), @bluebook_dir, registry: @registry
           )

data/lib/hecks/rust_build/wasm.rb

@@ -31,7 +31,6 @@ module Hecks
       # @raise [Failure] when the target is not installed or a step fails
       def call(argv)
         domain = argv.first or raise Failure, "usage: hecks build_wasm <domain>"
-        return build_with_rust(domain) if ENV["HECKS_PARSER"] == "rust" && ENV["HECKS_CODEGEN"] == "rust"
 
         require_target!
         rust_dir = RustBuild.rust_dir
@@ -48,17 +47,6 @@ module Hecks
         raise Failure, "project_rust failed for #{domain}" unless status.zero?
       end
 
-      # With the Rust parser and codegen, `hecks-build` runs the same steps and writes the same
-      # outputs.
-      def build_with_rust(domain)
-        build_dir = File.join(ROOT, "rust", "build")
-        puts "== cargo build (hecks-build) =="
-        RustBuild.command!("cargo", "build", chdir: build_dir)
-        puts "== hecks-build #{domain} --wasm =="
-        RustBuild.command!(File.join(build_dir, "target", "debug", "hecks-build"), domain, "--wasm")
-        0
-      end
-
       def require_target!
         return if RustBuild.target_installed?(TARGET)
 

data/lib/hecks/rust_build/write_if_changed.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../rust_format"
 
 module Hecks
   module RustBuild
@@ -9,17 +10,8 @@ module Hecks
     module WriteIfChanged
       module_function
 
-      # Records every path written or confirmed unchanged inside the block, then deletes
-      # files left in `dir` that were never touched (orphans of removed aggregates).
-      # Every write is recorded against every open ancestor directory.
-      # `push_directory`/`pop_and_prune` are the same operation split for non-adjacent writes.
-      def track_directory(dir)
-        push_directory(dir)
-        yield
-      ensure
-        pop_and_prune(dir)
-      end
-
+      # Starts recording every path written or confirmed unchanged inside `dir`, against every open
+      # ancestor directory too; `pop_and_prune` closes it and deletes the files never touched.
       def push_directory(dir)
         FileUtils.mkdir_p(dir)
         stack.push([File.expand_path(dir), Set.new])
@@ -56,6 +48,7 @@ module Hecks
       # Returns whether it wrote.
       def call(path, content)
         record_touch(path)
+        content = RustFormat.call(content) if RustFormat.rust?(path)
         # `.b` on both sides: String#== is encoding-aware, so UTF-8 vs ASCII-8BIT
         # content can compare unequal even when the bytes are identical.
         return false if File.exist?(path) && File.binread(path) == content.b
@@ -64,13 +57,20 @@ module Hecks
         true
       end
 
+      # Fills `tmp` from the block, then lays it out with rustfmt when `path` is Rust source.
+      def write_formatted(tmp, path, &)
+        File.open(tmp, "w", &)
+        File.write(tmp, RustFormat.call(File.read(tmp))) if RustFormat.rust?(path)
+      end
+      private_class_method :write_formatted
+
       # Like `call`, for callers that build content by writing to an IO. Yields a sibling
       # temp file, then renames it into place only if the bytes differ. Returns whether it wrote.
       def block(path, &)
         record_touch(path)
         tmp = "#{path}.tmp-#{Process.pid}-#{rand(1_000_000)}"
         begin
-          File.open(tmp, "w", &)
+          write_formatted(tmp, path, &)
           changed = !(File.exist?(path) && FileUtils.compare_file(tmp, path))
           FileUtils.mv(tmp, path) if changed
           changed

data/lib/hecks/rust_format.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Hecks
+  # Runs generated Rust through rustfmt, so a generator writes what `cargo fmt --check` accepts.
+  #
+  # Every generator that writes a `.rs` file formats its text here before comparing it with the tree
+  # or writing it, so a drift check and a write see the same bytes. The edition is pinned in the
+  # call, not read from a `rustfmt.toml`, because a generator may run from any directory.
+  module RustFormat
+    # Raised when the rustfmt program cannot be found.
+    class Missing < StandardError; end
+
+    # Raised when rustfmt fails for a reason that is not the text: a toolchain that will not
+    # install, say. Falling back to the unformatted text would write the wrong bytes without a word.
+    class Failed < StandardError; end
+
+    EDITION = "2021"
+
+    # The most passes `call` makes; a text still changing after them keeps the last result.
+    PASSES = 3
+
+    module_function
+
+    # @param path [String] where the text will be written
+    # @return [Boolean] whether the path is Rust source
+    def rust?(path)
+      path.to_s.end_with?(".rs")
+    end
+
+    # Formats one Rust source text.
+    #
+    # Text rustfmt cannot parse is returned as it came, with a warning on stderr: the compiler will
+    # name the real fault, and a generator should not be the thing that hides it. Any other failure
+    # of rustfmt raises, since the text is not the problem.
+    #
+    # @param text [String] Rust source
+    # @return [String] the same source as rustfmt lays it out
+    # @raise [Missing] when rustfmt is not installed
+    # @raise [Failed] when rustfmt fails for a reason other than the text
+    def call(text)
+      PASSES.times do
+        formatted = pass(text)
+        return formatted if formatted == text
+
+        text = formatted
+      end
+      text
+    end
+
+    # One rustfmt run. rustfmt does not always reach a fixed point in one pass, so `call` repeats it
+    # until the text stops changing, as a later `cargo fmt --check` would have it.
+    #
+    # @param text [String] Rust source
+    # @return [String] the source after one pass, or unchanged when rustfmt cannot parse it
+    # @raise [Failed] when rustfmt fails for a reason other than the text
+    def pass(text)
+      out, err, status = Open3.capture3("rustfmt", "--edition", EDITION, "--emit", "stdout", stdin_data: text)
+      return out if status.success?
+      raise Failed, "rustfmt failed: #{err.lines.first&.strip}" unless err.include?("<stdin>")
+
+      warn "hecks: rustfmt could not format generated Rust, leaving it as generated: #{err.lines.first&.strip}"
+      text
+    rescue Errno::ENOENT
+      raise Missing, "rustfmt is not installed: generated Rust is formatted with it; run `rustup component add rustfmt`"
+    end
+
+    # Formats the Rust texts of a path-to-text map and leaves the others alone.
+    #
+    # @param content [Hash{String => String}] absolute path to text
+    # @return [Hash{String => String}] the same map with each `.rs` text formatted
+    def files(content)
+      content.to_h { |path, text| [path, rust?(path) ? call(text) : text] }
+    end
+  end
+end

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

@@ -129,14 +129,14 @@ Hecks.bluebook "Site" do
     identified_by :run
 
     value_object "RunKey" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
 
       invariant("a run is named") { !value.to_s.empty? }
     end
 
     # A project directory, whose `bluebook/` holds the chapter that declares the route table.
     value_object "DomainPath" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
 
       invariant("a project is named by its path") { !value.to_s.empty? }
     end
@@ -144,7 +144,7 @@ Hecks.bluebook "Site" do
     # A directory or file anywhere on disk, relative to where the command runs: where routes.ts is
     # written when not in the project's generated/ directory, or the template to rewrite in place.
     value_object "Location" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # The file extension of the generated module: `ts` (routes.ts), or `mts` (routes.mts), which
@@ -164,12 +164,12 @@ Hecks.bluebook "Site" do
 
     # Path patterns, comma separated: the behaviours a change is about to add to the live distribution.
     value_object "PathList" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # Policy references and the ids they stand for live, as `!Ref Name=id`, comma separated.
     value_object "PolicyRefs" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # A running site's address, `https://example.org`: what `check_site` sends its requests to.

data/lib/hecks/sme/bluebook/sme.bluebook

@@ -30,37 +30,37 @@ Hecks.bluebook "SME" do
     attribute :accepted_actions, Tally
 
     value_object "Reference" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
     end
 
     # The domain being discovered, spelled as its bluebook will spell it. Many interviews, with
     # different experts on different days, name the same subject; the domain is not modelled here.
     value_object "Subject" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
     end
 
     # Who is being interviewed.
     value_object "Expert" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     value_object "Question" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # The expert's answer in their own words.
     value_object "Answer" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # A label for grouping exchanges ("lending rules"); optional on every exchange.
     value_object "Topic" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     value_object "Exchange" do
-      attribute :question, String, pattern: '[^\t\n\r]'
-      attribute :answer,   String, pattern: '[^\t\n\r]'
+      attribute :question, String, matches: :not_empty
+      attribute :answer,   String, matches: :not_empty
       attribute :topic,    String, optional: true
     end
 
@@ -76,7 +76,7 @@ Hecks.bluebook "SME" do
     end
 
     value_object "Name" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
     end
 
     # How many findings of a kind were accepted.
@@ -86,7 +86,7 @@ Hecks.bluebook "SME" do
     end
 
     value_object "Statement" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # Whether an action brings its thing into being, as opposed to happening to one that exists.
@@ -97,12 +97,12 @@ Hecks.bluebook "SME" do
     # A list the expert gave in a breath, comma separated: the values a field may take, or the
     # fields an action needs to be told. Absent when the expert gave none.
     value_object "Listing" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # Who may do an action, in the expert's words ("a maintainer", "QA engineer").
     value_object "Actor" do
-      attribute :value, String, pattern: '[^\t\n\r]'
+      attribute :value, String, matches: :not_empty
     end
 
     # A thing the domain keeps track of, and the field that identifies one: an aggregate to be.

data/lib/hecks/tickets/bluebook/tickets.bluebook

@@ -32,7 +32,7 @@ Hecks.bluebook "Tickets" do
     identified_by :finding
 
     value_object "FindingKey" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
 
       invariant("a finding is named") { !value.to_s.empty? }
     end
@@ -65,7 +65,7 @@ Hecks.bluebook "Tickets" do
     # The same finding refiled by the QA loop carries the same fingerprint, so a report of it while an
     # open finding holds it changes nothing.
     value_object "Fingerprint" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
     end
 
     value_object "Number" do
@@ -239,7 +239,7 @@ Hecks.bluebook "Tickets" do
     end
 
     value_object "FindingKey" do
-      attribute :value, String, pattern: '[^ \t\n\r]'
+      attribute :value, String, matches: :present
     end
 
     lifecycle :status, default: "draft" do

data/lib/hecks/tools/fuzz_sweep/findings.rb

@@ -48,19 +48,13 @@ module Hecks
           failure[:message].split("; ").all? { |chunk| matchers.any? { |regex| regex.match?(chunk) } }
         end
 
-        # Skips only exact, already-tracked wiring gaps; any other WiringError is re-raised.
+        # Skips only exact, already-tracked wiring gaps (`SKIPPED_DOMAIN_REASONS`); none is tracked
+        # now, so any WiringError is re-raised.
         #
         # @param error [Hecks::Runtime::WiringError] what generating a sequence raised
         # @return [Symbol] a key of `SKIPPED_DOMAIN_REASONS`
         def known_unfuzzable_wiring_gap(error)
-          case error.message
-          when %r{a compute/rekey rule is declared}
-            # compute/rekey needs an era/Postgres migration, so it cannot boot under IsolatedBoot's
-            # Memory rebind. Real coverage lives in spec/adapters/driven/postgres_era/*_spec.rb.
-            :skip_compute_rekey
-          else
-            raise error
-          end
+          raise error
         end
 
         # Shrinks steps, then arguments, keeping a removal only while the same finding reproduces.

data/lib/hecks/tools/fuzz_sweep.rb

@@ -29,9 +29,7 @@ module Hecks
       KNOWN_FUZZ_FINDINGS = {}.freeze
 
       # Why a domain is skipped, by the reason `known_unfuzzable_wiring_gap` answers.
-      SKIPPED_DOMAIN_REASONS = {
-        skip_compute_rekey: "declares compute/rekey, which only an era/Postgres-bound boot can interpret"
-      }.freeze
+      SKIPPED_DOMAIN_REASONS = {}.freeze
 
       # The persistence an ephemeral boot may use.
       ADAPTERS = %i[memory sqlite postgres].freeze

data/lib/hecks/tools/translation_audit/verdicts.rb

@@ -30,17 +30,14 @@ module Hecks
         end
 
         # @return [Integer] the exit status
-        def conclude(db, lineage, edge, failed, approve)
+        def conclude(db, failed)
+          db.close
           if failed
-            db.close
             puts "AUDIT REFUSED."
             return 1
           end
 
-          needs_approval = edge.aggregates.any? { |declared| !declared.computes.empty? || !declared.rekeys.empty? }
-          record_approval(lineage, edge) if needs_approval && approve
-          db.close
-          print_passed(needs_approval, approve)
+          puts "AUDIT PASSED — review the samples above; intent is yours to approve."
           0
         end
 
@@ -79,28 +76,6 @@ module Hecks
           puts "     before: #{JSON.generate(sample[:before])}" if sample[:before]
           puts "     after:  #{JSON.generate(sample[:after])}" if sample[:after]
         end
-
-        # Binds to what was reviewed — this edge and the journal as it stands now — so it must
-        # live in the database, not the repo.
-        def record_approval(lineage, edge)
-          lineage.record_approval!(
-            from: edge.from, to: edge.to,
-            edge_digest: Hecks::Translation::Audit.edge_digest(edge)
-          )
-        end
-
-        def print_passed(needs_approval, approve)
-          if needs_approval && approve
-            puts "AUDIT PASSED — approval recorded in the database, bound to this edge and this journal."
-            puts "A journal that advances before the mint invalidates it; re-run with --approve if that happens."
-          elsif needs_approval
-            puts "AUDIT PASSED — this edge carries a compute or rekey rule, and the samples above are " \
-                 "its ONLY verification."
-            puts "If they show what you intended, run again with --approve; the mint refuses until you do."
-          else
-            puts "AUDIT PASSED — review the samples above; intent is yours to approve."
-          end
-        end
       end
     end
   end

data/lib/hecks/tools/translation_audit.rb

@@ -12,13 +12,12 @@ require_relative "translation_audit/verdicts"
 module Hecks
   module Tools
     # Runs the translation audit's three layers standalone against a domain's latest or pending
-    # edge. Read-only except `--approve`, which records the human approval in the database.
+    # edge. Read-only.
     #
-    #   hecks audit_translation <domain> [--approve]
+    #   hecks audit_translation <domain>
     module TranslationAudit
-      # What one audit run works on: the loaded domain, its open journal, and whether `--approve`
-      # was given.
-      Session = Struct.new(:registry, :bluebook, :directory, :db, :lineage, :approve)
+      # What one audit run works on: the loaded domain and its open journal.
+      Session = Struct.new(:registry, :bluebook, :directory, :db, :lineage)
 
       extend DomainLoading
       extend Edges
@@ -28,18 +27,17 @@ module Hecks
 
       # Audits the edge and prints each aggregate's verdict and samples.
       #
-      # @param argv [Array<String>] the domain directory, and `--approve` to record approval
+      # @param argv [Array<String>] the domain directory
       # @param root [String] unused: the domain is read from the path given
       # @return [Integer] 0 when the audit passes or there is no edge, 1 when it is refused
       # @raise [SystemExit] when the domain cannot be loaded or is not lineage-capable
       def main(argv, **)
         argv = argv.dup
-        approve = argv.delete("--approve")
-        domain_path = argv.shift or abort "usage: hecks audit_translation <domain> [--approve]"
+        domain_path = argv.shift or abort "usage: hecks audit_translation <domain>"
 
         registry, bluebook, directory = load_domain(domain_path)
         db, lineage = open_lineage(registry, bluebook)
-        audit(Session.new(registry, bluebook, directory, db, lineage, approve))
+        audit(Session.new(registry, bluebook, directory, db, lineage))
       end
 
       # @param session [Session] the loaded domain and its open journal
@@ -59,7 +57,7 @@ module Hecks
 
         edge = chain.last[:translation]
         failed = report(session.bluebook, session.lineage, edge, era, chain)
-        conclude(session.db, session.lineage, edge, failed, session.approve)
+        conclude(session.db, failed)
       end
 
       # A journal with no era yet holds the bluebook as its first, so there is no edge to audit.

data/lib/hecks/tools/translation_scaffold/reporting.rb

@@ -31,7 +31,7 @@ module Hecks
               "Check it with hecks audit_translation, then boot."
           elsif unresolved.positive?
             "#{unresolved} unresolved — decide what each became (rename/move/convert/drop, or " \
-              "compute on PostgresEra), then boot."
+              "derive), then boot."
           end
         end
       end

data/lib/hecks/version.rb

@@ -1,5 +1,5 @@
 module Hecks
   # Read directly by the gemspec, so this file must never require the
   # rest of the gem (its dependencies aren't resolved yet at that point).
-  VERSION = "3.13.0".freeze
+  VERSION = "4.0.0".freeze # rust/host/HECKS_RELEASE names the same release
 end

data/lib/hecks/vocabulary.rb

@@ -412,7 +412,6 @@ module Hecks
         {"script"=>"backfill_era_projections", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"backfill_projections"}.freeze,
         {"script"=>"scaffold_translation", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"scaffold_translation"}.freeze,
         {"script"=>"translation_audit", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"audit_translation"}.freeze,
-        {"script"=>"translation_audit", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"approve_translation"}.freeze,
         {"script"=>"compact", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"compact"}.freeze,
         {"script"=>"heki_compact", "section"=>"Custodian", "aggregate"=>"Era", "verb"=>"compact_heki"}.freeze,
         {"script"=>"vendor_bluebook", "section"=>"Custodian", "aggregate"=>"Package", "verb"=>"vendor", "note"=>"waits: a refusal exits 1 with its reason on stderr"}.freeze,
@@ -514,6 +513,8 @@ module Hecks
       ].freeze,
       "RustReservedWord" => [
         {"word"=>"as"}.freeze,
+        {"word"=>"async"}.freeze,
+        {"word"=>"await"}.freeze,
         {"word"=>"break"}.freeze,
         {"word"=>"const"}.freeze,
         {"word"=>"continue"}.freeze,

data/lib/hecks.rb

@@ -45,6 +45,9 @@ Hecks.autoload(:Corpus, File.expand_path("hecks/corpus", __dir__))
 # The chapters a hecksagon can `attaches` by name (ADR 0080); loads on first use.
 Hecks.autoload(:Chapters, File.expand_path("hecks/chapters", __dir__))
 
+# The Composer's staging, parse stage and check; loads on first use.
+Hecks.autoload(:Composer, File.expand_path("hecks/composer", __dir__))
+
 # Root namespace and public facade of the DSL/runtime: `Hecks.boot`/`.boot_files`
 # assemble a running domain from `.bluebook`/`.hecksagon`/`.world` files.
 module Hecks