hecks 3.14.0 → 5.0.0

data/lib/hecks/forms/field_shape.rb

@@ -3,6 +3,7 @@ require_relative "../bluebook/attribute"
 require_relative "../naming"
 require_relative "value_object_shape"
 require_relative "text_shape"
+require_relative "rule_words"
 
 module Hecks
   # The forms surface: the `expose` DSL, the IR->HTML renderers and the Rack app (see forms.rb).
@@ -32,9 +33,20 @@ module Hecks
         Naming.words(segment)
       end
 
-      # "amount.cents" -> "Amount → Cents", for a fieldset legend spanning several hops.
-      def self.breadcrumb(path)
-        path.to_s.split(".").map { |part| label(part) }.join(" → ")
+      # A code name as a phrase: "AddTopping" -> "Add topping", "Order" -> "Order".
+      #
+      # @param name [String, Symbol, #to_s] a command, query or aggregate name
+      # @return [String] the sentence-cased words
+      def self.phrase(name) = Naming.words(name)
+
+      # A code name as words inside a sentence: "BankAccount" -> "bank account", "ATMCard" ->
+      # "ATM card".
+      #
+      # @param name [String, Symbol, #to_s] an aggregate or field name
+      # @return [String] the words, the first lowercased unless it is an acronym
+      def self.noun(name)
+        words = Naming.words(name)
+        words.match?(/\A[A-Z]{2,}\b/) ? words : words.sub(/\A./, &:downcase)
       end
     end
 
@@ -79,12 +91,8 @@ module Hecks
 
       def self.reference_field(attribute, common)
         target = attribute.type.resolve
-        Field.new(**common, kind: :reference, html_type: "text", target_aggregate: target,
-                            help: if target
-                                    "References an existing #{target.hecks_name} by id."
-                                  else
-                                    "References an aggregate in another domain — enter its id."
-                                  end)
+        help = target ? "An existing #{Humanize.noun(target.hecks_name)}, by its id." : "A record in another domain, by its id."
+        Field.new(**common, kind: :reference, html_type: "text", target_aggregate: target, help: help)
       end
 
       # Mirrors Runtime::Value::Admission#admitted_members (same split, chapter walk and
@@ -119,16 +127,26 @@ module Hecks
         return closed_set_field(shape, common) if shape.closed_set?
         return money_field(shape, common) if ValueObjectShape.money?(shape)
 
-        # A single-attribute value object names a scalar, not a group: unwrap it so the form
-        # asks for one thing and the inner attribute's own pattern drives the input type.
-        if (inner = ValueObjectShape.sole_attribute(shape))
-          return resolve(inner, aggregate: aggregate, path: "#{common[:path]}.#{inner.name}")
-                 .tap { |field| field.optional = common[:optional] || field.optional }
-        end
+        inner = ValueObjectShape.sole_attribute(shape)
+        return sole_attribute_field(shape, inner, aggregate, common) if inner
 
         group_field(shape, aggregate, common)
       end
 
+      # A single-attribute value object names a scalar, not a group: unwrap it so the form
+      # asks for one thing and the inner attribute's own pattern drives the input type. The
+      # label stays the command's own name for it (`topping`), never the inner `value`, and
+      # the help says what the value object's rules accept.
+      #
+      # @return [Forms::Field] the inner attribute's field at the dotted path
+      def self.sole_attribute_field(shape, inner, aggregate, common)
+        field = resolve(inner, aggregate: aggregate, path: "#{common[:path]}.#{inner.name}")
+        field.label = common[:label]
+        field.optional = common[:optional] || field.optional
+        field.help = RuleWords.describe(inner, shape.invariants) if field.leaf? && field.kind != :reference
+        field
+      end
+
       def self.cross_aggregate_value_object(aggregate, type_name)
         aggregate.hecks_owner&.aggregates&.each do |sibling|
           found = sibling.value_object(type_name)
