hecks 3.0.5 → 3.1.1

data/lib/hecks/tools/oidc_manifests.rb

@@ -9,7 +9,8 @@ module Hecks
     # `oidc.json` beside the domain.
     #
     # A domain that has no bluebook is skipped and one that cannot be projected is reported, so a
-    # sweep over the whole checkout carries on past either. `hecks deploy project_oidc` loads
+    # sweep over the whole checkout carries on past either. `hecks deploy
+    # oidc_manifest.project_oidc` loads
     # `bundler/setup` first, which pins the `json` gem: newer releases pretty-print an empty array
     # as `[\n\n]`, a diff spec/oidc_manifest_spec.rb would report as drift.
     module OidcManifests

data/lib/hecks/tools/sequence_script.rb

@@ -10,8 +10,8 @@ module Hecks
     #
     #   hecks generate_sequence <domain> [--seed N] [--steps N] [--adversarial fraction]
     #
-    # `--adversarial` mutates the sequence as `hecks quality_control ask run` does; 0 (off) by
-    # default.
+    # `--adversarial` mutates the sequence as `hecks quality_control query sweep.run` does; 0 (off)
+    # by default.
     module SequenceScript
       USAGE = "usage: hecks generate_sequence <domain> [--seed N] [--steps N] [--adversarial FRACTION]"
 

