hecks 3.0.4 → 3.1.0

data/rust/parser/src/parse/hecksagon.rs

@@ -1,4 +1,4 @@
-//! The `Hecksagon` construct: a `.hecksagon` file's `port` blocks and `uses_framework` words.
+//! The `Hecksagon` construct: a `.hecksagon` file's `port` blocks and `attaches` words.
 //! Adapter binds (`persisted_by`, `projected_by`, `subscribe`) are shape-matched and dropped.
 
 use super::domain_port;
@@ -14,8 +14,10 @@ pub fn not_implemented(file: &str, line: usize, word: &str) -> Diagnostic {
 /// Applies a `.hecksagon` body onto an already-built `ir::Bluebook`, attaching
 /// aggregate-scoped ports to the aggregates the sibling `.bluebook` registered.
 ///
-/// `uses_framework_names` and `vendored_bluebook_names` collect each argument in file order
-/// for `hecks-parse resolve`; `ir.json` itself carries neither.
+/// `gem_chapter_names` collects each `attaches "Name"` (and the deprecated `uses_framework`) and
+/// `vendored_bluebook_names` each `attaches "name", from: :vendor` (and the deprecated
+/// `uses_embryonaut_bluebook`), in file order, for `hecks-parse resolve`; `ir.json` itself
+/// carries neither.
 ///
 /// `require_matching_aggregate` is `false` for resolve, which never sees a `.bluebook`, so an
 /// aggregate-scoped `port` skips the attach step instead of failing the lookup.
@@ -24,7 +26,7 @@ pub fn apply(
     lines: &[SourceLine],
     pos: &mut usize,
     bluebook: &mut ir::Bluebook,
-    uses_framework_names: &mut Vec<String>,
+    gem_chapter_names: &mut Vec<String>,
     vendored_bluebook_names: &mut Vec<String>,
     require_matching_aggregate: bool,
 ) -> ParseResult<()> {
@@ -96,9 +98,9 @@ pub fn apply(
                     let built = policy::parse_body(file, lines, pos, &name)?;
                     bluebook.policies.push(built);
                 }
-                // Gated, then collected; `ir.json` carries no `uses_framework` key.
+                // Deprecated spelling of `attaches "Name"`; gated, then collected.
                 "uses_framework" => {
-                    uses_framework_names.push(super::positional_text(
+                    gem_chapter_names.push(super::positional_text(
                         file,
                         gated.line.number,
                         "uses_framework",
@@ -106,7 +108,7 @@ pub fn apply(
                         1,
                     )?);
                 }
-                // Collected like `uses_framework`; a binding fact, absent from `ir.json`.
+                // Deprecated spelling of `attaches "name", from: :vendor`; collected the same way.
                 "uses_embryonaut_bluebook" => {
                     vendored_bluebook_names.push(super::positional_text(
                         file,
@@ -117,10 +119,23 @@ pub fn apply(
                     )?);
                 }
                 "subscribe" => {}
-                // A chapter the gem carries, attached by name (ADR 0080); only the Ruby runtime
-                // loads it, so its one argument is checked and then dropped like `subscribe`.
+                // One word for a chapter the gem carries and for a vendored package; a binding
+                // fact collected for `resolve`, absent from `ir.json`. Only `from: :vendor`
+                // is admitted as a source, and anything else is refused.
                 "attaches" => {
-                    super::positional_text(file, gated.line.number, "attaches", &gated.args, 1)?;
+                    let name =
+                        super::positional_text(file, gated.line.number, "attaches", &gated.args, 1)?;
+                    match super::named_symbol(&gated.args, "from").as_deref() {
+                        None => gem_chapter_names.push(name),
+                        Some("vendor") => vendored_bluebook_names.push(name),
+                        Some(other) => {
+                            return Err(Diagnostic::new(
+                                file,
+                                gated.line.number,
+                                format!("'attaches' from: takes only :vendor, got :{other}"),
+                            ))
+                        }
+                    }
                 }
                 // Consumer-owned bounded-context mark; a wiring fact, dropped like `subscribe`.
                 "bounded" => {}

data/rust/project/mutations.rb

@@ -1,3 +1,5 @@
+require "hecks/rust_build/append_optionals"
+
 module RustProjection
   module Projector
     module_function
@@ -60,13 +62,7 @@ module RustProjection
 
     # Resolves an `append` target to its entity or value object, or nil if it is neither.
     def append_element(aggregate, target_type, value_objects_by_name)
-      # LOCAL FIRST — an aggregate's own nested entity is scoped to that
-      # Local entities win over the domain-wide value objects: Syntax's local `Argument` entity
-      # shares a name with Command's `Argument` value object.
-      local = aggregate[:entities].find { |e| e[:name] == target_type }
-      return local if local
-
-      value_objects_by_name[target_type]
+      Hecks::RustBuild::AppendOptionals.element(aggregate, target_type, value_objects_by_name)
     end
 
     # Identity attribute and its single-field value object for an auto-minted entity element,
@@ -454,29 +450,7 @@ module RustProjection
     # attribute
     # hash once, before the emitters read it, and never resets a `true`.
     def mark_append_optional_fields!(aggregate, value_objects_by_name)
-      aggregate[:attributes].each do |target_attr|
-        element = append_element(aggregate, target_attr[:type], value_objects_by_name)
-        next unless element
-
-        aggregate[:commands].each do |command|
-          command[:mutations].each do |m|
-            next unless m[:op].to_s == "append" && m[:target].to_s == target_attr[:name].to_s
-
-            m[:fields].each do |field_name, source|
-              # A Symbol is an argument name (optional ones are what this pass wants); else a
-              # literal.
-              parsed = append_field_source(source)
-              next unless parsed.is_a?(Symbol)
-
-              source_attr = command[:attributes].find { |a| a[:name].to_s == parsed.to_s }
-              next unless source_attr && source_attr[:optional]
-
-              field_attr = element[:attributes].find { |a| a[:name].to_s == field_name.to_s }
-              field_attr[:optional] = true if field_attr
-            end
-          end
-        end
-      end
+      Hecks::RustBuild::AppendOptionals.mark_aggregate(aggregate, value_objects_by_name)
     end
 
     # Derives the mutations of a `corrects EVENT, reverses: true` command from the commands that

data/rust/project/naming.rb

@@ -1,5 +1,7 @@
 require "hecks/vocabulary"
 require "hecks/bluebook/model_check"
+require "hecks/rust_build/domain_name"
+require "hecks/rust_build/rust_literal"
 
 module RustProjection
   # Domain-to-Rust codegen support: type mapping, reserved-name checks, and
@@ -59,15 +61,10 @@ module RustProjection
     # feature set.
     #
     # Declared once as the `CargoReservedName` vocabulary.
-    CARGO_RESERVED_DOMAIN_NAMES = Hecks::Vocabulary.fetch("CargoReservedName")
-
-    # Checks identifier shape locally; delegates the reserved-word half to
-    # `ModelCheck.rust_reserved_name_findings`, the one shared check.
-    def valid_domain_mod_name?(name)
-      str = name.to_s
-      str.match?(/\A[a-z_][a-z0-9_]*\z/) &&
-        Hecks::Bluebook::ModelCheck.rust_reserved_name_findings(domain_name: str).empty?
-    end
+    CARGO_RESERVED_DOMAIN_NAMES = Hecks::RustBuild::DomainName::CARGO_RESERVED
+
+    # Moved to `Hecks::RustBuild::DomainName`, which the codegen-backed `hecks project_rust` uses.
+    def valid_domain_mod_name?(name) = Hecks::RustBuild::DomainName.valid?(name)
 
     # Identifier-shape check only (a PascalCase name always passes); whether
     # the downcased name is a Rust keyword is `reserved_name_refusal`'s job,
@@ -220,24 +217,7 @@ module RustProjection
       end
     end
 
-    # Ruby's String#inspect escapes for Ruby's own read-back (e.g. a
-    # brace-less `\uXXXX`), which isn't valid Rust syntax. This escapes
-    # only what Rust's string-literal grammar needs: backslash,
-    # double-quote, and control characters.
-    def rust_string_literal(str)
-      escaped = str.to_s.each_char.map do |ch|
-        case ch
-        when "\\" then "\\\\"
-        when "\"" then "\\\""
-        when "\n" then "\\n"
-        when "\r" then "\\r"
-        when "\t" then "\\t"
-        else
-          cp = ch.ord
-          cp < 0x20 || cp == 0x7F ? format("\\u{%x}", cp) : ch
-        end
-      end.join
-      "\"#{escaped}\""
-    end
+    # Moved to `Hecks::RustBuild::RustLiteral`, which the codegen-backed `hecks project_rust` uses.
+    def rust_string_literal(str) = Hecks::RustBuild::RustLiteral.string(str)
   end
 end

data/rust/project/write_if_changed.rb

@@ -1,83 +1,7 @@
-require "fileutils"
-require "set"
+require "hecks/rust_build/write_if_changed"
 
-# Skips writes whose content is unchanged so file mtimes stay stable.
-# A rewrite alone forces Cargo to rebuild downstream crates.
 module RustProjection
-  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
-
-    def push_directory(dir)
-      FileUtils.mkdir_p(dir)
-      stack.push([File.expand_path(dir), Set.new])
-    end
-
-    # Matches by directory, not LIFO: nested directories can close out of order.
-    def pop_and_prune(dir)
-      abs_dir = File.expand_path(dir)
-      idx = stack.rindex { |tracked_dir, _| tracked_dir == abs_dir }
-      return unless idx
-
-      _dir, touched = stack.delete_at(idx)
-      existing = Dir.glob(File.join(abs_dir, "*"))
-      (existing - touched.to_a).each do |orphan|
-        FileUtils.rm_rf(orphan)
-        puts "pruned #{orphan} (no longer generated)"
-      end
-    end
-
-    def stack
-      Thread.current[:hecks_write_if_changed_stack] ||= []
-    end
-    private_class_method :stack
-
-    def record_touch(path)
-      abs = File.expand_path(path)
-      stack.each do |dir, touched|
-        touched << abs if abs.start_with?("#{dir}/")
-      end
-    end
-    private_class_method :record_touch
-
-    # Writes `content` to `path` unless it already holds identical bytes.
-    # Returns whether it wrote.
-    def call(path, content)
-      record_touch(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
-
-      File.write(path, content)
-      true
-    end
-
-    # 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") { |f| yield f }
-        if File.exist?(path) && FileUtils.compare_file(tmp, path)
-          false
-        else
-          FileUtils.mv(tmp, path)
-          true
-        end
-      ensure
-        File.delete(tmp) if File.exist?(tmp)
-      end
-    end
-  end
+  # The write-if-unchanged helper moved to `Hecks::RustBuild::WriteIfChanged`, which the
+  # codegen-backed `hecks project_rust` also uses; this name stays until this generator is deleted.
+  WriteIfChanged = Hecks::RustBuild::WriteIfChanged
 end

data/rust/project_rust_pipeline.rb

@@ -34,10 +34,10 @@ module RustProjectPipeline
     target_chapter_name = header_chapter_name(bluebook_paths.first)
     target_bluebooks = bluebook_paths.select { |path| header_chapter_name(path) == target_chapter_name }
 
-    uses_framework_names, uses_embryonaut_bluebook_names =
+    gem_chapter_names, vendored_package_names =
       if hecksagon_path
         resolved = JSON.parse(run_capture!(PARSER_BIN, "resolve", "--chapter", target_chapter_name, hecksagon_path))
-        [resolved.fetch("uses_framework"), resolved.fetch("uses_embryonaut_bluebook")]
+        [resolved.fetch("gem_chapters"), resolved.fetch("vendored_packages")]
       else
         [[], []]
       end
@@ -50,18 +50,22 @@ module RustProjectPipeline
 
     # Mirrors hecks project_rust's own Framework.load! resolution. A framework
     # member has no .hecksagon of its own, only its .bluebook.
-    chapters = uses_framework_names.map do |fw_name|
+    # A gem chapter that is not a framework member (the language, Tenancy, Deploy) is loaded by
+    # the Ruby runtime alone, so it is checked against the one table and skipped here.
+    chapters = gem_chapter_names.filter_map do |fw_name|
+      next if Hecks::Chapters.index.key?(fw_name) && !Hecks::Framework.members.key?(fw_name)
+
       fw_path = Hecks::Framework.members.fetch(fw_name) do
-        abort "hecks project_rust (Rust path): uses_framework #{fw_name.inspect} names no known framework member — known: #{Hecks::Framework.members.keys.sort.join(', ')}"
+        abort "hecks project_rust (Rust path): attaches #{fw_name.inspect} names no chapter the gem carries — known: #{Hecks::Chapters.table.keys.sort.join(', ')}"
       end
       fw_chapter_name = header_chapter_name(fw_path)
       unless fw_chapter_name == fw_name
-        abort "hecks project_rust (Rust path): #{fw_path} declares chapter #{fw_chapter_name.inspect}, but uses_framework named #{fw_name.inspect}"
+        abort "hecks project_rust (Rust path): #{fw_path} declares chapter #{fw_chapter_name.inspect}, but attaches named #{fw_name.inspect}"
       end
       fw_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", fw_chapter_name, fw_path))
       {
         mod_name:     fw_name.downcase,
-        source_label: "#{domain} (uses_framework #{fw_name.inspect})",
+        source_label: "#{domain} (attaches #{fw_name.inspect})",
         ir_text:      fw_ir_text
       }
     end
@@ -69,22 +73,22 @@ module RustProjectPipeline
     # Mirrors EmbryonautBluebook.load!: every .bluebook file directly under
     # vendor/embryonaut_bluebooks/<name>/bluebook/, sorted. A vendored
     # package has no .hecksagon of its own either, just its .bluebook(s).
-    chapters += uses_embryonaut_bluebook_names.map do |pkg_name|
+    chapters += vendored_package_names.map do |pkg_name|
       unless pkg_name.to_s.match?(Hecks::EmbryonautBluebook::PACKAGE_NAME)
-        abort "hecks project_rust (Rust path): uses_embryonaut_bluebook #{pkg_name.inspect} is not a package " \
+        abort "hecks project_rust (Rust path): attaches #{pkg_name.inspect}, from: :vendor is not a package " \
               "name — it must match [a-z][a-z0-9_]* (the name `hecks vendor` accepts)"
       end
       pkg_dir = File.join(domain, "vendor", "embryonaut_bluebooks", pkg_name.to_s, "bluebook")
       pkg_files = Dir.glob(File.join(pkg_dir, "*.bluebook")).sort
       if pkg_files.empty?
-        abort "hecks project_rust (Rust path): uses_embryonaut_bluebook #{pkg_name.inspect} names no vendored " \
+        abort "hecks project_rust (Rust path): attaches #{pkg_name.inspect}, from: :vendor names no vendored " \
               "bluebook at #{pkg_dir} — run hecks vendor #{pkg_name}"
       end
       pkg_chapter_name = header_chapter_name(pkg_files.first)
       expected_chapter_name = Hecks::Naming.pascal(pkg_name.to_s)
       unless pkg_chapter_name == expected_chapter_name
         abort "hecks project_rust (Rust path): #{pkg_files.first} declares chapter #{pkg_chapter_name.inspect}, but " \
-              "uses_embryonaut_bluebook #{pkg_name.inspect} expects #{expected_chapter_name.inspect}"
+              "attaches #{pkg_name.inspect}, from: :vendor expects #{expected_chapter_name.inspect}"
       end
       pkg_bluebooks = pkg_files.select { |path| header_chapter_name(path) == pkg_chapter_name }
       pkg_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", pkg_chapter_name, *pkg_bluebooks))
@@ -92,7 +96,7 @@ module RustProjectPipeline
         # Derived from the declared chapter name, not pkg_name.downcase
         # directly — the two diverge once a package name has an underscore.
         mod_name:     expected_chapter_name.downcase,
-        source_label: "#{domain} (uses_embryonaut_bluebook #{pkg_name.inspect})",
+        source_label: "#{domain} (attaches #{pkg_name.inspect}, from: :vendor)",
         ir_text:      pkg_ir_text
       }
     end
@@ -294,7 +298,7 @@ module RustProjectPipeline
       f.puts "// chapter (governance/identity — no merged.rs of its own, so absent"
       f.puts "// from `domains`) stays unconditional: it has no single feature of its"
       f.puts "// own to gate behind, and is compiled in by whichever domain(s) attach"
-      f.puts "// it via `uses_framework`."
+      f.puts "// it via `attaches`."
       all_dirs.each do |name|
         f.puts "#[cfg(feature = #{name.inspect})]" if domains.include?(name)
         f.puts "pub mod #{name};"

data/rust/src/kernel/cli.rs

@@ -18,6 +18,8 @@ pub fn run(input: &str) -> String {
 
     // Optional `"needs"`: which commands need which outside facts (ADR 0081), passed by the host.
     super::needs::install(parsed.get("needs"));
+    // Optional `"defaults"`: each command's declared argument defaults, filled the same way.
+    super::needs::install_defaults(parsed.get("defaults"));
 
     let steps = match parsed.get("steps").and_then(Json::as_array) {
         Some(s) => s,

data/rust/src/kernel/needs.rs

@@ -25,6 +25,7 @@ pub struct Need {
 
 thread_local! {
     static TABLE: RefCell<HashMap<String, Vec<Need>>> = RefCell::new(HashMap::new());
+    static DEFAULTS: RefCell<HashMap<String, Vec<(String, Json)>>> = RefCell::new(HashMap::new());
     static FIXED_CLOCK: Cell<Option<i64>> = const { Cell::new(None) };
 }
 
@@ -52,6 +53,23 @@ pub fn install(table: Option<&Json>) {
     TABLE.with(|t| *t.borrow_mut() = parsed);
 }
 
+/// Installs the declared defaults the host passed, `{ verb: { attribute: value } }` (an absent or
+/// malformed `"defaults"` installs an empty table). They fill after the needs, so a fact that is
+/// both needed and defaulted takes the answer.
+pub fn install_defaults(table: Option<&Json>) {
+    let parsed = match table {
+        Some(Json::Object(entries)) => entries
+            .iter()
+            .filter_map(|(verb, attributes)| match attributes {
+                Json::Object(held) => Some((verb.clone(), held.clone())),
+                _ => None,
+            })
+            .collect(),
+        _ => HashMap::new(),
+    };
+    DEFAULTS.with(|t| *t.borrow_mut() = parsed);
+}
+
 /// Makes the kernel clock answer `secs` on this thread until cleared; the test seam.
 pub fn fix_clock(secs: Option<i64>) {
     FIXED_CLOCK.with(|c| c.set(secs));
@@ -100,7 +118,11 @@ fn answer(need: &Need, occurred_at: Option<&str>) -> Option<Json> {
 /// needed filling (no needs, or every fact supplied). Reads `with` when the call carries one,
 /// else the flat object, as `CommandInvocation` does.
 pub fn enrich(verb: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json> {
-    let needs = TABLE.with(|t| t.borrow().get(verb).cloned())?;
+    let needs = TABLE.with(|t| t.borrow().get(verb).cloned()).unwrap_or_default();
+    let defaults = DEFAULTS.with(|t| t.borrow().get(verb).cloned()).unwrap_or_default();
+    if needs.is_empty() && defaults.is_empty() {
+        return None;
+    }
     let explicit = matches!(args.get("with"), Some(Json::Object(_)));
     let facts = if explicit { args.get("with")? } else { args };
     let Json::Object(held) = facts else { return None };
@@ -114,6 +136,11 @@ pub fn enrich(verb: &str, args: &Json, occurred_at: Option<&str>) -> Option<Json
             filled.push((need.fact.clone(), value));
         }
     }
+    for (name, value) in &defaults {
+        if !filled.iter().any(|(k, _)| k == name) {
+            filled.push((name.clone(), value.clone()));
+        }
+    }
     if filled.len() == before {
         return None;
     }
@@ -191,4 +218,50 @@ mod tests {
         assert_eq!(now_secs(Some("1970-01-01T00:00:00Z")), 0);
         assert!(now_secs(None) > 1_700_000_000);
     }
+
+    fn defaults() -> Json {
+        Json::parse(r#"{"D::A.Start": {"runs": 30}, "D::A.Instant": {"holder": "nobody"}}"#).unwrap()
+    }
+
+    #[test]
+    fn an_omitted_argument_takes_its_declared_default() {
+        install(None);
+        install_defaults(Some(&defaults()));
+        let filled = enrich("D::A.Start", &with(vec![("ref", Json::int(1))]), None).unwrap();
+        assert_eq!(filled.get("with").unwrap().get("runs"), Some(&Json::int(30)));
+        assert_eq!(filled.get("with").unwrap().get("ref"), Some(&Json::int(1)));
+    }
+
+    #[test]
+    fn a_supplied_argument_keeps_its_value_over_the_default() {
+        install(None);
+        install_defaults(Some(&defaults()));
+        assert_eq!(enrich("D::A.Start", &with(vec![("runs", Json::int(7))]), None), None);
+    }
+
+    #[test]
+    fn a_flat_invocation_is_filled_at_its_top_level() {
+        install(None);
+        install_defaults(Some(&defaults()));
+        let filled = enrich("D::A.Start", &Json::obj(vec![("ref", Json::int(1))]), None).unwrap();
+        assert_eq!(filled.get("runs"), Some(&Json::int(30)));
+    }
+
+    #[test]
+    fn a_needed_fact_is_answered_and_the_default_fills_beside_it() {
+        install(Some(&table()));
+        install_defaults(Some(&defaults()));
+        fix_clock(Some(3));
+        let filled = enrich("D::A.Instant", &with(vec![]), None).unwrap();
+        assert_eq!(filled.get("with").unwrap().get("now"), Some(&Json::obj(vec![("value", Json::int(3))])));
+        assert_eq!(filled.get("with").unwrap().get("holder"), Some(&Json::str("nobody")));
+        fix_clock(None);
+    }
+
+    #[test]
+    fn no_installed_defaults_leaves_a_command_untouched() {
+        install(None);
+        install_defaults(None);
+        assert_eq!(enrich("D::A.Start", &with(vec![]), None), None);
+    }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.1.0
 platform: ruby
 authors:
 - Chris Young
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -215,9 +215,11 @@ files:
 - lib/hecks/cli/deploy_template_diff.rb
 - lib/hecks/cli/doc_coverage.rb
 - lib/hecks/cli/document.rb
+- lib/hecks/cli/domain_stub.rb
 - lib/hecks/cli/expression_projection.rb
 - lib/hecks/cli/follow.rb
 - lib/hecks/cli/history.rb
+- lib/hecks/cli/interview_draft.rb
 - lib/hecks/cli/ir.rb
 - lib/hecks/cli/mcp.rb
 - lib/hecks/cli/model_check.rb
@@ -393,6 +395,8 @@ files:
 - lib/hecks/hecks/adapters/rust_workspace.rb
 - lib/hecks/hecks/adapters/shell.adapter
 - lib/hecks/hecks/adapters/shell.rb
+- lib/hecks/hecks/adapters/site_toolchain.adapter
+- lib/hecks/hecks/adapters/site_toolchain.rb
 - lib/hecks/hecks/adapters/terminal.adapter
 - lib/hecks/hecks/adapters/terminal.rb
 - lib/hecks/hecks/codebase.behaviors
@@ -408,6 +412,8 @@ files:
 - lib/hecks/hecks/hecks.bluebook
 - lib/hecks/hecks/hecks.hecksagon
 - lib/hecks/hecks/hecks.world
+- lib/hecks/hecks/site.behaviors
+- lib/hecks/hecks/site.world
 - lib/hecks/ir.rb
 - lib/hecks/kernel_capabilities.rb
 - lib/hecks/language/adapter.bluebook
@@ -521,6 +527,13 @@ files:
 - lib/hecks/projection_files.rb
 - lib/hecks/projections.rb
 - lib/hecks/projections/bootstrap_table.rb
+- lib/hecks/projections/deploy/box.rb
+- lib/hecks/projections/deploy/box/settings.rb
+- lib/hecks/projections/deploy/box/templates/box.yaml.tmpl
+- lib/hecks/projections/deploy/box/templates/deploy-box.sh.tmpl
+- lib/hecks/projections/deploy/box/templates/fetch-secrets.sh
+- lib/hecks/projections/deploy/box/templates/rds.yaml.tmpl
+- lib/hecks/projections/deploy/box/templates/render-compose.sh.tmpl
 - lib/hecks/projections/deploy/fargate.rb
 - lib/hecks/projections/deploy/fargate/assembly.rb
 - lib/hecks/projections/deploy/fargate/cdn.rb
@@ -573,6 +586,17 @@ files:
 - lib/hecks/projections/reference.rb
 - lib/hecks/projections/rust_vocabulary.rb
 - lib/hecks/projections/shape.rb
+- lib/hecks/projections/site/edge.rb
+- lib/hecks/projections/site/edge/behaviours.rb
+- lib/hecks/projections/site/edge/checks.rb
+- lib/hecks/projections/site/edge/pattern.rb
+- lib/hecks/projections/site/edge/rules.rb
+- lib/hecks/projections/site/regions.rb
+- lib/hecks/projections/site/routes_ts.rb
+- lib/hecks/projections/site/site_cdn.rb
+- lib/hecks/projections/site/table.rb
+- lib/hecks/projections/site/table/checks.rb
+- lib/hecks/projections/site/table/row_builder.rb
 - lib/hecks/projections/statements.rb
 - lib/hecks/projections/vocabulary.rb
 - lib/hecks/projector.rb
@@ -715,14 +739,25 @@ files:
 - lib/hecks/runtime/value/field_checks.rb
 - lib/hecks/runtime/value/invariant_violation.rb
 - lib/hecks/rust_build.rb
+- lib/hecks/rust_build/append_optionals.rb
 - lib/hecks/rust_build/conformance.rb
 - lib/hecks/rust_build/conformance_fuzz.rb
 - lib/hecks/rust_build/coverage.rb
+- lib/hecks/rust_build/domain_name.rb
+- lib/hecks/rust_build/kernel_input.rb
 - lib/hecks/rust_build/native_build.rb
 - lib/hecks/rust_build/project_rust.rb
+- lib/hecks/rust_build/project_rust/codegen_run.rb
 - lib/hecks/rust_build/project_rust/root_mod.rb
+- lib/hecks/rust_build/rust_literal.rb
 - lib/hecks/rust_build/wasm.rb
 - lib/hecks/rust_build/wasm_browser.rb
+- lib/hecks/rust_build/write_if_changed.rb
+- lib/hecks/site/bluebook/site.bluebook
+- lib/hecks/site/bluebook/site.hecksagon
+- lib/hecks/site/bluebook/site.ports.hecksagon
+- lib/hecks/sme/bluebook/sme.bluebook
+- lib/hecks/sme/bluebook/sme.hecksagon
 - lib/hecks/storehouse.rb
 - lib/hecks/tenancy/bluebook/tenancy.bluebook
 - lib/hecks/tenancy/bluebook/tenancy.hecksagon
@@ -750,6 +785,7 @@ files:
 - lib/hecks/tools/regeneration_run.rb
 - lib/hecks/tools/rust_comment_style.rb
 - lib/hecks/tools/sequence_script.rb
+- lib/hecks/tools/site_routes.rb
 - lib/hecks/tools/tail_merge.rb
 - lib/hecks/tools/tenant_provisioning.rb
 - lib/hecks/tools/translation_audit.rb
@@ -858,6 +894,7 @@ files:
 - rust/host/src/web.rs
 - rust/host/src/web/newsletter.rs
 - rust/host/src/web/newsletter/cooldown.rs
+- rust/host/src/web/newsletter/template.rs
 - rust/host/src/web/newsletter/tests.rs
 - rust/host/src/web/newsletter_send.rs
 - rust/host/src/web/registrations.rs