@@ -145,10 +163,10 @@ module Hecks
       def self.money_field(shape, common)
         cents = Field.new(path: "#{common[:path]}.cents", label: "Amount (cents)", kind: :number,
                           html_type: "number", step: "1", optional: common[:optional],
-                          default: shape.attribute(:cents)&.default, help: "Whole cents — 1050 is $10.50.")
+                          default: shape.attribute(:cents)&.default, help: "In cents: 1050 is $10.50.")
         currency = Field.new(path: "#{common[:path]}.currency", label: "Currency", kind: :text, html_type: "text",
                              optional: true, default: shape.attribute(:currency)&.default || "USD",
-                             help: "Three-letter code.")
+                             help: "Three-letter code, such as USD.")
         Field.new(path: common[:path], label: common[:label], kind: :money, optional: common[:optional],
                   children: [cents, currency])
       end
@@ -173,6 +191,7 @@ module Hecks
       end
 
       def self.primitive_field(attribute, common)
+        common = common.merge(help: RuleWords.describe(attribute))
         case attribute.type.to_s
         when "Integer" then Field.new(**common, kind: :number, html_type: "number", step: "1")
         when "Float"   then Field.new(**common, kind: :number, html_type: "number", step: "any")

data/lib/hecks/forms/index_renderer.rb

@@ -1,4 +1,5 @@
 require_relative "html"
+require_relative "field_shape"
 
 module Hecks
   module Forms
@@ -40,7 +41,7 @@ module Hecks
                  "#{aggregate.queries.size} quer#{aggregate.queries.size == 1 ? "y" : "ies"}"
         <<~HTML
           <li><a href="/#{Escape.attr(name)}/#{Escape.attr(aggregate.hecks_name)}.html">
-            <span>#{Escape.html(aggregate.hecks_name)}</span><span class="kind">#{Escape.html(counts)}</span>
+            <span>#{Escape.html(Humanize.phrase(aggregate.hecks_name))}</span><span class="kind">#{Escape.html(counts)}</span>
           </a></li>
         HTML
       end

data/lib/hecks/forms/page.rb

@@ -35,7 +35,7 @@ module Hecks
           #{body}
           </main>
           <footer class="site-footer">
-            <p>Generated straight from the loaded bluebook IR — nothing here is hand-authored per page. See <code>docs/command-form-and-query-form-bluebook.md</code>.</p>
+            <p>Every page here is generated from the domain's description (its bluebook). None is written by hand.</p>
           </footer>
           <script>#{SCRIPT}</script>
           </body>

data/lib/hecks/forms/params.rb

@@ -203,19 +203,6 @@ module Hecks
         end
         into
       end
-
-      # Renders held values as a URL query string, percent-encoding each flattened path and
-      # value.
-      #
-      # @param fields [Array<Forms::Field>] the field tree naming which paths to read
-      # @param values [Hash{String, Symbol => Object}] held values, flat or nested; see
-      #   `FieldRenderer.dig`
-      # @return [String] `key=value` pairs joined with `&`, without a leading `?`; `""` when
-      #   `flatten` yields no pairs
-      def self.to_query_string(fields, values)
-        pairs = flatten(fields, values)
-        pairs.map { |key, value| "#{URI.encode_www_form_component(key)}=#{URI.encode_www_form_component(value)}" }.join("&")
-      end
     end
   end
 end

data/lib/hecks/forms/query_form_renderer.rb

@@ -22,7 +22,7 @@ module Hecks
         reference_options = ReferenceOptions.collect(registry, domain, fields)
 
         <<~HTML
-          #{header(domain, aggregate, query)}
+          #{header(query)}
           #{canonical_link(action, fields)}
           #{quick_links(action, fields)}
           #{filter_form(action, fields, view.fetch(:params, {}), reference_options)}
@@ -32,9 +32,9 @@ module Hecks
         HTML
       end
 
-      def self.header(domain, aggregate, query)
+      def self.header(query)
         <<~HTML
-          <h1>#{Escape.html("#{domain}::#{aggregate.hecks_name}.#{query.hecks_name}")}</h1>
+          <h1>#{Escape.html(Humanize.phrase(query.hecks_name))}</h1>
           #{%(<p class="goal">#{Escape.html(query.description)}</p>) if query.description}
           #{badges(query)}
         HTML
