hecks 3.9.1 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d303c552c29899c933f31445d71ea42063a1b7cc5233cdef4a1d7392aa10201c
-  data.tar.gz: caa19c0f1639d2ca386465977a1c099336ee2c1e598399ee3b88122206d3c2b7
+  metadata.gz: 5ab2b4b582c53edd23595354a8db9d84a3a8ec4572d044a77ccfea2ac113c073
+  data.tar.gz: 80af1db86bd574227fc6a03e7d19b9fa1ede9d4fbf54c4934da9211c67a892a2
 SHA512:
-  metadata.gz: 3b2ee56f395214eee7e018c8ba28650b8f5f9ec97cc683b705037e19e37c96246fa4a380bbedb2aec9189ccb0361f3ef5f32e7af07cd5808531c1891e6e3011c
-  data.tar.gz: deb31a80d9d10f30898074608b3158e2e916989160d69cb632777c14dae4305dd2fe43d5da8561024625c0e24175fab7fc7998469854e00f16561ef1e2dd59cf
+  metadata.gz: d28b07fb0b22a96aa8a2dbe2481010c668555a18f256572ee67dc95afb5c517d833cc749718ca804cac68a1ce34e5268e755347ad2d32668ec264d8519d81b08
+  data.tar.gz: 6e823533f842634ad3771ccb994feda57439c9f027aa189e0ff36ba049024fe3c845fd96e3543ce720cb96d6bcaf159604a1279db640f4137ac1e72677d436da

data/lib/hecks/deploy/bluebook/deploy.bluebook

@@ -680,6 +680,112 @@ Hecks.bluebook "Deploy" do
     trigger Recipe::Fault, with: { refusal: :refusal }
   end
 
+  aggregate "Handover" do
+    description "One clearing of a domain's deployment settings: the body of every deployed_to block in its .world emptied, so a project handed to a client holds none of the host's own region, stacks, secrets or domain."
+
+    attribute :domain,  DomainPath
+    attribute :run,     RunKey
+    attribute :out,     Location, optional: true
+    attribute :output,  Report,   optional: true
+    attribute :refusal, Report,   optional: true
+    identified_by :run
+
+    value_object "RunKey" do
+      attribute :value, String, pattern: '[^ \t\n\r]'
+
+      invariant("a run is named") { !value.to_s.empty? }
+    end
+
+    # A domain directory, whose `bluebook/` holds the `.world` that declares `deployed_to`.
+    value_object "DomainPath" do
+      attribute :value, String, pattern: '[^\t\n\r]'
+
+      invariant("a domain is named by its path") { !value.to_s.empty? }
+    end
+
+    # A directory the cleared worlds are written to, at their paths below `bluebook/`, instead of
+    # over the originals.
+    value_object "Location" do
+      attribute :value, String, pattern: '[^\t\n\r]'
+    end
+
+    value_object "Report" do
+      attribute :value, String
+    end
+
+    lifecycle :status, default: "requested" do
+      transition "Complete" => "cleared", from: "requested"
+      transition "Fault"    => "faulted", from: "requested"
+    end
+
+    # `hecks deploy handover.clear <domain> [out=]`. The rest of the file is left as it was, a world
+    # with nothing to clear is answered as cleared with nothing removed, and a domain with no
+    # `.world` file is faulted with the sentence saying so.
+    command "Clear" do
+      goal "Empty the body of every deployed_to block in a domain's .world, keeping the settings' names in a comment"
+
+      attribute :domain, DomainPath
+      attribute :run,    RunKey
+      attribute :out,    Location, optional: true
+
+      sets :domain
+      sets :run
+      sets :out
+
+      emits "ClearingRequested"
+    end
+
+    command "Complete" do
+      goal "Record that the deployment settings were cleared, from which file and which settings"
+
+      reference_to Handover
+      attribute :output, Report
+
+      sets :output
+
+      emits "DeploymentCleared"
+    end
+
+    command "Fault" do
+      goal "Record that the deployment settings could not be cleared, and why"
+
+      reference_to Handover
+      attribute :refusal, Report
+
+      sets :refusal
+
+      emits "ClearingFaulted"
+    end
+
+    query "Outcome" do
+      description "What one clearing did: its status, and the file and settings removed or the reason it stopped."
+      attribute :run, RunKey
+      where(run: :run)
+      order_by :run
+    end
+
+    query "Faulted" do
+      description "Every clearing that could not be done."
+      where(status: "faulted")
+      order_by :run
+    end
+  end
+
+  policy "ClearWhenRequested" do
+    on      "Handover.ClearingRequested"
+    trigger Handover::DeployToolchain::ClearDeployment, with: { run: :run }
+  end
+
+  policy "RecordTheClearing" do
+    on      "Handover.HandoverAnswered"
+    trigger Handover::Complete, with: { output: :output }
+  end
+
+  policy "RecordTheFaultedClearing" do
+    on      "Handover.HandoverRefused"
+    trigger Handover::Fault, with: { refusal: :refusal }
+  end
+
   aggregate "MakefileCheck" do
     description "One lint of generated deploy Makefiles for prod-touching recipes that hide failure."
 