data/lib/hecks/tools/site_routes.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "hecks"
+require "fileutils"
+require "optparse"
+require_relative "../tools"
+require_relative "../projections/site/routes_ts"
+require_relative "../projections/site/site_cdn"
+require_relative "../projections/site/regions"
+
+module Hecks
+  module Tools
+    # Projects a project's route table into `routes.ts` (`Projections::Site::RoutesTs`) and, when
+    # it declares an edge, into the behaviours and listener rules of its template
+    # (`Projections::Site::SiteCdn`).
+    #
+    #   hecks site site_projection.project_site [<project>] [--out=<dir>] [--check]
+    #
+    # `<project>` is the directory whose `bluebook/` holds the chapter that declares the rows and a
+    # hecksagon that attaches Site; it defaults to the checkout. `routes.ts` is written to
+    # `<project>/generated` unless `--out` names another directory. The template is rewritten in
+    # place between its `BEGIN`/`END GENERATED site_cdn` markers, or under `--out` a copy of it is
+    # written at the same relative path. With `--check` nothing is written: the tool answers 1 and
+    # names each file that differs from the table.
+    module SiteRoutes
+      # Where the files go, relative to the project, when `--out` names no directory.
+      DEFAULT_OUT = "generated"
+
+      USAGE = "usage: hecks site site_projection.project_site [<project>] [--out=<dir>] [--check]"
+
+      module_function
+
+      # Projects the route table, writes what differs and prints a line for each file written.
+      #
+      # @param argv [Array<String>] the project directory, then the flags
+      # @param root [String] the checkout, used as the project when `argv` names none
+      # @return [Integer] 0, or 1 when `--check` finds a file out of date
+      # @raise [SystemExit] with the reason on stderr when the project declares no route table or
+      #   the table is refused
+      def main(argv, root: Tools::ROOT)
+        argv = argv.dup
+        out = nil
+        check = false
+        OptionParser.new do |parser|
+          parser.on("--out=DIR") { |value| out = value }
+          parser.on("--check") { check = true }
+        end.parse!(argv)
+        project = argv.empty? ? root : File.expand_path(argv.shift)
+        abort USAGE unless argv.empty?
+
+        files = projection(project, out: out)
+        stale = files.reject { |path, text| File.file?(path) && File.read(path) == text }.keys
+        return report(stale, project, check) if check
+
+        stale.each do |path|
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, files.fetch(path))
+          puts "wrote #{display(path, project)}"
+        end
+        puts "project_site: #{files.size} #{files.size == 1 ? 'file' : 'files'}, current" if stale.empty?
+        0
+      end
+
+      # @param root [String] the project directory
+      # @param out [String, nil] the directory to write to; `generated/` of the project when nil
+      # @return [Hash{String => String}] each file's absolute path to the text it should hold
+      # @raise [SystemExit] when the project declares no route table or the table is refused
+      def projection(root, out: nil)
+        registry = registry_for(root)
+        chapter = Projections::Site::Table.chapter(registry)
+        table = Projections::Site::Table.read(chapter, registry: registry)
+        files = Projector.call(:site_routes_ts, bluebook: chapter, options: { table: table })
+        dir = out ? File.expand_path(out) : File.join(root, DEFAULT_OUT)
+        written = files.to_h { |name, text| [File.join(dir, name), text] }
+        written.merge(template_files(root, out, chapter, table, registry))
+      rescue Projections::Site::Table::Invalid => e
+        abort "project_site: #{e.message}"
+      end
+
+      # The template with the edge's regions rewritten, when the project declares an edge.
+      #
+      # @param root [String] the project directory
+      # @param out [String, nil] the directory to write to, or nil to rewrite the template in place
+      # @param chapter [Bluebook::Chapter] the chapter that declares the route table
+      # @param table [Projections::Site::Table] the checked table
+      # @param registry [Hecks::Runtime::Registry] the registry the project booted into
+      # @return [Hash{String => String}] the template's path to its text; empty with no edge
+      # @raise [SystemExit] when the template is missing or lacks a region
+      def template_files(root, out, chapter, table, registry)
+        edge = Projections::Site::Edge.read(chapter, table: table, vocabulary: Projections::Site::Table.vocabulary(registry))
+        return {} unless edge
+
+        regions = Projector.call(:site_cdn, bluebook: chapter, options: { table: table, edge: edge })
+        relative = edge.setting.template
+        source = File.join(root, relative)
+        abort "project_site: the template #{relative} does not exist in #{root}" unless File.file?(source)
+
+        text = regions.reduce(File.read(source)) do |current, (name, block)|
+          unless Projections::Site::Regions.region?(current, name)
+            abort "project_site: #{relative} has no BEGIN/END GENERATED site_cdn #{name} region"
+          end
+
+          Projections::Site::Regions.replace(current, name, block)
+        end
+        { (out ? File.join(File.expand_path(out), relative) : source) => text }
+      end
+
+      # Loads the project's chapters the way a deploy does: the bluebooks, then the hecksagons that
+      # attach the chapters they need.
+      #
+      # @param root [String] the project directory
+      # @return [Hecks::Runtime::Registry] the registry
+      # @raise [SystemExit] when the project has no `bluebook/` directory
+      def registry_for(root)
+        dir = File.join(root, "bluebook")
+        unless Dir.exist?(dir)
+          abort "project_site: #{dir} does not exist; a project declares its route table in a bluebook/ directory"
+        end
+
+        registry = Hecks::Runtime::Registry.new(root: root)
+        lib_hecks = File.expand_path("..", __dir__)
+        Hecks.with_registry(registry) do
+          %w[ports/persistence.port ports/extraction.port adapters/driven/memory.adapter
+             adapters/driven/prism.adapter].each { |file| Kernel.load(File.join(lib_hecks, file)) }
+          Dir.glob(File.join(dir, "*.bluebook")).each { |file| Kernel.load(file) }
+          Dir.glob(File.join(dir, "*.hecksagon")).each { |file| Kernel.load(file) }
+        end
+        registry
+      end
+
+      # @param stale [Array<String>] absolute paths whose text differs from the table
+      # @param project [String] the project directory
+      # @param check [Boolean] whether this is a `--check` run
+      # @return [Integer] 0 when current, else 1 with the stale files on stderr
+      def report(stale, project, _check)
+        if stale.empty?
+          puts "project_site: every file current"
+          return 0
+        end
+
+        warn "project_site: out of date: #{stale.map { |path| display(path, project) }.join(', ')} " \
+             "(run hecks site site_projection.project_site)"
+        1
+      end
+
+      # @param path [String] an absolute path
+      # @param project [String] the project directory
+      # @return [String] the path relative to the project when it lies beneath it
+      def display(path, project) = path.delete_prefix("#{project}/")
+    end
+  end
+end

data/lib/hecks/tools/tenant_provisioning.rb

@@ -16,7 +16,7 @@ module Hecks
     # merge) the base `persisted_by` settings, so `--database` is required. A policy's refusal is
     # swallowed by `PolicyInterpreter#deliver`, so success is confirmed by query.
     #
