hecks 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acccf4e21574d64b971cfbfe6a34f08f0bc86fdb8c74a8c58a472042138f01f1
-  data.tar.gz: 582d4e043a4b0145c25f6dfa8e223c47da7f55e60205fbef6485f6b406a2ffe2
+  metadata.gz: 4a6fed3e5b894585b2fa7253696873a4218980f6982b4afeeda5effdd5a4aba4
+  data.tar.gz: b29a6ce60d5ae9142f0b53ee062979397f3c1384ce2f6da8c70b14396425c989
 SHA512:
-  metadata.gz: 01f4db2b60db4d05aa7682fb7abdab6206abae36f45031656b9461fa064ec61236301b731f0b64c58cdee4d26624fe8a9d61042c379ae34f3274d036b31644ad
-  data.tar.gz: 9d1c2b9990aa214173c76634eda0dbe2f32651e80fe27e54c204d1cf0877a25e00334fc2784700754cf502196548b8e3a59549974f68789e5e31dd8defb5c0be
+  metadata.gz: 77b6974a39536f06fd5bffeb121899ca35b1563e5db172bac48dfeef426c445ed459bea60bc004ea29fdb14b14149a72467b61dddce02aa1cc61b2bb9c11b944
+  data.tar.gz: 56fd3680ca94d0060d0ff5e1324c3ccbefb03f5dfc4ac03760cdfb8ee6ad2081c70cef85e4161a66098acb396bdb17c2a485185ff473bee49546a9f0a7336d65

data/exe/hecks

@@ -63,7 +63,7 @@ if reason
   if MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!"))
     why = begin
       require "json"
-      JSON.parse(text).dig("state", "refusal", "value")
+      JSON.parse(text).dig("state", "refusal")
     rescue JSON::ParserError
       nil
     end

data/lib/hecks/adapters/driving/json.rb

@@ -83,20 +83,19 @@ module Hecks
         #   with Symbol keys; a leaf is returned as it came
         def deep_symbolize(value) = Runtime::Value.deep_symbolize(value)
 
-        # Unwraps a record, a query row, or any value holding `Runtime::Value`s into plain
-        # Hashes, Arrays and scalars a JSON encoder can walk.
-        #
-        # Delegates to `Runtime::Value.materialize`; the only addition is `#to_h` on a
-        # `Handle`, which `materialize` does not recognize.
+        # Unwraps a record, a query row, or any value holding `Runtime::Value`s into the plain
+        # data a caller is answered with. A single-field value object answers as its bare
+        # field (`name: "Margherita"`), the shape a command takes it in; stored state stays
+        # wrapped.
         #
         # @param value [Adapters::Driving::Handle, Runtime::Value, Hash, Array, Object] what to
-        #   unwrap;
-        #   a `Handle` is read through its `to_h`, so its `:id` comes along
+        #   unwrap; a `Handle` is read through its `to_h`, so its `:id` comes along
         # @return [Hash, Array, Object] the same data with every `Runtime::Value` replaced
-        #   by a Hash of its fields; any other value is returned as it came
+        #   by its sole field's value, or by a Hash of its fields when it has more than one;
+        #   any other value is returned as it came
         def materialize(value)
           value = value.to_h if value.is_a?(Handle)
-          Runtime::Value.materialize(value)
+          Runtime::Value.materialize_unwrapped(value)
         end
 
         # Turns a command's JSON body, raw or already parsed, into the `to:`/`with:`

data/lib/hecks/cli/project_cli/launcher_source.rb

@@ -36,7 +36,7 @@ module Hecks
           if MEMORY_COMMANDS.include?(ARGV.first.to_s.chomp("!"))
             why = begin
               require "json"
-              JSON.parse(text).dig("state", "refusal", "value")
+              JSON.parse(text).dig("state", "refusal")
             rescue JSON::ParserError
               nil
             end

data/lib/hecks/forms/app/responses.rb

@@ -1,5 +1,6 @@
 require "json"
 require_relative "../page"
+require_relative "../../runtime/value"
 
 module Hecks
   module Forms
@@ -13,8 +14,9 @@ module Hecks
           respond(status, "text/html; charset=utf-8", Page.render(title: title, body: body, breadcrumbs: breadcrumbs))
         end
 
+        # A single-field value object answers as its bare field, as `Json.materialize` does.
         def json(status, payload)
-          respond(status, "application/json", JSON.pretty_generate(payload))
+          respond(status, "application/json", JSON.pretty_generate(Runtime::Value.materialize_unwrapped(payload)))
         end
 
         def redirect(location)

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/projections/site/cms_editor/templates/src/host.ts.tmpl

@@ -23,9 +23,14 @@ export function hostUrl(options: HostOptions = {}): string {
   return (options.url ?? (process.env[EDITOR.hostEnv] || EDITOR.hostDefault)).replace(/\/+$/, "");
 }
 