data/lib/hecks/deploy/bluebook/deploy.hecksagon

@@ -27,6 +27,14 @@ Hecks.hecksagon "Deploy" do
     end
   end
 
+  Deploy::Handover.port "DeployToolchain" do
+    asks "ClearDeployment", to: Handover do
+      attribute :run, RunKey
+      answers "HandoverAnswered"
+      refuses "HandoverRefused"
+    end
+  end
+
   Deploy::MakefileCheck.port "DeployToolchain" do
     asks "Scan", to: MakefileCheck do
       attribute :run, RunKey

data/lib/hecks/deploy/oidc.json

@@ -156,6 +156,21 @@
       "verb": "Deploy::FargateTarget.Declare",
       "role": null
     },
+    {
+      "scope": "deploy:handover.clear",
+      "verb": "Deploy::Handover.Clear",
+      "role": null
+    },
+    {
+      "scope": "deploy:handover.complete",
+      "verb": "Deploy::Handover.Complete",
+      "role": null
+    },
+    {
+      "scope": "deploy:handover.fault",
+      "verb": "Deploy::Handover.Fault",
+      "role": null
+    },
     {
       "scope": "deploy:lambda_target.declare",
       "verb": "Deploy::LambdaTarget.Declare",
@@ -367,7 +382,5 @@
       "role": null
     }
   ],
-  "roles": [
-
-  ]
+  "roles": []
 }

data/lib/hecks/hecks/adapters/deploy_toolchain/clearing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../console_capture"
+require_relative "../world_clearing"
+
+module Hecks
+  module Adapters
+    class DeployToolchain
+      # The `ClearDeployment` ask: empties the `deployed_to` blocks of a domain's `.world` files, in
+      # place or into a directory, and says which files and settings it removed.
+      module Clearing
+        # Empties every `deployed_to` block under `<domain>/bluebook/**/*.world`, through
+        # `hecks deploy handover.clear`.
+        #
+        # With `out`, the cleared files are written there at their paths below `<domain>/bluebook/`
+        # and the originals are left alone; without it they are rewritten in place. A world with
+        # nothing left to clear is not rewritten and not listed.
+        #
+        # @param held [Hash] the `Handover` record: `domain`, and `out` when set
+        # @return [Hash{Symbol => Hash}] `output:` one line per file cleared with its settings
+        # @raise [ConsoleCapture::Failure] when the domain holds no `.world` file
+        def clear_deployment(**held)
+          bluebook = File.join(File.expand_path(plain(held[:domain])), "bluebook")
+          out = plain(held[:out])
+          lines = worlds_of(bluebook).filter_map { |path| clear_world(path, bluebook, out && File.expand_path(out)) }
+          { output: { value: lines.empty? ? "no deployed_to settings to clear" : lines.join("\n") } }
+        end
+
+        private
+
+        def worlds_of(bluebook)
+          worlds = Dir.glob(File.join(bluebook, "**", "*.world"))
+          raise ConsoleCapture::Failure, "#{bluebook} holds no .world file to clear" if worlds.empty?
+
+          worlds
+        end
+
+        def clear_world(path, bluebook, out)
+          cleared = WorldClearing.call(File.read(path))
+          return unless cleared.changed?
+
+          target = out ? File.join(out, path.delete_prefix("#{bluebook}/")) : path
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, cleared.text)
+          "#{target}: cleared #{cleared.settings.join(", ")}"
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/deploy_toolchain.rb