-    #   hecks deploy provision <domain-directory> <slug> --domain=name --realm=name \
+    #   hecks deploy tenant.provision <domain-directory> <slug> --domain=name --realm=name \
     #     --schema=name --database=name [--adapter=PostgresEra]
     module TenantProvisioning
       USAGE = "usage: hecks deploy provision <domain-directory> <slug> --domain=NAME --realm=NAME " \

data/lib/hecks/tools.rb

@@ -24,6 +24,7 @@ module Hecks
       "project_ci_gates"               => ["tools/ci_gates", "CiGates"],
       "decide_ci_gate"                 => ["tools/ci_gate_decision", "CiGateDecision"],
       "project_deploy"                 => ["tools/deploy_recipe", "DeployRecipe"],
+      "project_site"                   => ["tools/site_routes", "SiteRoutes"],
       "lint_deploy_recipes"            => ["tools/deploy_recipe_lint", "DeployRecipeLint"],
       "project_oidc"                   => ["tools/oidc_manifests", "OidcManifests"],
       "project_tenant"                 => ["tools/tenant_provisioning", "TenantProvisioning"],

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.0.5".freeze
+  VERSION = "3.1.1".freeze
 end

data/lib/hecks.rb

@@ -29,6 +29,7 @@ require_relative "hecks/projector"
 require_relative "hecks/projections"
 # After `Projector`, which dispatches against the `:cli` projection.
 require_relative "hecks/doors/cli_door"
+require_relative "hecks/doors/usage_cache"
 require_relative "hecks/doors/cli_runner"
 require_relative "hecks/storehouse"
 require_relative "hecks/mcp_stdio_guard"

data/rust/build/src/cargo_sync.rs