-/** A client for the domain this editor edits. */
+/**
+ * A client for the domain this editor edits. It reads and writes the stored shape (`bare: false`),
+ * since its forms walk every value object by the schema's own fields.
+ */
 export function hostClient(options: HostOptions = {}): HostClient {
-  return new HostClient({ domain: options.domain ?? SCHEMA.domain, url: hostUrl(options), fetch: options.fetch, timeoutMs: EDITOR.timeoutMs });
+  return new HostClient({
+    domain: options.domain ?? SCHEMA.domain, url: hostUrl(options), fetch: options.fetch, timeoutMs: EDITOR.timeoutMs, bare: false,
+  });
 }
 
 /**

data/lib/hecks/runtime/value/unwrapping.rb

@@ -0,0 +1,60 @@
+module Hecks
+  module Runtime
+    class Value
+      # The shape a caller is answered with: a single-attribute value object as its bare field,
+      # following the declared types down through nested value objects and lists. Extended into
+      # `Value` beside `Coercion`; `materialize` keeps the wrapped shape stored state depends on.
+      module Unwrapping
+        # `materialize`, but a single-attribute value object unwraps to its bare field. What
+        # `group_by` rows and `Driving::Json.materialize` answer with.
+        #
+        # @param value [Object] the value to materialize; anything that is not a `Runtime::Value`,
+        #   Array or Hash passes through unchanged
+        # @return [Object] `value` with every nested `Runtime::Value` replaced by its own sole
+        #   field's value (recursively unwrapped), or by its own `Hash` of fields when it has
+        #   more than one
+        def materialize_unwrapped(value)
+          case value
+          when self then unwrap_typed(value.value_object, value.raw_fields)
+          when Array then value.map { |item| materialize_unwrapped(item) }
+          when Hash then value.transform_values { |item| materialize_unwrapped(item) }
+          else value
+          end
+        end
+
+        private
+
+        # A value object's fields by its declared attributes. A nested value object is often held
+        # as a plain Hash, so its own type is looked up rather than read off the field.
+        def unwrap_typed(value_object, fields)
+          sole = value_object.sole_attribute
+          return unwrap_field(value_object, sole, fields[sole.name]) if sole
+
+          value_object.attributes.to_h { |attr| [attr.name, unwrap_field(value_object, attr, fields[attr.name])] }
+        end
+
+        def unwrap_field(value_object, attribute, held)
+          case held
+          when Array then held.map { |item| unwrap_field(value_object, attribute, item) }
+          when Hash then unwrap_held_hash(value_object, attribute, held)
+          else materialize_unwrapped(held)
+          end
+        end
+
+        def unwrap_held_hash(value_object, attribute, held)
+          nested = nested_value_object(value_object, attribute.type)
+          return materialize_unwrapped(held) unless nested
+
+          unwrap_typed(nested, held.transform_keys(&:to_sym))
+        end
+
+        # The value object a field's type names, resolved against the aggregate that declares
+        # `value_object`; nil for a primitive, or when the owner is not known.
+        def nested_value_object(value_object, type)
+          owner = value_object.respond_to?(:hecks_owner) ? value_object.hecks_owner : nil
+          owner.respond_to?(:value_object) ? value_object_for(owner, type) : nil
+        end
+      end
+    end
+  end
+end

data/lib/hecks/runtime/value.rb

@@ -9,12 +9,13 @@ require_relative "value/flags"
 require_relative "value/identifiers"
 require_relative "value/entity_list_coercion"
 require_relative "value/admission"
+require_relative "value/unwrapping"
 
 module Hecks
   module Runtime
     # A typed value object: frozen fields, read by name.
     # Construction lives in value/coercion.rb, field_checks.rb, entity_list_coercion.rb and
-    # admission.rb.
+    # admission.rb; the shape a caller is answered with in unwrapping.rb.
     class Value
       extend FieldChecks
       extend Coercion
@@ -24,6 +25,7 @@ module Hecks
       extend Identifiers
       extend EntityListCoercion
       extend Admission
+      extend Unwrapping
 
       attr_reader :value_object
 
@@ -115,32 +117,6 @@ module Hecks
         end
       end
 
-      # `materialize`, but a single-attribute value object unwraps to its bare field.
-      # Opt-in for `group_by` rows; `materialize` keeps the wrapped shape callers depend on.
-      #
-      # @param value [Object] the value to materialize; anything that is not a `Runtime::Value`,
-      #   Array or Hash passes through unchanged
-      # @return [Object] `value` with every nested `Runtime::Value` replaced by its own sole
-      #   field's value (recursively unwrapped), or by its own `Hash` of fields when it has
-      #   more than one
-      def self.materialize_unwrapped(value)
-        case value
-        when self then unwrap_value_object(value)
-        when Array then value.map { |item| materialize_unwrapped(item) }
-        when Hash then value.transform_values { |item| materialize_unwrapped(item) }
-        else value
-        end
-      end
-
-      def self.unwrap_value_object(value)
-        sole = value.value_object.sole_attribute
-        return materialize_unwrapped(value[sole.name]) if sole
-
-        # Not `value.to_h`: it materializes nested values to Hashes, ending the recursion.
-        value.value_object.attributes.to_h { |attr| [attr.name, materialize_unwrapped(value[attr.name])] }
-      end
-      private_class_method :unwrap_value_object
-
       # Reduces an append-only `list_of` sub-log to its current state: the latest row per `key`.
       # Grouping only; what counts as removed, and the ordering, belong to the caller.
       #

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 = "4.0.0".freeze # rust/host/HECKS_RELEASE names the same release
+  VERSION = "5.0.0".freeze # rust/host/HECKS_RELEASE names the same release
 end

data/rust/codegen/src/domain_generator.rs

@@ -1116,6 +1116,12 @@ pub fn generate(
             }
         }
 
+        puts_blank(&mut out);
+        puts_str(
+            &mut out,
+            &crate::presenters::emit_aggregate_presenter(aggregate, &value_objects_by_name),
+        );
+
         aggregate_files.push(GeneratedFile {
             name: format!("{}.rs", crate::naming::aggregate_module(agg_name)),
             content: out,

data/rust/codegen/src/main.rs

@@ -26,6 +26,7 @@ mod naming;
 mod optional_pass;
 mod ports;
 mod prelude;
+mod presenters;
 mod queries;
 mod reactions;
 mod read_models;
@@ -377,6 +378,11 @@ fn run_full(args: &[String]) -> Result<(), String> {
         &mut merged_rs,
         &read_models::emit_read_model_table(&ex, &merged_read_models),
     );
+    puts_blank(&mut merged_rs);
+    puts_str(
+        &mut merged_rs,
+        &presenters::emit_present_router(&merged_aggregates),
+    );
 
     let merged_path = format!("{target_out_dir}/merged.rs");
     std::fs::write(&merged_path, &merged_rs).map_err(|e| format!("writing {merged_path}: {e}"))?;

data/rust/codegen/src/presenters.rs

@@ -0,0 +1,335 @@
+//! The bare answer shape, generated: a port of Ruby's `Value.materialize_unwrapped`, emitted as
+//! type-directed Rust over `crate::kernel::Json`.
+//!
+//! A single-attribute value object answers as its sole field's value, a multi-field one as an
+//! object of its fields, each unwrapped the same way; a list maps item-wise and an entity's
+//! fields are unwrapped. Stored state stays wrapped: this is only what a caller is answered with
+//! (`group_by` rows, and the kernel's `{"present": answer}` input).
+
+use crate::json::Json;
+use crate::registry::AggregateEntry;
+use std::collections::HashMap;
+
+/// Emits an expression unwrapping the `Json` named `expr` as a `type_name` (a `list` of them
+/// when `list`), resolving value objects in `value_objects_by_name` and entities in `aggregate`.
+pub fn unwrap_json_expr(
+    expr: &str,
+    type_name: &str,
+    list: bool,
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> String {
+    Unwrapper {
+        aggregate,
+        value_objects_by_name,
+    }
+    .expr(expr, type_name, list, &mut Vec::new())
+}
+
+/// Emits `pub fn present(state) -> Json` for one aggregate's module: its state (or one of its
+/// events' payloads) with every field it declares unwrapped, other keys passed through.
+///
+/// The fields are the aggregate's attributes and projected fields, then every aggregate and
+/// entity command argument not already named, since an event payload carries a command's
+/// arguments. A name declared with more than one type unwraps by whichever type's field names
+/// the value's own keys fit, first declared first.
+pub fn emit_aggregate_presenter(
+    aggregate: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> String {
+    let unwrapper = Unwrapper {
+        aggregate,
+        value_objects_by_name,
+    };
+    let arms: Vec<String> = presented_fields(aggregate)
+        .iter()
+        .map(|(name, candidates)| format!("{name:?} => {},", unwrapper.candidates("v", candidates)))
+        .collect();
+    if arms.is_empty() {
+        return format!("{PRESENT_DOC}pub fn present(state: crate::kernel::Json) -> crate::kernel::Json {{\n    state\n}}\n");
+    }
+    let arms = arms.join(" ");
+    format!(
+        "{PRESENT_DOC}pub fn present(state: crate::kernel::Json) -> crate::kernel::Json {{\n    match state {{ crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(fields.into_iter().map(|(k, v)| {{ let new_v = match k.as_str() {{ {arms} _ => v }}; (k, new_v) }}).collect()), other => other }}\n}}\n"
+    )
+}
+
+const PRESENT_DOC: &str = "/// This aggregate's state, or one of its events' payloads, as a caller is answered with\n/// it: each single-field value object as its bare field (the shape a command takes it in).\n";
+
+/// Emits the merged target's `present(aggregate, state)`: one arm per generated aggregate across
+/// every chapter, keyed by its qualified `Domain::Aggregate` name; any other name passes through.
+pub fn emit_present_router(aggregates: &[AggregateEntry]) -> String {
+    let arms: Vec<String> = aggregates
+        .iter()
+        .map(|a| {
+            format!(
+                "        {} => crate::generated::{}::{}::present(state),",
+                crate::naming::ruby_inspect_string(&format!("{}::{}", a.domain_name, a.name)),
+                a.chapter_mod,
+                a.module_name
+            )
+        })
+        .collect();
+    format!(
+        "/// One `\"Domain::Aggregate\"` state as a caller is answered with it (the kernel's\n/// `{{\"present\": answer}}` input); stored state stays wrapped. An unknown name passes through.\npub fn present(aggregate: &str, state: crate::kernel::Json) -> crate::kernel::Json {{\n    match aggregate {{\n{}\n        _ => state,\n    }}\n}}\n",
+        arms.join("\n")
+    )
+}
+
+// Each presented name with its distinct declared (type, list) pairs, in declaration order.
+fn presented_fields(aggregate: &Json) -> Vec<(String, Vec<(String, bool)>)> {
+    let mut attributes: Vec<Json> = aggregate
+        .get("attributes")
+        .map_or_default(Json::each)
+        .to_vec();
+    attributes.extend(crate::types::projected_field_pseudo_attributes(aggregate));
+    let commands = aggregate
+        .get("commands")
+        .map_or_default(Json::each)
+        .iter()
+        .chain(
+            aggregate
+                .get("entities")
+                .map_or_default(Json::each)
+                .iter()
+                .flat_map(|e| e.get("commands").map_or_default(Json::each)),
+        );
+    for command in commands {
+        attributes.extend(
+            command
+                .get("attributes")
+                .map_or_default(Json::each)
+                .iter()
+                .cloned(),
+        );
+    }
+
+    let mut fields: Vec<(String, Vec<(String, bool)>)> = Vec::new();
+    for attribute in &attributes {
+        let name = crate::attr::name(attribute).to_string();
+        let candidate = (
+            crate::attr::type_name(attribute).to_string(),
+            crate::attr::list(attribute),
+        );
+        match fields.iter_mut().find(|(n, _)| *n == name) {
+            Some((_, candidates)) if !candidates.contains(&candidate) => candidates.push(candidate),
+            Some(_) => {}
+            None => fields.push((name, vec![candidate])),
+        }
+    }
+    fields
+}
+
+struct Unwrapper<'a> {
+    aggregate: &'a Json,
+    value_objects_by_name: &'a HashMap<String, &'a Json>,
+}
+
+impl Unwrapper<'_> {
+    // The declared fields of a value object or entity type, and whether it is a value object.
+    fn fields_of(&self, type_name: &str) -> Option<(&[Json], bool)> {
+        if let Some(vo) = self.value_objects_by_name.get(type_name) {
+            return vo.get("attributes").map(|a| (Json::each(a), true));
+        }
+        self.aggregate
+            .get("entities")
+            .map_or_default(Json::each)
+            .iter()
+            .find(|e| e.get("name").map(Json::to_s).unwrap_or_default() == type_name)
+            .and_then(|e| e.get("attributes").map(|a| (Json::each(a), false)))
+    }
+
+    // `seen` holds the types being expanded, so a type that contains itself stops there and
+    // passes its nested value through rather than recursing without end.
+    fn expr(&self, expr: &str, type_name: &str, list: bool, seen: &mut Vec<String>) -> String {
+        if list {
+            let inner = self.expr("item", type_name, false, seen);
+            return format!("match {expr} {{ crate::kernel::Json::Array(items) => crate::kernel::Json::Array(items.into_iter().map(|item| {inner}).collect()), other => other }}");
+        }
+        let Some((fields_meta, is_value_object)) = self.fields_of(type_name) else {
+            return expr.to_string();
+        };
+        if seen.iter().any(|s| s == type_name) {
+            return expr.to_string();
+        }
+        seen.push(type_name.to_string());
+        let out = if is_value_object && fields_meta.len() == 1 {
+            let field = &fields_meta[0];
+            let unwrapped = self.expr(
+                "field_value",
+                crate::attr::type_name(field),
+                crate::attr::list(field),
+                seen,
+            );
+            let field_name = crate::attr::name(field);
+            format!("match {expr} {{ crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == {field_name:?}).map_or(crate::kernel::Json::Null, |(_, field_value)| {unwrapped}), other => other }}")
+        } else {
+            let inner_arms: Vec<String> = fields_meta
+                .iter()
+                .map(|f| {
+                    let unwrapped =
+                        self.expr("v", crate::attr::type_name(f), crate::attr::list(f), seen);
+                    format!("{:?} => {unwrapped},", crate::attr::name(f))
+                })
+                .collect();
+            let inner_arms = inner_arms.join(" ");
+            format!("match {expr} {{ crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(fields.into_iter().map(|(k, v)| {{ let new_v = match k.as_str() {{ {inner_arms} _ => v }}; (k, new_v) }}).collect()), other => other }}")
+        };
+        seen.pop();
+        out
+    }
+
+    // One declared type unwraps unconditionally; several are told apart by the value's keys.
+    fn candidates(&self, expr: &str, candidates: &[(String, bool)]) -> String {
+        if let [(type_name, list)] = candidates {
+            return self.expr(expr, type_name, *list, &mut Vec::new());
+        }
+        let branches: Vec<String> = candidates
+            .iter()
+            .filter_map(|(type_name, list)| {
+                let guard = self.fits(&format!("&{expr}"), type_name, *list)?;
+                let unwrapped = self.expr(expr, type_name, *list, &mut Vec::new());
+                Some(format!("if {guard} {{ {unwrapped} }}"))
+            })
+            .collect();
+        if branches.is_empty() {
+            return expr.to_string();
+        }
+        format!("{} else {{ {expr} }}", branches.join(" else "))
+    }
+
+    // Whether the value at `expr` (a `&Json`) has the shape of `type_name`: an object whose keys
+    // are all its declared fields. `None` for a type with no fields to unwrap.
+    fn fits(&self, expr: &str, type_name: &str, list: bool) -> Option<String> {
+        if list {
+            let item = self.fits("item", type_name, false)?;
+            return Some(format!("matches!({expr}, crate::kernel::Json::Array(items) if items.iter().all(|item| {item}))"));
+        }
+        let (fields_meta, _) = self.fields_of(type_name)?;
+        let names: Vec<String> = fields_meta
+            .iter()
+            .map(|f| format!("{:?}", crate::attr::name(f)))
+            .collect();
+        Some(format!("matches!({expr}, crate::kernel::Json::Object(fields) if fields.iter().all(|(k, _)| matches!(k.as_str(), {})))", names.join(" | ")))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn attribute(name: &str, type_name: &str, list: bool) -> String {
+        format!(r#"{{"name": "{name}", "type": "{type_name}", "list": {list}}}"#)
+    }
+
+    fn value_object(name: &str, attributes: &[String]) -> String {
+        format!(
+            r#"{{"name": "{name}", "attributes": [{}]}}"#,
+            attributes.join(", ")
+        )
+    }
+
+    // Pizzas' `Order`, cut down: a single-field name, a multi-field pizza holding two
+    // single-field value objects, a list of single-field tags, and two commands that both
+    // take an `amount` of a different single-field type.
+    fn order() -> Json {
+        let text = format!(
+            r#"{{"name": "Order",
+                "attributes": [{}, {}, {}],
+                "value_objects": [{}, {}, {}, {}, {}, {}],
+                "commands": [
+                  {{"name": "CreatePizza", "attributes": [{}, {}]}},
+                  {{"name": "AddTopping", "attributes": [{}]}},
+                  {{"name": "Purchase", "attributes": [{}]}}
+                ]}}"#,
+            attribute("name", "PizzaName", false),
+            attribute("pizza", "Pizza", false),
+            attribute("tags", "Tag", true),
+            value_object("PizzaName", &[attribute("value", "String", false)]),
+            value_object("Price", &[attribute("cents", "Integer", false)]),
+            value_object("Size", &[attribute("value", "String", false)]),
+            value_object("Tag", &[attribute("value", "String", false)]),
+            value_object("ToppingAmount", &[attribute("value", "Integer", false)]),
+            value_object(
+                "Pizza",
+                &[
+                    attribute("price_cents", "Price", false),
+                    attribute("size", "Size", false)
+                ]
+            ),
+            attribute("name", "PizzaName", false),
+            attribute("pizza", "Pizza", false),
+            attribute("amount", "ToppingAmount", false),
+            attribute("amount", "Price", false),
+        );
+        Json::parse(&text).unwrap()
+    }
+
+    fn presenter() -> String {
+        let order = order();
+        let vos: Vec<&Json> = order
+            .get("value_objects")
+            .map_or_default(Json::each)
+            .iter()
+            .collect();
+        let by_name: HashMap<String, &Json> = vos
+            .iter()
+            .map(|vo| (vo.get("name").map(Json::to_s).unwrap_or_default(), *vo))
+            .collect();
+        emit_aggregate_presenter(&order, &by_name)
+    }
+
+    #[test]
+    fn a_single_field_attribute_presents_as_its_sole_field() {
+        assert!(presenter().contains(r#""name" => match v { crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == "value")"#));
+    }
+
+    #[test]
+    fn a_multi_field_value_object_keeps_its_object_and_unwraps_each_field() {
+        let text = presenter();
+        assert!(text.contains(r#""pizza" => match v { crate::kernel::Json::Object(fields) => crate::kernel::Json::Object("#));
+        assert!(text.contains(r#""price_cents" => match v { crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == "cents")"#));
+        assert!(text.contains(r#""size" => match v { crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == "value")"#));
+    }
+
+    #[test]
+    fn a_list_of_single_field_value_objects_maps_item_wise() {
+        assert!(presenter().contains(r#""tags" => match v { crate::kernel::Json::Array(items) => crate::kernel::Json::Array(items.into_iter().map(|item| match item { crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == "value")"#));
+    }
+
+    #[test]
+    fn a_name_declared_with_two_types_is_told_apart_by_its_keys() {
+        let text = presenter();
+        let arm = text.split(r#""amount" => "#).nth(1).unwrap();
+        assert!(arm.starts_with(r#"if matches!(&v, crate::kernel::Json::Object(fields) if fields.iter().all(|(k, _)| matches!(k.as_str(), "value")))"#));
+        assert!(arm.contains(r#"else if matches!(&v, crate::kernel::Json::Object(fields) if fields.iter().all(|(k, _)| matches!(k.as_str(), "cents")))"#));
+    }
+
+    #[test]
+    fn a_command_argument_already_named_by_an_attribute_adds_no_second_arm() {
+        assert_eq!(presenter().matches(r#""name" => "#).count(), 1);
+    }
+
+    #[test]
+    fn the_router_names_each_aggregate_qualified_and_passes_any_other_through() {
+        let entry = AggregateEntry {
+            name: "Order".to_string(),
+            module_name: "order".to_string(),
+            record: "Order".to_string(),
+            commands: vec![],
+            entity_commands: vec![],
+            nested_entity_commands: vec![],
+            ports: vec![],
+            chapter_mod: "pizzas".to_string(),
+            domain_name: "Pizzas".to_string(),
+            reference_specs: vec![],
+            identified_by: vec![],
+            entities: vec![],
+        };
+        let text = emit_present_router(&[entry]);
+        assert!(
+            text.contains(r#""Pizzas::Order" => crate::generated::pizzas::order::present(state),"#)
+        );
+        assert!(text.contains("_ => state,"));
+    }
+}

data/rust/codegen/src/read_models.rs

@@ -3,6 +3,7 @@
 
 use crate::exemplar::Exemplar;
 use crate::json::Json;
+use crate::presenters::unwrap_json_expr;
 use crate::queries;
 use crate::shared::ruby_to_i;
 use crate::skip_reason::{reskip, skip, SkipReason};
@@ -1030,63 +1031,6 @@ fn group_by_leaf_check(
     )
 }
 
-// Port of `Value.materialize_unwrapped` (Ruby).
-fn unwrap_json_expr(
-    expr: &str,
-    type_name: &str,
-    list: bool,
-    aggregate: &Json,
-    value_objects_by_name: &HashMap<String, &Json>,
-) -> String {
-    if list {
-        let inner = unwrap_json_expr("item", type_name, false, aggregate, value_objects_by_name);
-        return format!("match {expr} {{ crate::kernel::Json::Array(items) => crate::kernel::Json::Array(items.into_iter().map(|item| {inner}).collect()), other => other }}");
-    }
-
-    let vo = value_objects_by_name.get(type_name).copied();
-    let entity = aggregate
-        .get("entities")
-        .map_or_default(Json::each)
-        .iter()
-        .find(|e| e.get("name").map(Json::to_s).unwrap_or_default() == type_name);
-    let fields_meta: Option<&[Json]> = vo.map_or_else(
-        || entity.and_then(|e| e.get("attributes").map(Json::each)),
-        |vo| vo.get("attributes").map(Json::each),
-    );
-    let Some(fields_meta) = fields_meta else {
-        return expr.to_string();
-    };
-
-    if vo.is_some() && fields_meta.len() == 1 {
-        let field = &fields_meta[0];
-        let unwrapped = unwrap_json_expr(
-            "field_value",
-            crate::attr::type_name(field),
-            crate::attr::list(field),
-            aggregate,
-            value_objects_by_name,
-        );
-        let field_name = crate::attr::name(field);
-        return format!("match {expr} {{ crate::kernel::Json::Object(fields) => fields.into_iter().find(|(k, _)| k == {field_name:?}).map_or(crate::kernel::Json::Null, |(_, field_value)| {unwrapped}), other => other }}");
-    }
-
-    let inner_arms: Vec<String> = fields_meta
-        .iter()
-        .map(|f| {
-            let unwrapped = unwrap_json_expr(
-                "v",
-                crate::attr::type_name(f),
-                crate::attr::list(f),
-                aggregate,
-                value_objects_by_name,
-            );
-            format!("{:?} => {unwrapped},", crate::attr::name(f))
-        })
-        .collect();
-    let inner_arms = inner_arms.join(" ");
-    format!("match {expr} {{ crate::kernel::Json::Object(fields) => crate::kernel::Json::Object(fields.into_iter().map(|(k, v)| {{ let new_v = match k.as_str() {{ {inner_arms} _ => v }}; (k, new_v) }}).collect()), other => other }}")
-}
-
 const READ_MODEL_TABLE_ROW_PLACEHOLDER: &str = "crate::kernel::read_model::ReadModelDef {\n    verb: \"tmpl_verb\",\n    reference_name: Some(\"tmpl_reference_name\"),\n    heads: &[\n        crate::kernel::read_model::ReadModelHead {\n            aggregate: \"tmpl_aggregate\",\n            as_name: \"tmpl_as_name\",\n            many: true,\n            is_root: false,\n            reference_fields: &[\n                crate::kernel::read_model::ReferenceField { target_aggregate: \"tmpl_target_aggregate\", field: \"tmpl_field\" },\n            ],\n        },\n    ],\n    filtered_heads: &[\n        crate::kernel::read_model::FilteredHead { as_name: \"tmpl_as_name\", conditions: &[crate::kernel::QueryCondition { field: \"tmpl_field\", comparator: crate::kernel::query_comparators::QueryComparator::Eq, value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\") },], reference_hop_conditions: &[crate::kernel::read_model::ReferenceHopCondition { via_field: \"tmpl_via_field\", target_aggregate: \"tmpl_target_aggregate\", through: &[crate::kernel::read_model::HopStep { via_field: \"tmpl_via_field\", target_aggregate: \"tmpl_target_aggregate\" }], inner_field: \"tmpl_inner_field\", inner_comparator: crate::kernel::query_comparators::QueryComparator::Eq, inner_value: crate::kernel::QueryConditionValue::Literal(\"tmpl_literal\") },], order_by: Some(crate::kernel::read_model::ReadModelOrderBy { field: \"tmpl_order_field\", descending: true, nulls: crate::kernel::query_ordering::NullsMode::Last }), offset: Some(crate::kernel::read_model::ReadModelOffset::Literal(1)), limit: Some(crate::kernel::read_model::ReadModelLimit::Literal(5)) },\n    ],\n    authorization: Some(crate::kernel::named_query::TenantAuth { query_name: \"tmpl_query_name\", tenant_field: \"tmpl_tenant_field\", policy: \"tmpl_policy\" }),\n    group_by: None,\n    reduction: None,\n},";
 
 pub fn emit_read_model_table(exemplar: &Exemplar, read_model_defs: &[ReadModelDef]) -> String {

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-4.0.0
+5.0.0

data/rust/host/src/dispatch.rs

@@ -715,6 +715,29 @@ pub async fn query(
     parse_kernel_output(&output)
 }
 
+/// Answers `answer` (a kernel answer already computed and persisted) in the bare shape a caller
+/// reads, by one more wasm run of the kernel's `{"present": answer}` input: each single-field
+/// value object as its sole field. Nothing is stored or replayed.
+pub async fn present(
+    wasm_path: &Path,
+    answer: serde_json::Value,
+) -> anyhow::Result<serde_json::Value> {
+    let owned_wasm_path = wasm_path.to_path_buf();
+    tokio::task::spawn_blocking(move || {
+        present_with(&answer, |input| wasm_runner::run(&owned_wasm_path, input))
+    })
+    .await?
+}
+
+/// Presents `answer` as `present` does, with `run` standing in for the kernel (text in, text out).
+pub(crate) fn present_with(
+    answer: &serde_json::Value,
+    run: impl FnOnce(&str) -> anyhow::Result<String>,
+) -> anyhow::Result<serde_json::Value> {
+    let input = serde_json::json!({ "present": answer }).to_string();
+    parse_kernel_output(&run(&input)?)
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
 
@@ -963,6 +986,30 @@ pub(crate) mod tests {
         }
     }
 
+    #[test]
+    fn present_hands_the_kernel_the_answer_under_present_and_answers_what_it_returns() {
+        let answer = serde_json::json!({"instances": {"Shop::Item#a": {"name": {"value": "x"}}}});
+        let mut sent = String::new();
+        let presented = present_with(&answer, |input| {
+            sent = input.to_string();
+            Ok(r#"{"instances":{"Shop::Item#a":{"name":"x"}}}"#.to_string())
+        })
+        .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&sent).unwrap(),
+            serde_json::json!({ "present": answer })
+        );
+        assert_eq!(presented["instances"]["Shop::Item#a"]["name"], "x");
+    }
+
+    #[test]
+    fn present_is_an_error_when_the_kernel_fails() {
+        let failed = present_with(&serde_json::json!({}), |_| {
+            Ok(r#"{"error":"expected a top-level {\"steps\": [...]} object"}"#.to_string())
+        });
+        assert!(failed.is_err());
+    }
+
     pub(crate) fn wasm_path() -> std::path::PathBuf {
         std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../dist/banking.wasm")
     }

data/rust/host/src/server.rs

@@ -25,16 +25,36 @@ use tokio_postgres::Client;
 
 /// The per-request dispatch decision, shared between the Lambda custom-runtime path and the
 /// axum fallback route below. `body` is already-parsed JSON in one of its recognized shapes.
+///
+/// `"bare": true` beside any of them (`verb` with `to`/`with` or `args`, `read`, `query`) answers
+/// the same outcome with each single-field value object as its bare field
+/// (`{"name": "Margherita"}`, not `{"name": {"value": "Margherita"}}`). What is stored is the
+/// same either way; without `bare` the answer is the stored shape.
 pub async fn dispatch_body(body: Value, host: Host<'_>) -> Result<Value, Error> {
+    if let Some(response) = web::render(&body, host).await {
+        return Ok(response);
+    }
+    let answer = kernel_answer(&body, host).await?;
+    if !wants_bare(&body) {
+        return Ok(answer);
+    }
+    Ok(dispatch::present(host.wasm_path, answer)
+        .await
+        .map_err(|e| format!("{e:#}"))?)
+}
+
+fn wants_bare(body: &Value) -> bool {
+    body.get("bare").and_then(Value::as_bool) == Some(true)
+}
+
+// The kernel's outcome for a read, query or command body, in the stored shape.
+async fn kernel_answer(body: &Value, host: Host<'_>) -> Result<Value, Error> {
     let Host {
         client,
         wasm_path,
         config,
         ..
     } = host;
-    if let Some(response) = web::render(&body, host).await {
-        return Ok(response);
-    }
 
     if body.get("read").and_then(serde_json::Value::as_bool) == Some(true) {
         // `{e:#}`: anyhow's alternate Display walks `source()` to the real message,
@@ -48,7 +68,7 @@ pub async fn dispatch_body(body: Value, host: Host<'_>) -> Result<Value, Error>
     // A query step reads current state and writes nothing to the journal.
     if body.get("query").is_some() {
         return Ok(crate::query_step::answer(
-            &body,
+            body,
             crate::ir::ir(),
             &config.domain,
             client,
@@ -1041,6 +1061,58 @@ mod tests {
         );
     }
 
+    // The checkout fixture's `Event`: `slug`, `name` and `capacity` hold one `value` field and
+    // `price` one `cents` field, so each answers as a bare scalar when asked to.
+    #[tokio::test]
+    async fn a_bare_body_answers_single_field_value_objects_bare_and_the_default_stays_wrapped() {
+        let client = crate::dispatch::tests::scratch_db("rust_host_serve_bare").await;
+        crate::dispatch::tests::provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event"],
+        )
+        .await;
+        let config = LineageConfig {
+            domain: "CheckoutFixture".to_string(),
+            era: Some(1),
+            mirrored: None,
+        };
+        let wasm = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../dist/checkout_fixture.wasm");
+        let host = Host::new(&client, &wasm, &config, &crate::lambda_client::NeverInvoker);
+        let schedule = serde_json::json!({
+            "verb": "CheckoutFixture::Event.Schedule",
+            "role": "Organizer",
+            "with": {"slug": "intro", "name": "Intro", "price": 1500, "capacity": 10},
+            "bare": true,
+        });
+
+        let scheduled = dispatch_body(schedule, host).await.unwrap();
+        let wrapped = dispatch_body(serde_json::json!({"read": true}), host)
+            .await
+            .unwrap();
+        let bare = dispatch_body(serde_json::json!({"read": true, "bare": true}), host)
+            .await
+            .unwrap();
+
+        let event = "CheckoutFixture::Event#intro";
+        assert_eq!(
+            scheduled["instances"][event]["name"], "Intro",
+            "{scheduled}"
+        );
+        assert_eq!(
+            scheduled["events"][0]["payload"]["price"], 1500,
+            "{scheduled}"
+        );
+        assert_eq!(
+            wrapped["instances"][event]["name"],
+            serde_json::json!({"value": "Intro"}),
+            "{wrapped}"
+        );
+        assert_eq!(bare["instances"][event]["price"], 1500, "{bare}");
+        assert_eq!(bare["instances"][event]["capacity"], 10, "{bare}");
+    }
+
     #[test]
     fn build_is_the_env_value_when_set() {
         assert_eq!(version_body("e", "h", Some("cms-1"))["build"], "cms-1");

data/rust/src/kernel/cli.rs

@@ -1,5 +1,6 @@
 //! The stdin/stdout JSON CLI shared by the native binary and the wasm32-wasip1 module.
-//! `run` reads `{"steps": [...]}` and hands each step to `kernel::orchestrate` (ADR 0012).
+//! `run` reads `{"steps": [...]}` and hands each step to `kernel::orchestrate` (ADR 0012), or
+//! `{"present": answer}` and answers that answer bare (`kernel::present`).
 
 use super::{
     named_query, orchestrate, query_comparators, read_model, repository, AggregateScan,
@@ -24,6 +25,18 @@ pub fn run(input: &str) -> String {
         Err(e) => return error_output(&format!("invalid JSON on stdin: {e}")),
     };
 
+    // `{"present": answer}`: a run's answer in the bare shape a caller reads (single-field value
+    // objects as their sole field); no step runs, and stored state stays wrapped.
+    // Parsed again keeping number text, so a Float the answer carries is written back unchanged.
+    if parsed.get("present").is_some() {
+        let answer = Json::parse_keeping_number_text(input)
+            .ok()
+            .and_then(|whole| whole.get("present").cloned())
+            .unwrap_or(Json::Null);
+        return super::present::present_answer(answer, crate::generated::active::present)
+            .to_json_string();
+    }
+
     // Optional `"needs"`: which commands need which outside facts (ADR 0081), passed by the host.
     super::needs::install(parsed.get("needs"));
     // Optional `"query_needs"`: which queries need which outside facts, filled the same way.

data/rust/src/kernel/json.rs

@@ -371,9 +371,21 @@ impl Json {
     }
 
     pub fn parse(input: &str) -> Result<Self, String> {
+        Self::parse_with(input, false)
+    }
+
+    /// Parses `input` keeping every number literal's source text, so writing the value back
+    /// reproduces each number exactly as given (`0.0` stays `0.0`, not `0`). For a document that
+    /// is only reshaped and written out again, never evaluated.
+    pub fn parse_keeping_number_text(input: &str) -> Result<Self, String> {
+        Self::parse_with(input, true)
+    }
+
+    fn parse_with(input: &str, keep_number_text: bool) -> Result<Self, String> {
         let mut parser = Parser {
             chars: input.chars().peekable(),
             depth: 0,
+            keep_number_text,
         };
         let value = parser.parse_value()?;
         parser.skip_ws();
@@ -703,6 +715,7 @@ fn write_escaped_string(s: &str, out: &mut String) {
 struct Parser<'a> {
     chars: std::iter::Peekable<std::str::Chars<'a>>,
     depth: usize,
+    keep_number_text: bool,
 }
 
 /// How deeply arrays and objects may nest before `parse` refuses. Each level is a recursive call,
@@ -895,7 +908,8 @@ impl Parser<'_> {
         // A literal with a `.`/exponent is a genuine `Float`, and Ruby's `Float` is the same
         // `f64` Rust's is, so there is nothing to preserve there.
         let is_plain_integer = !s.contains('.') && !s.contains(['e', 'E']);
-        let keeps_source = is_plain_integer && canonical_integer_digits(value) != s;
+        let keeps_source =
+            self.keep_number_text || (is_plain_integer && canonical_integer_digits(value) != s);
         // `1e999` parses to infinity with no source text kept, and `write` would print it as `inf`:
         // not JSON, so refuse it. A plain integer keeps its digits, which `write` re-emits as-is.
         if !value.is_finite() && !keeps_source {

data/rust/src/kernel/mod.rs

@@ -10,6 +10,7 @@ pub mod named_query;
 pub mod needs;
 pub mod orchestrate;
 pub mod pattern;
+pub mod present;
 pub mod query_ordering;
 pub mod vocab;
 // Kept at its old path so existing `refusal_wording::RefusalSite` call sites still resolve.

data/rust/src/kernel/present.rs

@@ -0,0 +1,261 @@
+//! The kernel's `{"present": answer}` input: a run's answer turned into the bare shape a caller
+//! is answered with, by the generated `present(aggregate, state)` router.
+//!
+//! It runs no step and touches no store. Only what a caller reads is presented: `instances`,
+//! each event's `payload`, and each declared query's `rows`. Everything a host stores or replays
+//! (`mutations`, `sagas`, `saga_snapshot`, ...) is left exactly as it came, because stored state
+//! stays wrapped.
+
+use super::Json;
+
+/// The generated router's shape: one `"Domain::Aggregate"` state in, its bare shape out.
+pub type Presenter = fn(&str, Json) -> Json;
+
+/// Returns `answer` with its `instances`, event payloads and declared query rows presented
+/// through `present`; every other key passes through verbatim.
+pub fn present_answer(answer: Json, present: Presenter) -> Json {
+    let Json::Object(fields) = answer else {
+        return answer;
+    };
+    Json::Object(
+        fields
+            .into_iter()
+            .map(|(key, value)| {
+                let value = match key.as_str() {
+                    "instances" => present_instances(value, present),
+                    "events" => map_items(value, |event| present_event(event, present)),
+                    "queries" => map_items(value, |entry| present_query(entry, present)),
+                    _ => value,
+                };
+                (key, value)
+            })
+            .collect(),
+    )
+}
+
+// `"Domain::Aggregate#id" => state`: the aggregate is the key up to its first `#`.
+fn present_instances(instances: Json, present: Presenter) -> Json {
+    let Json::Object(entries) = instances else {
+        return instances;
+    };
+    Json::Object(
+        entries
+            .into_iter()
+            .map(|(key, state)| {
+                let aggregate = key.split_once('#').map_or(key.as_str(), |(head, _)| head);
+                let state = present(aggregate, state);
+                (key, state)
+            })
+            .collect(),
+    )
+}
+
+fn present_event(event: Json, present: Presenter) -> Json {
+    let Some(aggregate) = event
+        .get("aggregate")
+        .and_then(Json::as_str)
+        .map(str::to_string)
+    else {
+        return event;
+    };
+    replace_field(event, "payload", |payload| present(&aggregate, payload))
+}
+
+// A declared query is named `"Domain::Aggregate.Query"`; its rows are that aggregate's state.
+// A read model or an ad hoc filter names no aggregate this way, and the router passes an unknown
+// name through, so its rows come back as they were.
+fn present_query(entry: Json, present: Presenter) -> Json {
+    let Some(aggregate) = entry
+        .get("query")
+        .and_then(Json::as_str)
+        .and_then(|question| question.rsplit_once('.'))
+        .map(|(head, _)| head.to_string())
+    else {
+        return entry;
+    };
+    replace_field(entry, "rows", |rows| {
+        map_items(rows, |row| present(&aggregate, row))
+    })
+}
+
+fn replace_field(object: Json, name: &str, f: impl Fn(Json) -> Json) -> Json {
+    let Json::Object(fields) = object else {
+        return object;
+    };
+    Json::Object(
+        fields
+            .into_iter()
+            .map(|(key, value)| {
+                let value = if key == name { f(value) } else { value };
+                (key, value)
+            })
+            .collect(),
+    )
+}
+
+fn map_items(list: Json, f: impl Fn(Json) -> Json) -> Json {
+    match list {
+        Json::Array(items) => Json::Array(items.into_iter().map(f).collect()),
+        other => other,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Stands in for the generated router: `Shop::Item` unwraps its `name` object to its
+    // `value`; any other aggregate passes through, as the generated one does.
+    fn shop_present(aggregate: &str, state: Json) -> Json {
+        if aggregate != "Shop::Item" {
+            return state;
+        }
+        replace_field(state, "name", |name| {
+            name.get("value").cloned().unwrap_or(name)
+        })
+    }
+
+    fn present(text: &str) -> String {
+        present_answer(Json::parse(text).unwrap(), shop_present).to_json_string()
+    }
+
+    #[test]
+    fn instances_are_presented_by_the_aggregate_their_key_names() {
+        assert_eq!(
+            present(
+                r#"{"instances":{"Shop::Item#a":{"name":{"value":"x"}},"Other::Thing#b":{"name":{"value":"y"}}}}"#
+            ),
+            r#"{"instances":{"Shop::Item#a":{"name":"x"},"Other::Thing#b":{"name":{"value":"y"}}}}"#
+        );
+    }
+
+    #[test]
+    fn an_event_payload_is_presented_by_its_aggregate() {
+        assert_eq!(
+            present(
+                r#"{"events":[{"name":"Named","aggregate":"Shop::Item","payload":{"name":{"value":"x"}}}]}"#
+            ),
+            r#"{"events":[{"name":"Named","aggregate":"Shop::Item","payload":{"name":"x"}}]}"#
+        );
+    }
+
+    #[test]
+    fn declared_query_rows_are_presented_by_the_aggregate_the_query_names() {
+        assert_eq!(
+            present(
+                r#"{"queries":[{"query":"Shop::Item.All","rows":[{"id":"a","name":{"value":"x"}}],"reference_rows":[{"name":{"value":"x"}}]}]}"#
+            ),
+            r#"{"queries":[{"query":"Shop::Item.All","rows":[{"id":"a","name":"x"}],"reference_rows":[{"name":{"value":"x"}}]}]}"#
+        );
+    }
+
+    #[test]
+    fn mutations_sagas_and_refusals_pass_through_verbatim() {
+        let text = r#"{"mutations":[[{"aggregate":"Shop::Item","state":{"name":{"value":"x"}}}]],"sagas":[],"refusals":[{"verb":"Shop::Item.Name","error":"no"}]}"#;
+        assert_eq!(present(text), text);
+    }
+}
+
+// Through `cli::run` and the generated pizzas router: what `{"present": answer}` answers for a
+// real run's answer.
+#[cfg(test)]
+#[cfg(feature = "pizzas")]
+mod pizzas_tests {
+    use crate::kernel::cli::run;
+    use crate::kernel::Json;
+
+    const STEPS: &str = r#"{"steps":[
+        {"verb":"Pizzas::Order.CreatePizza","with":{"name":"Margherita","pizza":{"price_cents":1200,"size":"large"}}},
+        {"verb":"Pizzas::Order.AddTopping","to":"Margherita","with":{"topping":"basil","amount":2}},
+        {"verb":"Pizzas::Order.Purchase","to":"Margherita","with":{"amount":1500,"customer_name":"Ann"}},
+        {"query":"Pizzas::Order.Everything"}]}"#;
+
+    fn answers() -> (Json, Json) {
+        let answer = run(STEPS);
+        let presented = run(&format!(r#"{{"present":{answer}}}"#));
+        (
+            Json::parse(&answer).unwrap(),
+            Json::parse(&presented).unwrap(),
+        )
+    }
+
+    fn text(value: Option<&Json>) -> String {
+        value.map_or_else(|| "missing".to_string(), Json::to_json_string)
+    }
+
+    fn items<'a>(value: &'a Json, key: &str) -> &'a [Json] {
+        value.get(key).and_then(Json::as_array).unwrap_or_default()
+    }
+
+    #[test]
+    fn an_instance_answers_bare_and_a_multi_field_value_object_keeps_its_object() {
+        let (_, presented) = answers();
+        assert_eq!(
+            text(presented.dig("instances.Pizzas::Order#Margherita")),
+            r#"{"name":"Margherita","pizza":{"price_cents":1200,"size":"large"},"toppings":[{"name":"basil","amount":2}],"customer_name":"Ann","status":"sold"}"#
+        );
+    }
+
+    #[test]
+    fn each_event_payload_answers_bare_even_where_two_commands_type_one_name_apart() {
+        let (_, presented) = answers();
+        let payloads: Vec<String> = items(&presented, "events")
+            .iter()
+            .map(|event| text(event.get("payload")))
+            .collect();
+        assert_eq!(
+            payloads,
+            [
+                r#"{"name":"Margherita","pizza":{"price_cents":1200,"size":"large"}}"#,
+                r#"{"topping":"basil","amount":2}"#,
+                r#"{"amount":1500,"customer_name":"Ann"}"#,
+            ]
+        );
+    }
+
+    #[test]
+    fn a_declared_query_row_answers_bare() {
+        let (_, presented) = answers();
+        assert_eq!(
+            text(items(&presented, "queries")[0].get("rows")),
+            r#"[{"id":"Margherita","name":"Margherita","pizza":{"price_cents":1200,"size":"large"},"toppings":[{"name":"basil","amount":2}],"customer_name":"Ann","status":"sold"}]"#
+        );
+    }
+
+    #[test]
+    fn mutations_and_the_run_without_present_stay_wrapped() {
+        let (answer, presented) = answers();
+        assert_eq!(
+            text(presented.get("mutations")),
+            text(answer.get("mutations"))
+        );
+        assert_eq!(
+            text(answer.dig("instances.Pizzas::Order#Margherita.name")),
+            r#"{"value":"Margherita"}"#
+        );
+    }
+}
+
+#[cfg(test)]
+#[cfg(feature = "tally")]
+mod tally_tests {
+    use crate::kernel::cli::run;
+    use crate::kernel::Json;
+
+    #[test]
+    fn a_list_of_single_field_value_objects_answers_as_scalars_and_a_float_stays_one() {
+        let answer = run(
+            r#"{"steps":[{"verb":"Tallying::Tally.Open","with":{"tag":"a"}},
+                {"verb":"Tallying::Tally.TagWith","to":"a","with":{"label":"red"}},
+                {"verb":"Tallying::Tally.TagWith","to":"a","with":{"label":"blue"}}]}"#,
+        );
+        let presented =
+            Json::parse_keeping_number_text(&run(&format!(r#"{{"present":{answer}}}"#))).unwrap();
+        let tally = presented.dig("instances.Tallying::Tally#a").unwrap();
+        assert_eq!(
+            tally.get("tags").unwrap().to_json_string(),
+            r#"["red","blue"]"#
+        );
+        assert_eq!(tally.get("weight").unwrap().to_json_string(), "0.0");
+    }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Chris Young
@@ -1543,6 +1543,7 @@ files:
 - lib/hecks/runtime/value/invariant_violation.rb
 - lib/hecks/runtime/value/references.rb
 - lib/hecks/runtime/value/shape_checks.rb
+- lib/hecks/runtime/value/unwrapping.rb
 - lib/hecks/runtime/value/validation.rb
 - lib/hecks/rust_build.rb
 - lib/hecks/rust_build/conformance.rb
@@ -1685,9 +1686,9 @@ files:
 - lib/rubocop/cop/hecks/symbol_string_key_mix.rb
 - lib/rubocop/cop/hecks/thread_shared_ivar_mutation.rb
 - lib/rubocop/cop/hecks/untyped_raise.rb
-- prebuilt/02c09c73b272c1fb5a9ae6d87bb5e5e529208e00f6b4b597dc2c0fd70a9c0964.marshal
-- prebuilt/bb84a835cf6a15136bad5ca03aa5bf93a5b92f5f72444618d3ef2412b987fb32.marshal
-- prebuilt/verdicts-f1f10da14c8e8f01b4c9b7e3e2d74be8cd2bf4676364ed17fa16975d2a076d75.json
+- prebuilt/ad68f9e06c8068c2a4176b57abf3083d591d5d8980c2b3e897b97331f965b643.marshal
+- prebuilt/ee22ec8642c4006717ba2b80f46e5efb81de459eef9dfec043e838c0ad4fd720.marshal
+- prebuilt/verdicts-b69f5dcbba79c20daa0493476fa7c317004a30aa2bc3d3dc6a722ea70ae2b43b.json
 - qa/settings.yml
 - rust/.cargo/config.toml
 - rust/.cargo/mutants.toml
@@ -1743,6 +1744,7 @@ files:
 - rust/codegen/src/optional_pass.rs
 - rust/codegen/src/ports.rs
 - rust/codegen/src/prelude.rs
+- rust/codegen/src/presenters.rs
 - rust/codegen/src/queries.rs
 - rust/codegen/src/reactions.rs
 - rust/codegen/src/read_models.rs
@@ -1946,6 +1948,7 @@ files:
 - rust/src/kernel/orchestrate.rs
 - rust/src/kernel/orchestrate_guard_tests.rs
 - rust/src/kernel/pattern.rs
+- rust/src/kernel/present.rs
 - rust/src/kernel/query_comparators.rs
 - rust/src/kernel/query_ordering.rs
 - rust/src/kernel/read_model.rs