@@ -10,6 +10,7 @@ require_relative "deploy_plans"
 require_relative "deploy_toolchain/statuses"
 require_relative "deploy_toolchain/scripts"
 require_relative "deploy_toolchain/answers"
+require_relative "deploy_toolchain/clearing"
 
 module Hecks
   module Adapters
@@ -26,6 +27,7 @@ module Hecks
       include Statuses
       include Scripts
       include Answers
+      include Clearing
 
       # Accepts the arguments every driven adapter is built with and keeps none of them.
       #

data/lib/hecks/hecks/adapters/site_toolchain/role_prober.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require_relative "../../../projections/site/role_probe"
+
+module Hecks
+  module Adapters
+    class SiteToolchain
+      # Dispatches each role-declaring command to a host with no role and no actor, and reports
+      # whether the host refused the caller.
+      #
+      # A host that does not enforce roles would run the command, so this talks only to a host on
+      # this machine: the one a spec or a CI job started for the purpose.
+      class RoleProber
+        # The addresses that name this machine.
+        LOOPBACK = %w[localhost 127.0.0.1 ::1 [::1]].freeze
+
+        # Seconds to wait to connect to the host, and again for its answer.
+        TIMEOUT = 10
+
+        # The failures of the network that fail one check rather than the whole run.
+        NETWORK = [SystemCallError, Timeout::Error, SocketError, JSON::ParserError].freeze
+
+        # @param checks [Array<Projections::Site::RoleProbe::Check>] the commands to dispatch
+        # @param base [String] the host's scheme, host and port
+        # @raise [ConsoleCapture::Failure] when the host is not on this machine
+        def initialize(checks, base:)
+          @checks = checks
+          @uri = URI.parse(base)
+          return if LOOPBACK.include?(@uri.host)
+
+          raise ConsoleCapture::Failure, "roles are checked against a host on this machine, not #{@uri.host}: " \
+                                         "a host that does not enforce roles would run each command"
+        end
+
+        # @return [Array<(String, Integer)>] the report, one line per command ending in the count,
+        #   and how many failed; a command whose synthesized arguments the host refused is counted
+        #   as unchecked, not failed
+        def call
+          lines = @checks.map { |check| judged(check) }
+          failed = lines.count { |_, state| state == :failed }
+          unchecked = lines.count { |_, state| state == :unchecked }
+          summary = "#{lines.size} commands, #{failed} failed, #{unchecked} unchecked"
+          [lines.map(&:first).append(summary).join("\n"), failed]
+        end
+
+        private
+
+        def judged(check)
+          answer = answer_to(check)
+          return [line(check, "unchecked: the host refused the arguments before the role"), :unchecked] if unchecked?(answer)
+
+          why = Projections::Site::RoleProbe.verdict(check, answer)
+          [line(check, why ? "FAILED: #{why}" : "ok"), why ? :failed : :ok]
+        rescue *NETWORK => e
+          [line(check, "FAILED: #{e.class}: #{e.message}"), :failed]
+        end
+
+        def unchecked?(answer) = Projections::Site::RoleProbe.unchecked?(answer)
+
+        def line(check, outcome) = "  #{check.verb} (#{check.role}) is refused with no role... #{outcome}"
+
+        def answer_to(check)
+          request = Net::HTTP::Post.new(URI.join(@uri.to_s, "/dispatch"), "Content-Type" => "application/json")
+          request.body = JSON.generate(verb: check.verb, with: check.arguments)
+          JSON.parse(connection.request(request).body)
+        end
+
+        def connection
+          Net::HTTP.new(@uri.host, @uri.port).tap do |http|
+            http.open_timeout = http.read_timeout = TIMEOUT
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/site_toolchain.rb