@@ -50,7 +50,7 @@ module Hecks
         paths = Params.paths(fields)
         template = paths.empty? ? action : "#{action}?#{paths.map { |path| "#{path}={#{path}}" }.join("&")}"
         <<~HTML
-          <p class="help">Every query is a plain GET — this exact URL is bookmarkable, linkable from a dashboard, curlable, whatever a feature needs:</p>
+          <p class="help">This query is a plain link. Bookmark it, share it, or put it on a dashboard:</p>
           <div class="link-row"><code id="canonical-link">#{Escape.html(template)}</code><button type="button" class="copy" data-copy="#canonical-link">copy</button></div>
         HTML
       end
@@ -81,7 +81,8 @@ module Hecks
       def self.error_banner(error)
         return "" unless error
 
-        %(<div class="error-banner" role="alert"><p><strong>#{Escape.html(error.class.name.split("::").last)}</strong> — ) \
+        kind = Escape.html(error.class.name.split("::").last)
+        %(<div class="error-banner" role="alert"><p><strong>Refused (#{kind}):</strong> ) \
           "#{Escape.html(error.message)}</p></div>"
       end
 
@@ -96,7 +97,7 @@ module Hecks
         paths = Params.paths(fields)
         <<~HTML
           <details class="inspect">
-            <summary>Inspect — #{Escape.html(verb)}</summary>
+            <summary>Inspect: #{Escape.html(verb)}</summary>
             <p>Parameters: #{paths.empty? ? "<em>none</em>" : paths.map { |p| "<code>#{Escape.html(p)}</code>" }.join(", ")}</p>
             <pre>#{Escape.html(JSON.pretty_generate(query.to_h))}</pre>
           </details>

data/lib/hecks/forms/record_renderer.rb

@@ -11,7 +11,7 @@ module Hecks
       def self.index(registry:, domain:, aggregate:)
         instances = registry.repository(domain, aggregate).all
         <<~HTML
-          <h1>#{Escape.html("#{domain}::#{aggregate.hecks_name}")}</h1>
+          <h1>#{Escape.html(Naming.plural(Humanize.phrase(aggregate.hecks_name)))}</h1>
           #{%(<p class="goal">#{Escape.html(aggregate.description)}</p>) if aggregate.description}
           #{creating_links(domain, aggregate)}
           <h2>Records (#{instances.size})</h2>
@@ -26,7 +26,7 @@ module Hecks
 
         links = creators.map do |cmd|
           %(<a class="button" href="/#{domain}/#{aggregate.hecks_name}/#{cmd.hecks_name}.html">) \
-            "+ #{Escape.html(cmd.hecks_name)}</a>"
+            "+ #{Escape.html(Humanize.phrase(cmd.hecks_name))}</a>"
         end
         %(<div class="actions">#{links.join}</div>)
       end
@@ -40,7 +40,7 @@ module Hecks
         state = instance.state
         current = aggregate.lifecycle && state[aggregate.lifecycle.field]
         <<~HTML
-          <h1>#{Escape.html("#{domain}::#{aggregate.hecks_name}")} <span class="mono">#{Escape.html(id)}</span></h1>
+          <h1>#{Escape.html(Humanize.phrase(aggregate.hecks_name))} <span class="mono">#{Escape.html(id)}</span></h1>
           #{lifecycle_badge(aggregate, current)}
           #{state_table(state)}
           <h2>Commands</h2>
@@ -76,7 +76,8 @@ module Hecks
       # Omits lifecycle transitions that dispatch would refuse from the current state.
       def self.command_links(domain, aggregate, id, current_state)
         commands = aggregate.commands.reject(&:creates?).select { |cmd| applies?(aggregate, cmd, current_state) }
-        return "<p><em>No commands act on an existing #{Escape.html(aggregate.hecks_name)}.</em></p>" if commands.empty?
+        noun = Escape.html(Humanize.noun(aggregate.hecks_name))
+        return "<p><em>No commands act on an existing #{noun}.</em></p>" if commands.empty?
 
         items = commands.map { |cmd| command_item(domain, aggregate, cmd, id) }
         %(<ul class="verb-list">#{items.join}</ul>)
@@ -86,7 +87,7 @@ module Hecks
       def self.command_item(domain, aggregate, cmd, id)
         # The id is free-form, so it is percent-encoded as a query value.
         href = "/#{domain}/#{aggregate.hecks_name}/#{cmd.hecks_name}.html?to=#{Escape.url(id)}"
-        %(<li><a href="#{Escape.attr(href)}"><span>#{Escape.html(cmd.hecks_name)}</span>) \
+        %(<li><a href="#{Escape.attr(href)}"><span>#{Escape.html(Humanize.phrase(cmd.hecks_name))}</span>) \
           "<span class=\"kind\">#{Escape.html(cmd.goal.to_s)}</span></a></li>"
       end
 
@@ -110,15 +111,18 @@ module Hecks
 
         cmd_items = commands.map { |c| verb_item(domain, aggregate, c, "command") }
         query_items = aggregate.queries.map { |q| verb_item(domain, aggregate, q, "query") }
-        %(<h2>Every command &amp; query on #{Escape.html(aggregate.hecks_name)}</h2>) \
+        %(<h2>Commands and queries for #{plural_noun(aggregate)}</h2>) \
           "<ul class=\"verb-list\">#{(cmd_items + query_items).join}</ul>"
       end
 
       # @param kind [String] the word shown beside the verb, `"command"` or `"query"`
       # @return [String] the list item linking to the verb's own page
+      # @return [String] the aggregate's name as a lowercase plural, HTML-escaped: "orders"
+      def self.plural_noun(aggregate) = Escape.html(Naming.plural(Humanize.noun(aggregate.hecks_name)))
+
       def self.verb_item(domain, aggregate, verb, kind)
         %(<li><a href="/#{domain}/#{aggregate.hecks_name}/#{verb.hecks_name}.html">) \
-          "<span>#{Escape.html(verb.hecks_name)}</span><span class=\"kind\">#{kind}</span></a></li>"
+          "<span>#{Escape.html(Humanize.phrase(verb.hecks_name))}</span><span class=\"kind\">#{kind}</span></a></li>"
       end
     end
   end

data/lib/hecks/forms/rule_words.rb

@@ -0,0 +1,100 @@
+require_relative "../bluebook/named_pattern"
+
+module Hecks
+  module Forms
+    module FieldShape
+      # Says in plain words what a field accepts, read only from what the bluebook declares:
+      # the attribute's type, its named `matches:` pattern, and the invariants of the value
+      # object it sits in. An invariant this module cannot read is quoted by its own
+      # description rather than guessed at.
+      module RuleWords
+        # Words for each `Bluebook::NamedPattern` name; a raw regex has none and is not shown.
+        PATTERN_WORDS = {
+          present:       "Must not be blank.",
+          not_empty:     "Must not be empty.",
+          no_whitespace: "No spaces.",
+          snake_name:    "Lowercase letters, digits and underscores, starting with a letter.",
+          git_sha:       "A commit id: 7 to 40 hexadecimal characters.",
+          digits:        "Digits only."
+        }.freeze
+
+        # The noun a numeric type reads as, for "A whole number above zero."
+        NUMBER_NOUNS = { "Integer" => "A whole number", "Float" => "A number" }.freeze
+
+        # One comparison of the attribute against a literal number, as its canonical source
+        # spells it: `value > 0`, `cents >= 0`.
+        COMPARISON = /\A(?<name>\w+) (?<op>>=|<=|>|<) (?<bound>-?\d+(?:\.\d+)?)\z/
+
+        # How each comparison reads after the noun: "above 5", "10 or less".
+        BOUND_WORDS = { ">" => "above %s", ">=" => "%s or more", "<" => "below %s", "<=" => "%s or less" }.freeze
+
+        module_function
+
+        # Describes what `attribute` accepts, or nil when nothing declared can be said in words.
+        #
+        # @param attribute [Bluebook::Attribute] the scalar attribute the field asks for
+        # @param invariants [Array<Bluebook::Invariant>] the rules of the value object that
+        #   wraps `attribute`; empty for a bare attribute
+        # @return [String, nil] one or more sentences, such as "A whole number above zero."
+        def describe(attribute, invariants = [])
+          readable, quoted = invariants.partition { |rule| reading(attribute, rule) }
+          sentences = [type_sentence(attribute, readable), pattern_sentence(attribute, readable)]
+          sentences += quoted.map { |rule| "Rule: #{rule.description}." }
+          text = sentences.compact.uniq.join(" ")
+          text.empty? ? nil : text
+        end
+
+        # @return [String, nil] the numeric noun with every readable bound, such as
+        #   "A whole number above zero." or "A whole number, zero or more."; nil for a
+        #   non-numeric attribute
+        def type_sentence(attribute, readable)
+          noun = NUMBER_NOUNS[attribute.type.to_s]
+          return nil unless noun
+
+          bounds = Naming.to_sentence_list(readable.map { |rule| reading(attribute, rule) }.grep_v(:not_blank))
+          return "#{noun}." if bounds.empty?
+
+          "#{noun}#{bounds.start_with?("above", "below") ? " " : ", "}#{bounds}."
+        end
+
+        # @return [String, nil] "Must not be blank." when the named pattern or a readable
+        #   invariant says so, or the named pattern's own words
+        def pattern_sentence(attribute, readable)
+          named = Bluebook::NamedPattern::TABLE.key(attribute.pattern.to_s)
+          return PATTERN_WORDS.fetch(:present) if readable.any? { |rule| reading(attribute, rule) == :not_blank }
+
+          named && PATTERN_WORDS[named]
+        end
+
+        # Reads one invariant over the attribute alone.
+        #
+        # @return [String, Symbol, nil] a bound's words ("above zero"), `:not_blank`, or nil
+        #   when the rule is not one this module can read
+        def reading(attribute, rule)
+          name = attribute.name.to_s
+          canonical = rule.canonical.to_s.strip
+          return :not_blank if blank_check?(name, canonical)
+          return "above zero" if canonical == "#{name}.positive?"
+
+          comparison_words(name, canonical)
+        end
+
+        # @return [Boolean] whether the rule refuses an empty or all-whitespace value
+        def blank_check?(name, canonical)
+          ["!#{name}.to_s.empty?", "!#{name}.to_s.strip.empty?", "!#{name}.empty?", "!#{name}.strip.empty?"]
+            .include?(canonical)
+        end
+
+        # @return [String, nil] the comparison's words, with zero spelled out; nil when the
+        #   rule is not one comparison of `name` against a number
+        def comparison_words(name, canonical)
+          match = COMPARISON.match(canonical)
+          return nil unless match && match[:name] == name
+
+          bound = match[:bound] == "0" ? "zero" : match[:bound]
+          format(BOUND_WORDS.fetch(match[:op]), bound)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/forms/value_object_shape.rb

@@ -1,7 +1,8 @@
 module Hecks
   module Forms
     # Shared value-object shape classification, so callers such as
-    # field_shape.rb, ui_schema.rb and sql_query_builder.rb agree on it.
+    # field_shape.rb and sql_query_builder.rb agree on it. There is no Ruby ui_schema; the Rust
+    # host builds the UI schema (rust/host/src/ui_schema.rs) from the same field-shape rules.
     module ValueObjectShape
       module_function
 

data/lib/hecks/fuzzing/bounded_exhaustive_expressions.rb

@@ -35,9 +35,6 @@ module Hecks
         array:   %w[arr_num arr_str].freeze
       }.freeze
 
-      # Element type per array attribute, so a block parameter gets the right leaf set.
-      ARRAY_ELEMENT_TYPE = { "arr_num" => :numeric, "arr_str" => :string }.freeze
-
       BLOCK_PARAM = "el".freeze
 
       MAX_DEPTH = 3

data/lib/hecks/fuzzing/isolated_boot/worlds.rb

@@ -74,12 +74,9 @@ module Hecks
 
         def hecksagon_names_in(path) = File.read(path).scan(HECKSAGON_NAME).flatten
 
-        # Deletes every `translations/*.bluebook` in the copy. A compute/rekey translation
-        # edge refuses to boot under any non-lineage-capable adapter (only `PostgresEra`
-        # answers `lineage_capable? == true`), so every other mode strips it here rather
-        # than tripping that refusal. Safe to drop: an ephemeral, zero-history boot never
-        # has a pre-existing era-1 row to translate — the edge only matters at mint time,
-        # against a real database, never here.
+        # Deletes every `translations/*.bluebook` in the copy. Safe to drop: an ephemeral,
+        # zero-history boot never has a pre-existing era-1 row to translate; the edge only
+        # matters at mint time, against a real database, never here.
         def strip_translations!(copy)
           Dir.glob(File.join(copy, "**", "translations", "*.bluebook")).each { |path| File.delete(path) }
         end

data/lib/hecks/fuzzing/replay/filters.rb

@@ -1,4 +1,4 @@
-require_relative "../../query_specification/common/comparators"
+require_relative "../../vocabulary"
 require_relative "../../query_specification/common/where_clause"
 require_relative "../../query_specification/field_path"
 require_relative "../../ports/query/in_memory"
@@ -9,10 +9,6 @@ module Hecks
       # Answers the ad hoc `{aggregate:, field:, op:, value:}` filter steps that bypass the
       # declared query DSL.
       module Filters
-        # Mirrors QuerySpecification::Common::COMPARATORS, not the Rust
-        # kernel's own comparator enum, which is missing `none_in_state` and has drifted.
-        FILTER_COMPARATORS = Hecks::QuerySpecification::Common::COMPARATORS.map(&:to_s).freeze
-
         # Answers one ad hoc filter step, the mirror image of kernel/cli.rs's own
         # `run_filter`, calling the same production `Ports::Query::InMemory` rather than
         # re-deriving comparator behavior by hand. Sorted by id ascending regardless,
@@ -31,7 +27,7 @@ module Hecks
 
         # A malformed ad-hoc ask is a fault (C8.3), not a bare RuntimeError.
         def check_comparator!(comparator)
-          return if FILTER_COMPARATORS.include?(comparator)
+          return if Hecks::Vocabulary.fetch("QueryComparator").include?(comparator)
 
           raise Bluebook::Expression::EvaluationError, "unknown query comparator #{comparator.inspect}"
         end

data/lib/hecks/gate/stages.yml

@@ -84,6 +84,20 @@ pre_push:
       title: comment blocks, no run of comment lines past ADR 0075's cap
       run: [bundle, exec, exe/hecks, style_run.check_comments, "paths=lib,spec,examples", only=long_block, --wait]
       blocked: a comment block ran past the cap; shorten it.
+    - &check_rust_fmt
+      id: rust_fmt
+      title: rustfmt, every Rust crate laid out as `cargo fmt` would
+      run:
+        - sh
+        - -ec
+        - |
+          # The main crate's generated modules are not committed, so cargo fmt would stop at a
+          # missing file on a fresh checkout; its hand-written entry points are named instead.
+          rustfmt --check --edition 2021 rust/src/main.rs rust/src/kernel/mod.rs rust/tests/*.rs
+          for crate in parser codegen lsp host web build; do
+            cargo fmt --check --manifest-path "rust/$crate/Cargo.toml"
+          done
+      blocked: a Rust file is not laid out as rustfmt has it; run `cargo fmt` in its crate (rust/src/exemplar is exempt, it is text templates). Generated Rust is laid out by its generators, so fix the generator, not the output.
 
 # The checks a push of only unguarded lanes (`main`) runs in place of pre_push. The slow suite is
 # skipped there; the style checks are not, since an offense that lands on `main` is a red CI run,
@@ -140,6 +154,17 @@ ci:
     - *check_comment_style
     - *check_comment_blocks
     - *check_codegen_drift
+    - *check_rust_fmt
+    - id: rust_clippy
+      title: clippy, every Rust crate with its warnings as errors
+      run:
+        - sh
+        - -ec
+        - |
+          for crate in . parser codegen lsp host web build; do
+            cargo clippy --all-targets --manifest-path "rust/$crate/Cargo.toml" -- -D warnings
+          done
+      blocked: clippy found a warning in a Rust crate, under the strict `[lints.clippy]` table of its Cargo.toml. The main crate needs rust/src/generated, so run `hecks regenerate_corpus --confirm` first on a fresh checkout. Fix the code, or allow a lint at the one site with a line saying why; a warning in generated Rust is fixed in its generator.
     - id: lint_deploy_recipes
       title: generated deploy recipes, a command with no checked exit status or no echo
       run: [bundle, exec, exe/hecks, deploy, makefile_check.lint, --wait]

data/lib/hecks/grammar/evolve/seeds.rb

@@ -157,15 +157,9 @@ module Hecks
         # First `end` after the opener is the block's own — member rows sit bare (ADR 0025).
         def keyword_blocks(source) = seed_blocks(source, "KeywordSeed")
 
-        # The first KeywordSeed block's source text.
-        def keyword_block(source) = seed_block(source, "KeywordSeed", required: true)
-
         # ArgumentSeed blocks; see keyword_blocks for why the first bare end
         # after the opener is already the block's own.
         def argument_blocks(source) = seed_blocks(source, "ArgumentSeed")
-
-        # The first ArgumentSeed block's source text.
-        def argument_block(source) = seed_block(source, "ArgumentSeed", required: true)
       end
     end
   end

data/lib/hecks/grammar/evolve.rb

@@ -96,9 +96,6 @@ module Hecks
         end
       end
 
-      # Narrow compatibility entry point for single-file callers; syntax_paths is normal.
-      def syntax_path = syntax_paths.first
-
       # Resolves the file(s) a call should search or write.
       def paths_for(path) = path ? Array(path) : syntax_paths
 

data/lib/hecks/grammar/translation.bluebook

@@ -23,7 +23,7 @@ Hecks.bluebook "Translation" do
     # "retired" is the edge-level declaration (TranslationBuilder#retired).
     value_object "Kind" do
       attribute :value, String,
-                one_of: ["rename", "move", "convert", "drop", "retype", "retired", "compute", "rekey",
+                one_of: ["rename", "move", "convert", "drop", "retype", "retired", "derive", "rekey_to",
                          "backfill", "unresolved"]
     end
 

data/lib/hecks/hecks/adapters/codebase/composing.rb

@@ -0,0 +1,56 @@
+require_relative "corpus_tasks"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `CorpusRun` asks of the working tree to open the Composer: serve its editor
+      # over one domain directory, on the loopback address only, until the server is stopped.
+      #
+      # The server hook is the one `CorpusTasks` has, so a spec replaces both servers the same way.
+      module Composing
+        # Every operation this family carries out.
+        OPERATIONS = %w[compose].freeze
+
+        # The port the editor listens on when none is named.
+        DEFAULT_PORT = 4570
+
+        # The directory the editor opens when none is named, relative to the checkout.
+        DEFAULT_WORKSPACE = "examples/pizzas/bluebook".freeze
+
+        # The only address the editor binds: it carries no authentication.
+        HOST = "127.0.0.1".freeze
+
+        module_function
+
+        # Opens the editor.
+        #
+        # @param operation [String] `compose`
+        # @param held [Hash] the `CorpusRun` record's fields: `port`, `domains` (the directory)
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @param shell [#capture, nil] unused
+        # @return [String] a note that the server stopped
+        def call(operation, held, tree, shell: nil)
+          _ = [operation, shell]
+          require "hecks/composer/web"
+          fields = held.transform_values { |value| value.is_a?(Hash) ? value[:value] : value }
+          workspace = File.expand_path(fields[:domains] || DEFAULT_WORKSPACE, tree.root)
+          port = fields[:port] || DEFAULT_PORT
+          warn "composer over #{workspace} on http://#{HOST}:#{port}/composer - no authentication, " \
+               "no CSRF protection, no caller identity; do not expose beyond localhost"
+          app = Composer::Web.app(workspace: workspace)
+          (CorpusTasks.web_server || method(:serve)).call(app: app, port: port, host: HOST)
+          "composed on port #{port}, now stopped"
+        end
+
+        # @param app [#call] the Rack app
+        # @param port [Integer] the port
+        # @param host [String] the address to bind
+        # @return [void]
+        def serve(app:, port:, host:)
+          require "rackup"
+          Rackup::Server.start(app: app, Host: host, Port: port, server: "webrick")
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/source_tree.rb

@@ -11,6 +11,7 @@ require_relative "inspection"
 require_relative "codemods"
 require_relative "test_suite"
 require_relative "corpus_tasks"
+require_relative "composing"
 require_relative "publishing"
 require_relative "promotion"
 require_relative "../git"
@@ -183,7 +184,8 @@ module Hecks
       # The task families, each carrying out the operations it lists.
       FAMILIES = [Codebase::Language, Codebase::KernelTables, Codebase::Conformance, Codebase::Regeneration,
                   Codebase::Gate, Codebase::Style, Codebase::Inspection, Codebase::Codemods, Codebase::TestSuite,
-                  Codebase::CorpusTasks, Codebase::Publishing, Codebase::Promotion].freeze
+                  Codebase::CorpusTasks, Codebase::Composing, Codebase::Publishing,
+                  Codebase::Promotion].freeze
       private_constant :FAMILIES
 
       # The facts of a promotion or a watch, naming the operation so policies can tell them apart.

data/lib/hecks/hecks/adapters/first_admin.rb

@@ -57,7 +57,7 @@ module Hecks
         provider = membership_provider
         verbs, gate, people = check_unadministered(provider)
 
-        admitted = people.none? { |person| person.dig(:email, :value) == email }
+        admitted = people.none? { |person| person[:email] == email }
         admit(provider, verbs.fetch(:admit), email, name || email[/\A[^@]+/]) if admitted
         grant(provider, verbs.fetch(:grant), email, role || gate)
         Result.new(email: email, role: role || gate, admitted: admitted)
@@ -103,10 +103,10 @@ module Hecks
       end
 
       def refuse_if_administered!(people, roles)
-        held = people.select { |person| roles.map(&:downcase).include?(person.dig(:role, :value).to_s.downcase) }
+        held = people.select { |person| roles.map(&:downcase).include?(person[:role].to_s.downcase) }
         return if held.empty?
 
-        who = held.map { |person| person.dig(:email, :value) }.join(", ")
+        who = held.map { |person| person[:email] }.join(", ")
         raise Runtime::NotFound, "an administrator already exists (#{who}); grant roles through the " \
                                  "domain's own #{roles.first} access instead"
       end

data/lib/hecks/hecks/adapters/journal_store/changes.rb

@@ -117,32 +117,6 @@ module Hecks
         def apply_compaction(held, kind)
           Compaction.new(plain(held[:domain]), aggregates: names(held[:aggregates]), kind: kind).apply!.join("\n")
         end
-
-        # Writes `translations/<edge>.approval`; the host reads it at its next boot.
-        def apply_approve_translation(held)
-          domain = HeldDomain.open(plain(held[:domain]))
-          finding = domain.reading { |lineage| audited_edge(domain, lineage) }
-          document = approval_document(domain, finding, held)
-          path = Translation::ApprovalFile.write!(domain.directory, finding.edge, document)
-          "approval of edge #{document["edge"]} written to #{path} (digest #{document["edge_digest"][0, 12]}…, " \
-            "by #{document["approved_by"]}). Commit it with the edge; the host applies it at its next boot."
-        end
-
-        def approval_document(domain, finding, held)
-          Translation::ApprovalFile.build(
-            edge: finding.edge, approved_by: Git.new.identity(chdir: domain.directory),
-            approved_at: Time.now.utc.iso8601, rehearsal: rehearsal_block(held)
-          )
-        end
-
-        def audited_edge(domain, lineage)
-          eras = domain.held_eras(lineage)
-          finding = eras.empty? ? nil : EdgeAudit.call(domain, lineage, eras)
-          raise Runtime::WiringError, "#{domain.bluebook.name} has no edge to approve" unless finding
-          raise Runtime::WiringError, "#{finding.report}\nAUDIT REFUSED." unless finding.ok
-
-          finding
-        end
       end
     end
   end