@@ -50,7 +50,7 @@ fn write_root_mod(out_root: &Path, all_dirs: &[String], domains: &[String], targ
     out.push_str("// chapter (governance/identity — no merged.rs of its own, so absent\n");
     out.push_str("// from `domains`) stays unconditional: it has no single feature of its\n");
     out.push_str("// own to gate behind, and is compiled in by whichever domain(s) attach\n");
-    out.push_str("// it via `uses_framework`.\n");
+    out.push_str("// it via `attaches`.\n");
     for name in all_dirs {
         if domains.iter().any(|d| d == name) {
             out.push_str(&format!("#[cfg(feature = {name:?})]\n"));

data/rust/build/src/pipeline.rs

@@ -66,10 +66,10 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
         }
     }
 
-    let (uses_framework_names, uses_embryonaut_bluebook_names) = match &hecksagon_path {
+    let (gem_chapter_names, vendored_package_names) = match &hecksagon_path {
         Some(p) => (
-            resolve::resolve_uses_framework(&parser_bin, &target_chapter_name, p)?,
-            resolve::resolve_uses_embryonaut_bluebook(&parser_bin, &target_chapter_name, p)?,
+            resolve::resolve_gem_chapters(&parser_bin, &target_chapter_name, p)?,
+            resolve::resolve_vendored_packages(&parser_bin, &target_chapter_name, p)?,
         ),
         None => (Vec::new(), Vec::new()),
     };
@@ -85,45 +85,52 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
     lineage_pass::run(&mut target_ir, hecksagon_path.as_deref(), world_path.as_deref(), root)?;
     let target_ir_text = crate::json::write(&target_ir);
 
-    // Every other chapter's `uses_framework` names, resolved through the
+    // Every other chapter the gem supplies by `attaches "Name"`, resolved through the
     // same directory listing (`resolve::framework_members`) the Ruby
-    // pipeline itself calls.
+    // pipeline itself calls. A gem chapter that is not a framework member (the language,
+    // Tenancy, Deploy) is loaded by the Ruby runtime alone, so it is checked and skipped.
     let framework_members = resolve::framework_members(root)?;
+    let other_gem_chapters = resolve::other_gem_chapter_names(root)?;
     let mut chapters: Vec<Chapter> = Vec::new();
-    for fw_name in &uses_framework_names {
+    for fw_name in &gem_chapter_names {
+        if other_gem_chapters.contains(fw_name) && !framework_members.iter().any(|(name, _)| name == fw_name) {
+            continue;
+        }
         let fw_path = framework_members
             .iter()
             .find(|(name, _)| name == fw_name)
             .map(|(_, path)| path.clone())
             .ok_or_else(|| {
-                let known: Vec<&str> = framework_members.iter().map(|(n, _)| n.as_str()).collect();
-                format!("hecks-build: uses_framework {fw_name:?} names no known framework member — known: {}", known.join(", "))
+                let mut known: Vec<&str> = framework_members.iter().map(|(n, _)| n.as_str()).collect();
+                known.extend(other_gem_chapters.iter().map(String::as_str));
+                known.sort();
+                format!("hecks-build: attaches {fw_name:?} names no chapter the gem carries — known: {}", known.join(", "))
             })?;
         let fw_chapter_name = resolve::header_chapter_name(&fw_path)?;
         if &fw_chapter_name != fw_name {
             return Err(format!(
-                "hecks-build: {} declares chapter {fw_chapter_name:?}, but uses_framework named {fw_name:?}",
+                "hecks-build: {} declares chapter {fw_chapter_name:?}, but attaches named {fw_name:?}",
                 fw_path.display()
             ));
         }
         let fw_ir_text = parse_chapter_with_optionals(&parser_bin, &fw_chapter_name, std::slice::from_ref(&fw_path))?;
         chapters.push(Chapter {
             mod_name: fw_name.to_lowercase(),
-            source_label: format!("{domain} (uses_framework {fw_name:?})"),
+            source_label: format!("{domain} (attaches {fw_name:?})"),
             ir_text: fw_ir_text,
         });
     }
 
-    // Every vendored package's `uses_embryonaut_bluebook` names, resolved the
+    // Every vendored package's `attaches ... from: :vendor` names, resolved the
     // same way `EmbryonautBluebook.load!` (Ruby) resolves them — without this,
     // a vendored chapter would silently drop from the output.
-    for pkg_name in &uses_embryonaut_bluebook_names {
+    for pkg_name in &vendored_package_names {
         let pkg_files = resolve::vendored_bluebook_files(&domain_path, pkg_name)?;
         let pkg_chapter_name = resolve::header_chapter_name(&pkg_files[0])?;
         let expected_chapter_name = resolve::pascal(pkg_name);
         if pkg_chapter_name != expected_chapter_name {
             return Err(format!(
-                "hecks-build: {} declares chapter {pkg_chapter_name:?}, but uses_embryonaut_bluebook {pkg_name:?} \
+                "hecks-build: {} declares chapter {pkg_chapter_name:?}, but attaches {pkg_name:?}, from: :vendor \
                  expects {expected_chapter_name:?}",
                 pkg_files[0].display()
             ));
@@ -140,13 +147,13 @@ pub fn run(root: &Path, domain: &str, opts: &Options) -> Result<(), String> {
             // `expected_chapter_name` above), not the raw `pkg_name` — that
             // would diverge the moment a package name has an underscore.
             mod_name: expected_chapter_name.to_lowercase(),
-            source_label: format!("{domain} (uses_embryonaut_bluebook {pkg_name:?})"),
+            source_label: format!("{domain} (attaches {pkg_name:?}, from: :vendor)"),
             ir_text: pkg_ir_text,
         });
     }
 
-    // Guards against a `uses_framework`- and a `uses_embryonaut_bluebook`-
-    // derived entry sharing a `mod_name`, which would silently overwrite one
+    // Guards against a gem-chapter and a vendored-package
+    // entry sharing a `mod_name`, which would silently overwrite one
     // chapter's sidecars with another's.
     {
         let mut seen: Vec<&str> = Vec::new();

data/rust/build/src/resolve.rs

@@ -77,12 +77,45 @@ pub fn grammar_files(root: &Path) -> Result<Vec<PathBuf>, String> {
     bluebook_files(&dir)
 }
 
-pub fn resolve_uses_framework(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
-    resolve_json(parser_bin, chapter_name, hecksagon_path, "uses_framework")
+// The names `attaches "Name"` gave, for a chapter the gem carries.
+pub fn resolve_gem_chapters(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
+    resolve_json(parser_bin, chapter_name, hecksagon_path, "gem_chapters")
 }
 
-pub fn resolve_uses_embryonaut_bluebook(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
-    resolve_json(parser_bin, chapter_name, hecksagon_path, "uses_embryonaut_bluebook")
+// The names `attaches "name", from: :vendor` gave, for a vendored package.
+pub fn resolve_vendored_packages(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path) -> Result<Vec<String>, String> {
+    resolve_json(parser_bin, chapter_name, hecksagon_path, "vendored_packages")
+}
+
+// Where the gem keeps the chapters other than framework members, relative to `lib/hecks`; the
+// same places `Hecks::Chapters::GLOBS` lists.
+const OTHER_GEM_CHAPTER_DIRS: &[&str] = &["language", "grammar", "tenancy/bluebook", "deploy/bluebook", "quality_control"];
+
+// The names of the chapters the gem carries beside the framework members, found by reading each
+// file's header. Only the Ruby runtime loads them, so the build uses this list to tell a real
+// gem chapter from a misspelt name.
+pub fn other_gem_chapter_names(root: &Path) -> Result<Vec<String>, String> {
+    fn walk(directory: &Path, names: &mut Vec<String>) -> Result<(), String> {
+        let Ok(entries) = std::fs::read_dir(directory) else { return Ok(()) };
+        for entry in entries {
+            let path = entry.map_err(|e| format!("reading {}: {e}", directory.display()))?.path();
+            if path.is_dir() {
+                walk(&path, names)?;
+            } else if path.extension().and_then(|e| e.to_str()) == Some("bluebook") {
+                if let Ok(name) = header_chapter_name(&path) {
+                    names.push(name);
+                }
+            }
+        }
+        Ok(())
+    }
+    let mut names = Vec::new();
+    for directory in OTHER_GEM_CHAPTER_DIRS {
+        walk(&root.join("lib/hecks").join(directory), &mut names)?;
+    }
+    names.sort();
+    names.dedup();
+    Ok(names)
 }
 
 fn resolve_json(parser_bin: &Path, chapter_name: &str, hecksagon_path: &Path, key: &str) -> Result<Vec<String>, String> {
@@ -105,13 +138,13 @@ pub fn valid_package_name(name: &str) -> bool {
 pub fn vendored_bluebook_files(domain: &Path, pkg_name: &str) -> Result<Vec<PathBuf>, String> {
     if !valid_package_name(pkg_name) {
         return Err(format!(
-            "uses_embryonaut_bluebook {pkg_name:?} is not a package name — it must match [a-z][a-z0-9_]* (the name `hecks vendor` accepts)"
+            "attaches {pkg_name:?}, from: :vendor is not a package name — it must match [a-z][a-z0-9_]* (the name `hecks vendor` accepts)"
         ));
     }
     let dir = domain.join("vendor").join("embryonaut_bluebooks").join(pkg_name).join("bluebook");
     if !dir.is_dir() {
         return Err(format!(
-            "uses_embryonaut_bluebook {pkg_name:?} names no vendored bluebook at {} — run hecks vendor {pkg_name}",
+            "attaches {pkg_name:?}, from: :vendor names no vendored bluebook at {} — run hecks vendor {pkg_name}",
             dir.display()
         ));
     }

data/rust/codegen/src/json_codec.rs

@@ -44,6 +44,7 @@ pub fn scalar_json_accessor(scalar_type: &str) -> &'static str {
         "String" => "as_str",
         "Integer" => "as_i64",
         "Float" => "as_f64",
+        "TrueClass" | "FalseClass" => "as_bool",
         other => panic!("no JSON accessor for scalar type {other:?}"),
     }
 }
@@ -77,6 +78,7 @@ pub fn scalar_to_json_expr(scalar_type: &str, rust_expr: &str) -> String {
         "String" => format!("crate::kernel::Json::Str({rust_expr}.clone())"),
         "Integer" => format!("crate::kernel::Json::int({rust_expr})"),
         "Float" => format!("crate::kernel::Json::Float({rust_expr})"),
+        "TrueClass" | "FalseClass" => format!("crate::kernel::Json::Bool({rust_expr})"),
         other => panic!("no to_json expr for scalar type {other:?}"),
     }
 }
@@ -565,6 +567,7 @@ pub fn emit_closed_set_table_codec(exemplar: &Exemplar, vo: &Json) -> String {
                 Some("String") => format!("crate::kernel::Json::Str(self.{ident}.to_string())"),
                 Some("Integer") => format!("crate::kernel::Json::int(self.{ident})"),
                 Some("Float") => format!("crate::kernel::Json::Float(self.{ident})"),
+                Some("TrueClass" | "FalseClass") => format!("crate::kernel::Json::Bool(self.{ident})"),
                 _ => String::new(),
             };
             exemplar.render("to_json_field", &[("\"tmpl_field_name\"", naming::ruby_inspect_string(&key)), ("tmpl_json_value_placeholder()", value_expr)])

data/rust/codegen/src/naming.rs

@@ -7,6 +7,7 @@ pub fn scalar_rust_type(type_name: &str) -> Option<&'static str> {
         "String" => Some("String"),
         "Integer" => Some("i64"),
         "Float" => Some("f64"),
+        "TrueClass" | "FalseClass" => Some("bool"),
         _ => None,
     }
 }
@@ -29,6 +30,8 @@ pub fn effective_scalar_type(type_name: &str) -> Option<&'static str> {
         "String" => Some("String"),
         "Integer" => Some("Integer"),
         "Float" => Some("Float"),
+        "TrueClass" => Some("TrueClass"),
+        "FalseClass" => Some("FalseClass"),
         _ => None,
     }
 }
@@ -250,6 +253,7 @@ pub fn scalar_to_value(type_name: &str, rust_expr: &str) -> Option<String> {
         "String" => Some(format!("Value::Str({rust_expr}.clone())")),
         "Integer" => Some(format!("Value::Int({rust_expr})")),
         "Float" => Some(format!("Value::Float({rust_expr})")),
+        "TrueClass" | "FalseClass" => Some(format!("Value::Bool({rust_expr})")),
         _ => None,
     }
 }

data/rust/codegen/src/types.rs

@@ -360,3 +360,48 @@ pub fn emit_projected_field_table(aggregate: &Json) -> String {
         .collect();
     format!("pub static {name}_PROJECTED_FIELDS: &[crate::kernel::ProjectedFieldSpec] = &[\n{}\n];\n", rows.join("\n"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A value object with one attribute per Ruby spelling of a boolean.
+    fn flag_value_object() -> Json {
+        Json::parse(
+            r#"{
+              "name":"Entry",
+              "attributes":[
+                {"name":"on","type":"TrueClass","list":false,"optional":false,"default":false},
+                {"name":"off","type":"FalseClass","list":false,"optional":false}
+              ]
+            }"#,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn boolean_attributes_are_rust_bool_not_a_type_named_for_the_ruby_class() {
+        let vo = flag_value_object();
+        let generated = emit_value_object(&Exemplar::load(), &vo, &HashMap::new(), &HashMap::new());
+
+        assert!(generated.contains("pub on: bool,"));
+        assert!(generated.contains("pub off: bool,"));
+        assert!(generated.contains("Value::Bool(self.on)"));
+        assert!(!generated.contains("TrueClass,"));
+        assert!(!generated.contains("FalseClass,"));
+    }
+
+    #[test]
+    fn boolean_attributes_round_trip_through_json_as_bool() {
+        let vo = flag_value_object();
+        let attributes = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+        let by_name = HashMap::new();
+        let exemplar = Exemplar::load();
+        let from_json = crate::json_codec::emit_from_json_flat(&exemplar, "Entry", attributes, &by_name, None, None, false, false, None);
+        let to_json = crate::json_codec::emit_to_json_flat(&exemplar, "Entry", attributes, &by_name, false, &[], None);
+
+        assert!(from_json.contains("x.as_bool()"));
+        assert!(!from_json.contains("TrueClass::from_json"));
+        assert!(to_json.contains("crate::kernel::Json::Bool(self.on)"));
+    }
+}

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-3.0.5
+3.1.1

data/rust/host/src/api.rs

@@ -780,7 +780,7 @@ async fn presentation_save(
 const PRESENTATION_WRITE_REFUSAL: &str =
     "this host's kernel carries no ConsoleSettings chapter, so it has no StateStyle/Collection/Overview \
      commands to dispatch, and writing the rows behind its back would skip the invariants those commands \
-     enforce. Attach it with `uses_framework \"ConsoleSettings\"` in this domain's own .hecksagon and \
+     enforce. Attach it with `attaches \"ConsoleSettings\"` in this domain's own .hecksagon and \
      rebuild the kernel, or save from the Ruby console engine instead.";
 
 // ---- response envelopes ---------------------------------------------