@@ -9,6 +9,7 @@ require "hecks/tools"
 require "hecks/tools/site_routes"
 require "hecks/projections/site/live_edge"
 require_relative "site_toolchain/prober"
+require_relative "site_toolchain/role_prober"
 
 module Hecks
   module Adapters
@@ -23,7 +24,8 @@ module Hecks
       SCRIPTS = { project: "project_site" }.freeze
 
       # The tool's flag for each `SiteProjection` field that takes a value.
-      FLAGS = { "out" => :out, "template" => :template, "cms" => :cms, "root" => :root, "extension" => :extension }.freeze
+      FLAGS = { "out" => :out, "template" => :template, "cms" => :cms, "root" => :root, "editor" => :editor,
+                "extension" => :extension }.freeze
 
       # Accepts the arguments every driven adapter is built with and keeps none of them.
       #
@@ -35,7 +37,7 @@ module Hecks
       # Writes a project's `routes.ts` from its declared route table, or with `check` only compares.
       #
       # @param held [Hash] the `SiteProjection` record: `domain`, and `out`, `template`, `cms`,
-      #   `root`, `extension` and `check` when set
+      #   `root`, `editor`, `extension` and `check` when set
       # @return [Hash{Symbol => Hash}] `output:` one line per file written or found current
       # @raise [ConsoleCapture::Failure] when the route table is refused (an unknown cache class,
       #   a duplicate path), a path or the extension is refused, or under `check` a file is out
@@ -84,6 +86,23 @@ module Hecks
         { output: { value: report } }
       end
 
+      # Dispatches every command a project declares a role for to a host with no role and no actor,
+      # and checks the host refuses each as `Unauthorized`. The host must be on this machine and
+      # enforcing roles (`HECKS_ROLE_ENFORCEMENT=enforce`); one that is not would run the commands.
+      #
+      # @param held [Hash] the `SiteProjection` record: `domain`, the project that declares the
+      #   commands, and `url`, the host's base address
+      # @return [Hash{Symbol => Hash}] `output:` one line per command, ending in the count
+      # @raise [ConsoleCapture::Failure] when the host is not on this machine, or a command is not
+      #   refused for its role; the message is the report
+      def roles(**held)
+        checks = Projections::Site::RoleProbe.checks(registry_of(located(:domain, held[:domain])))
+        report, failed = RoleProber.new(checks, base: base_url(plain(held[:url]))).call
+        raise ConsoleCapture::Failure, report if failed.positive?
+
+        { output: { value: report } }
+      end
+
       private
 
       # The scheme, host and port of an http(s) address.
@@ -121,12 +140,18 @@ module Hecks
       # The project's checked route table.
       def table_of(root) = read_table(root).last
 
-      # The registry, chapter and checked table of the project at `root`.
-      def read_table(root)
+      # The registry the project at `root` boots into.
+      def registry_of(root)
         registry = nil
         outcome = ConsoleCapture.capture { registry = Tools::SiteRoutes.registry_for(root) }
         raise ConsoleCapture::Failure, outcome.output.strip unless outcome.ok?
 
+        registry
+      end
+
+      # The registry, chapter and checked table of the project at `root`.
+      def read_table(root)
+        registry = registry_of(root)
         chapter = Projections::Site::Table.chapter(registry)
         [registry, chapter, Projections::Site::Table.read(chapter, registry: registry)]
       rescue Projections::Site::Table::Invalid => e

data/lib/hecks/hecks/adapters/world_clearing.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Adapters
+    # Empties the `deployed_to(...) do ... end` blocks of a `.world` file's text: the region,
+    # stacks, secrets, domain and buckets a host deploys with, which a project handed to a client
+    # must not carry. Each block keeps its opening and closing lines and holds one comment naming
+    # the settings it held, so the file still loads and shows what to set.
+    #
+    # A block closes at the first `end` at its own indent, and a setting is a line one indent
+    # step inside it that starts with its name. A block that holds only comments is already clear
+    # and is left as it is, so clearing twice changes nothing the second time.
+    class WorldClearing
+      BLOCK = /^(?<indent>[ \t]*)deployed_to\b[^\n]*[ \t]do\b[^\n]*\n(?<body>.*?)^\k<indent>end\b[^\n]*\n/m
+
+      # What clearing one world's text produced.
+      #
+      # @!attribute [r] text
+      #   @return [String] the text with every block emptied
+      # @!attribute [r] settings
+      #   @return [Array<String>] the setting names removed, in order, without repeats
+      Result = Struct.new(:text, :settings) do
+        # @return [Boolean] whether any block was emptied
+        def changed? = !settings.empty?
+      end
+
+      # @param text [String] the contents of a `.world` file
+      # @return [Result] the cleared text and the settings that were in the blocks
+      def self.call(text)
+        names = []
+        cleared = text.gsub(BLOCK) { |block| empty(Regexp.last_match, block, names) }
+        Result.new(cleared, names.uniq)
+      end
+
+      # @param match [MatchData] one `deployed_to` block
+      # @param block [String] the block's text
+      # @param names [Array<String>] collects the setting names removed
+      # @return [String] the block's replacement
+      def self.empty(match, block, names)
+        indent = match[:indent]
+        held = match[:body].scan(/^#{indent} {2}([a-z_]\w*)/).flatten
+        return block if held.empty?
+
+        names.concat(held)
+        "#{block.lines.first}#{comment(indent, note(held.uniq))}#{indent}end\n"
+      end
+
+      # @param held [Array<String>] the setting names the block held
+      # @return [String] the comment that stands where the settings were
+      def self.note(held)
+        "The host's deployment settings were removed from this handoff. Set your own: #{held.join(", ")}."
+      end
+
+      # @param indent [String] the block's indent
+      # @param note [String] the sentence to put in the block
+      # @return [String] the sentence as comment lines inside the block, folded under 100 columns
+      def self.comment(indent, note)
+        width = 96 - indent.size
+        note.scan(/(.{1,#{width}})(?:\s+|\z)/).flatten.map { |line| "#{indent}  # #{line}\n" }.join
+      end
+
+      private_class_method :empty, :note, :comment
+    end
+  end
+end

data/lib/hecks/hecks/hecks.hecksagon

@@ -407,6 +407,14 @@ Hecks.hecksagon "Hecks" do
     end
   end
 
+  Deploy::Handover.port "DeployToolchain" do
+    asks "ClearDeployment", to: Handover do
+      attribute :run, RunKey
+      answers "HandoverAnswered"
+      refuses "HandoverRefused"
+    end
+  end
+
   Deploy::MakefileCheck.port "DeployToolchain" do
     asks "Scan", to: MakefileCheck do
       attribute :run, RunKey

data/lib/hecks/hecks/hecks.world

@@ -47,7 +47,8 @@ Hecks.world "Hecks" do
                                   service_roll.run box_roll.run data_copy.restore
                                   data_copy.verify bluebook_diff.run preview_run.name
                                   preview_run.url preview_run.list preview_run.deploy
-                                  preview_run.destroy preview_run.login companion_roll.run],
+                                  preview_run.destroy preview_run.login companion_roll.run
+                                  handover.clear],
                        names: { "mcp" => "door.serve_mcp", "console" => "operation.open_console", "init" => "door.init",
                                 "interview" => "door.interview", "package.check" => "registry.check",
                                 "package.digest" => "registry.digest",

data/lib/hecks/projections/deploy/fargate/settings/tuning.rb

@@ -38,6 +38,7 @@ module Hecks
               plan.domain_env = Check.map!(settings.fetch(:domain_env, {}), "domain_env", nil_ok: true)
               plan.install_dir = install_dir(settings.fetch(:install_dir, DEFAULT_INSTALL_DIR))
               plan.build_context_dir = build_context_dir(settings.fetch(:build_context_dir, ""))
+              plan.host_dir = host_dir(settings.fetch(:host_crate, DEFAULT_HOST_DIR))
             end
 
             def check_execution_grant!(plan)
@@ -62,6 +63,20 @@ module Hecks
               raise ArgumentError, "install_dir must be an absolute path without a trailing slash, got #{value.inspect}"
             end
 
+            # The directory of the Cargo package the Makefile builds `bootstrap` from: an absolute
+            # path, or one relative to the Makefile's `ROOT`. Only path characters are accepted,
+            # since the value is written into a Makefile that shell lines expand.
+            def host_dir(value)
+              text = value.to_s
+              return text if text == DEFAULT_HOST_DIR
+              return text if text.match?(%r{\A/[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*\z})
+              return "$(ROOT)/#{text}" if text.match?(%r{\A[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*\z})
+
+              raise ArgumentError,
+                    "host_crate must be a directory path of letters, digits, . _ - and /, absolute or relative to the " \
+                    "Makefile's ROOT, got #{value.inspect}"
+            end
+
             def build_context_dir(value)
               text = value.to_s
               return text if text.empty? || text.match?(%r{\A[A-Za-z0-9_.-]+(/[A-Za-z0-9_.-]+)*/\z})

data/lib/hecks/projections/deploy/fargate/settings.rb

@@ -19,7 +19,7 @@ module Hecks
           Plan = Struct.new(
             :ids, :names, :layout, :cdn, :alerts, :extras, :execute_command, :health_check_grace_period,
             :deregistration_delay, :desired_count_parameter, :domain_env, :install_dir, :build_context_dir,
-            :db_name_parameter, :execution_database_grant,
+            :db_name_parameter, :execution_database_grant, :host_dir,
             keyword_init: true
           )
 
@@ -37,6 +37,8 @@ module Hecks
           }.freeze
           NAME_ROLES = [:cluster, :log_group, :service, :alb, :family, :alb_security_group_description, :db_secret_policy].freeze
           DEFAULT_INSTALL_DIR = "/usr/local/bin".freeze
+          # Where the generated Makefile builds the host binary unless `host_crate` names another.
+          DEFAULT_HOST_DIR = "$(ROOT)/rust/host".freeze
 
           extend Ids
           extend Tuning

data/lib/hecks/projections/deploy/fargate/stack/readers.rb

@@ -65,6 +65,7 @@ module Hecks
             def vpc_ref = shared ? "!Ref OwningVpcId" : "!Ref #{db_id}Vpc"
             def sidecar_dir = plan.install_dir
             def build_context_dir = plan.build_context_dir
+            def host_dir = plan.host_dir
             def cmd_binary = sidecar_dir == Settings::DEFAULT_INSTALL_DIR ? domain_name : "#{sidecar_dir}/#{domain_name}"
             def desired_count_value = plan.desired_count_parameter ? "!Ref #{plan.desired_count_parameter}" : desired_count
             def declared_domain_literal = declared_domain_name.inspect

data/lib/hecks/projections/deploy/templates/fargate/Makefile.tmpl

@@ -1,8 +1,9 @@
 # GENERATED by hecks deploy project @@domain@@ — re-run it to refresh
 # this file rather than hand-editing.
 #
-# `make deploy` — builds rust/host for this domain, pushes it to this
-# stack's own ECR repository, and deploys the CloudFormation stack.
+# `make deploy` — builds the host for this domain (rust/host, or the
+# directory `host_crate` names), pushes it to this stack's own ECR
+# repository, and deploys the CloudFormation stack.
 # No SAM anywhere in this path.
 
 ROOT       := @@root@@
@@ -11,6 +12,8 @@ STACK      := @@stack_name@@
 BASTION_STACK := @@stack_name@@-bastion
 REGION     := @@region@@
 IMAGE_TAG  := latest
+# The Cargo package `bootstrap` is built from; `make HOST_DIR=<dir>` builds another.
+HOST_DIR   ?= @@host_dir@@
 
 build:
 # aarch64, not x86_64 — matches template.yaml's own
@@ -33,8 +36,8 @@ build:
 # rust/dist/@@domain_name@@.wasm/.ir.json from this domain's own
 # .bluebook.
 	cd $(ROOT) && HECKS_ENVIRONMENT=memory ruby exe/hecks build.build_wasm domain=$(DOMAIN) --wait
-	cd $(ROOT)/rust/host && CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc rustup run stable cargo build --release --target aarch64-unknown-linux-gnu --bin bootstrap
-	cp $(ROOT)/rust/host/target/aarch64-unknown-linux-gnu/release/bootstrap @@domain_name@@-host
+	cd $(HOST_DIR) && CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc rustup run stable cargo build --release --target aarch64-unknown-linux-gnu --bin bootstrap
+	cp $(HOST_DIR)/target/aarch64-unknown-linux-gnu/release/bootstrap @@domain_name@@-host
 	cp $(ROOT)/rust/dist/@@domain_name@@.wasm @@domain_name@@.wasm
 	cp $(ROOT)/rust/dist/@@domain_name@@.ir.json @@domain_name@@.ir.json
 

data/lib/hecks/projections/site/cms_editor/attributes.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # One attribute as the editor reads it: its name, the type as the bluebook spells it, how a
+        # value of it is entered (`kind`), and whether it is optional or a list.
+        #
+        # A type that names one of the aggregate's value objects is an `object`; a reference is a
+        # `reference`; the primitives are `integer`, `number`, `boolean` and `text`, and any other
+        # name is entered as text.
+        #
+        # An attribute whose value object has the shape of a structured document, a `blocks`
+        # list of a value object that has `kind` and `spans`, carries `widget: "body"` and is
+        # edited with the rich-text widget. The shape decides it, never a name.
+        class Attributes
+          # The parts a value object needs for its list of blocks to be a document body's blocks.
+          BLOCK_PARTS = %w[kind spans].freeze
+
+          # The kind a primitive's name enters as; any other name is text.
+          KINDS = { "Integer" => "integer", "Float" => "number", "Boolean" => "boolean", "TrueClass" => "boolean",
+                    "FalseClass" => "boolean" }.freeze
+
+          # @param objects [Array<Bluebook::ValueObject>] the aggregate's value objects
+          def initialize(objects)
+            @by_name = objects.to_h { |object| [object.hecks_name, object] }
+            @objects = @by_name.keys
+          end
+
+          # @param attribute [Bluebook::Attribute] a declared attribute
+          # @return [Hash{String => Object}] the attribute as the editor reads it
+          def of(attribute)
+            type = attribute.type
+            return reference(attribute, type.target_name) if type.is_a?(Bluebook::Reference)
+
+            entry = base(attribute, type.to_s, kind(type.to_s))
+            body?(attribute) ? entry.merge("widget" => "body") : entry
+          end
+
+          private
+
+          # A single (not listed) attribute whose value object holds a list of document blocks.
+          def body?(attribute)
+            return false if attribute.list?
+
+            block = block_object(@by_name[attribute.type.to_s])
+            !block.nil? && (BLOCK_PARTS - block.attributes.map { |part| part.name.to_s }).empty?
+          end
+
+          # @return [Bluebook::ValueObject, nil] the value object `object`'s `blocks` list holds
+          def block_object(object)
+            blocks = object&.attributes&.find { |part| part.name.to_s == "blocks" && part.list? }
+            blocks && @by_name[blocks.type.to_s]
+          end
+
+          def reference(attribute, target)
+            base(attribute, target, "reference").merge("target" => target)
+          end
+
+          def base(attribute, type, kind)
+            { "name" => attribute.name.to_s, "type" => type, "kind" => kind,
+              "optional" => attribute.optional?, "list" => attribute.list? }
+          end
+
+          def kind(type)
+            return "object" if @objects.include?(type)
+
+            KINDS.fetch(type, "text")
+          end
+        end
+      end
+    end
+  end
+end