hecks 6.0.0 → 7.0.0

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

@@ -31,10 +31,12 @@ pub fn parse_body(
         let line = gated.line.number;
 
         match gated.row.word {
-            // A dotted symbol (`:"reference.value"`), which only `positional_symbol` can spell.
+            // A dotted symbol (`:"reference.value"`), or a bare aggregate name (`Message`), which
+            // `build::correlation_keys` resolves once every aggregate is known.
             "correlates_by" => {
-                pm.correlates_by =
-                    super::positional_symbol(file, line, "correlates_by", &gated.args, 1)?;
+                let raw =
+                    super::positional_raw(file, line, "correlates_by", &gated.args, 1)?.trim();
+                pm.correlates_by = super::symbol_text(raw).unwrap_or_else(|| raw.to_string());
             }
             // Event references keep only the bare final segment (`Naming.event_name_ref`);
             // `SagaInterpreter` matches them against a bare `event.name`.
@@ -48,13 +50,18 @@ pub fn parse_body(
                 )?);
             }
             "ends_on" => {
-                pm.ends_on = Some(super::positional_event_name_ref(
-                    file,
-                    line,
-                    "ends_on",
-                    &gated.args,
-                    1,
-                )?);
+                // A process manager can end on several events: `ends_on` is the first, as the
+                // Ruby builder's `ends_on` reads `endings.first`.
+                let event =
+                    super::positional_event_name_ref(file, line, "ends_on", &gated.args, 1)?;
+                pm.ends_on.get_or_insert_with(|| event.clone());
+                pm.endings.push(event);
+            }
+            // Each `resumes` is one `stage=command` entry, kept in declaration order; the
+            // runtime does not read the stage map yet.
+            "resumes" => {
+                let entry = super::positional_text(file, line, "resumes", &gated.args, 1)?;
+                pm.resumes.push(entry);
             }
             "transition" => {
                 for handler in parse_transition(file, lines, pos, line, &gated)? {

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

@@ -202,7 +202,8 @@ fn default_database_set(file: &str, line: usize, call: &lex::Call) -> ParseResul
     Ok(true)
 }
 
-/// One binding call: `verb("Adapter") do ... end`, or `verb "Adapter", k: v, ...` with no block.
+/// One binding call: `verb("Adapter") do ... end`, or `verb "Adapter", k: v, ...` with no block;
+/// the adapter may be left out when keyword settings are given.
 /// Records the verb, the first positional string, the keyword names, then the body's top-level
 /// keys. A verb that is a grammar word elsewhere is refused, as Ruby's word gate refuses it.
 fn parse_binding(
@@ -256,13 +257,6 @@ fn parse_binding(
             ));
         }
     }
-    let adapter = adapter.ok_or_else(|| {
-        Diagnostic::new(
-            file,
-            number,
-            format!("'{}' needs a quoted adapter name", call.word),
-        )
-    })?;
     match call.opener {
         Opener::None => {}
         Opener::DoBlock { .. } => body_keys(file, lines, pos, &mut settings)?,
@@ -274,6 +268,16 @@ fn parse_binding(
             ))
         }
     }
+    // A verb that names no adapter but gives settings (`stored_as Revision: "commit"`,
+    // `minting commands: [...]`) binds under the empty adapter, as Ruby's world builder does.
+    let adapter = adapter.or_else(|| (!settings.is_empty()).then(String::new));
+    let adapter = adapter.ok_or_else(|| {
+        Diagnostic::new(
+            file,
+            number,
+            format!("'{}' needs a quoted adapter name", call.word),
+        )
+    })?;
     Ok(ir::Binding {
         verb: call.word.clone(),
         adapter,

data/rust/parser/src/render_ruby.rs

@@ -100,6 +100,7 @@ fn refuse_unspelt(declaration: &ir::Bluebook) -> Result<(), String> {
         (!declaration.process_managers.is_empty(), "process managers"),
         (!declaration.provides.is_empty(), "provided capabilities"),
         (!declaration.attaches_to.is_empty(), "attaches"),
+        (!declaration.modules.is_empty(), "modules"),
         (declaration.version.is_some(), "a version"),
     ];
     match held.iter().find(|(present, _)| *present) {
@@ -297,6 +298,14 @@ fn command_text(out: &mut String, command: &ir::Command) -> Result<(), String> {
     } else if let Some(role) = &command.role {
         out.push_str(&format!("      role {}\n", string(role)));
     }
+    if !command.audience.is_empty() {
+        let names: Vec<String> = command
+            .audience
+            .iter()
+            .map(|name| format!(":{name}"))
+            .collect();
+        out.push_str(&format!("      audience {}\n", names.join(", ")));
+    }
     if let Some(goal) = &command.goal {
         out.push_str(&format!("      goal {}\n", string(goal)));
     }

data/rust/parser/src/sentence/format.rs

@@ -48,6 +48,9 @@ pub fn sentences(declaration: &ir::Bluebook) -> Result<String, String> {
         out.push_str(&format!("  It attaches to {}\n", join_and(&contexts)));
     }
     provides_text(&mut out, &declaration.provides)?;
+    if !declaration.modules.is_empty() {
+        return Err("the sentence form cannot say modules".to_string());
+    }
     for aggregate in &declaration.aggregates {
         out.push('\n');
         aggregate_text(&mut out, aggregate)?;

data/rust/parser/src/sentence/process.rs

@@ -34,7 +34,11 @@ impl Parser<'_> {
             match m.id {
                 "process_matched" => pm.correlates_by = m.text_of("path"),
                 "process_starts" => pm.starts_on = Some(m.text_of("event")),
-                "process_ends" => pm.ends_on = Some(m.text_of("event")),
+                "process_ends" => {
+                    let event = m.text_of("event");
+                    pm.ends_on.get_or_insert_with(|| event.clone());
+                    pm.endings.push(event);
+                }
                 "process_when" | "process_when_refused" => {
                     let handler = self.handler(&m)?;
                     if let Some(earlier) = pm.handlers.iter().find(|h| {
@@ -140,7 +144,7 @@ pub(super) fn said(pm: &ir::ProcessManager) -> Result<String, String> {
     if let Some(event) = &pm.starts_on {
         out.push_str(&format!("  It starts when {event} is announced\n"));
     }
-    if let Some(event) = &pm.ends_on {
+    for event in &pm.endings {
         out.push_str(&format!("  It ends when {event} is announced\n"));
     }
     for handler in &pm.handlers {

data/rust/src/exemplar/json.rs

@@ -268,6 +268,23 @@ impl TmplExtractIdType {
 }
 // TMPL:extract_id END
 
+// An entity element is addressed by its declared identity alone: unlike a root aggregate it has
+// no `id` or reference-key fallback, so an argument offering only those names no element.
+struct TmplExtractExactType;
+// TMPL:extract_id_exact BEGIN
+impl TmplExtractExactType {
+    pub fn tmpl_extract_id_name(v: &crate::kernel::Json) -> Result<String, crate::kernel::Refusal> {
+        (|| -> Option<String> {
+            // TMPL:extract_id_exact:TIER1_LINE BEGIN
+            let c0 = v.dig("tmpl_path")?.tmpl_id_coercion().ok()?;
+            // TMPL:extract_id_exact:TIER1_LINE END
+            Some(tmpl_tier1_join_placeholder())
+        })()
+        .ok_or_else(|| crate::kernel::Refusal::TypeMismatch("tmpl_error_text".to_string()))
+    }
+}
+// TMPL:extract_id_exact END
+
 fn tmpl_tier1_join_placeholder() -> String {
     String::new()
 }

data/rust/src/kernel/cli.rs

@@ -243,6 +243,7 @@ pub fn run(input: &str) -> String {
                 &command_input,
                 caller_role,
                 caller_actor_id,
+                step.get("occurred_at").and_then(Json::as_str),
             ));
             mutations_per_step.push(Vec::new());
             cross_domain_per_step.push(Vec::new());
@@ -260,6 +261,7 @@ pub fn run(input: &str) -> String {
                 &command_input,
                 caller_role,
                 caller_actor_id,
+                step.get("occurred_at").and_then(Json::as_str),
             ));
             mutations_per_step.push(Vec::new());
             cross_domain_per_step.push(Vec::new());
@@ -392,8 +394,16 @@ fn dry_run(
     command_input: &Json,
     caller_role: Option<&str>,
     caller_actor_id: Option<&str>,
+    occurred_at: Option<&str>,
 ) -> Json {
-    let (outcome, collected) = preview(store, verb, command_input, caller_role, caller_actor_id);
+    let (outcome, collected) = preview(
+        store,
+        verb,
+        command_input,
+        caller_role,
+        caller_actor_id,
+        occurred_at,
+    );
     match outcome {
         Ok(()) => Json::obj(vec![
             ("verb", Json::str(verb.to_string())),
@@ -411,8 +421,16 @@ fn validation(
     command_input: &Json,
     caller_role: Option<&str>,
     caller_actor_id: Option<&str>,
+    occurred_at: Option<&str>,
 ) -> Json {
-    let (outcome, collected) = preview(store, verb, command_input, caller_role, caller_actor_id);
+    let (outcome, collected) = preview(
+        store,
+        verb,
+        command_input,
+        caller_role,
+        caller_actor_id,
+        occurred_at,
+    );
     let refusals: Vec<Json> = match outcome {
         Ok(()) => Vec::new(),
         Err(refusal) if collected.is_empty() => vec![refusal_entry(&refusal, &Detail::default())],
@@ -429,14 +447,19 @@ fn validation(
 }
 
 /// The command run against a throwaway copy of the store with a collector bound: what it raised,
-/// and every refusal its failing stage kept.
+/// and every refusal its failing stage kept. The facts the command `needs` are answered first, as
+/// `orchestrate` answers them for a real dispatch, so a dry run or a validation sees the same
+/// arguments the command would.
 fn preview(
     store: &Store,
     verb: &str,
     command_input: &Json,
     caller_role: Option<&str>,
     caller_actor_id: Option<&str>,
+    occurred_at: Option<&str>,
 ) -> (Result<(), Refusal>, Vec<Collected>) {
+    let enriched = super::needs::enrich(verb, command_input, occurred_at);
+    let command_input = enriched.as_ref().unwrap_or(command_input);
     let mut scratch = store.clone();
     let (outcome, collected) = collecting::collecting(|| {
         dispatch_by_name(
@@ -569,6 +592,7 @@ pub fn serve(input: impl std::io::BufRead, mut output: impl std::io::Write) {
                         &dry_run_command_input(args),
                         caller_role,
                         caller_actor_id,
+                        occurred_at,
                     )
                 } else if let Some(verb) = step.get("verb").and_then(Json::as_str) {
                     let mut events: Vec<Event> = Vec::new();

data/rust/src/kernel/dispatch.rs

@@ -160,8 +160,10 @@ pub fn dispatch<'a, T, R>(
     mutations: &mut Vec<MutationRecord>,
     // The synchronous half of `projects`, applied right before `repo.save`.
     seed_projections: Vec<(&'static str, Option<Value>)>,
-    // The write-side tenant boundary. The router computes it (it needs every aggregate's repo)
-    // but it is applied here, first in `Save`, before `seed_projections`.
+    // The settled-state checks: references a command set through a plain value object, then the
+    // write-side tenant boundary. The router computes it (it needs every aggregate's repo)
+    // but it is applied here, first in `Save`, before `seed_projections`, as Ruby's
+    // `resolve_state_references` runs at `save`.
     tenant_boundary_check: Result<(), Refusal>,
 ) -> Result<(T, Vec<Event>), Refusal>
 where

data/rust/src/kernel/json.rs

@@ -250,6 +250,39 @@ impl Json {
         }
     }
 
+    /// Refuses `TypeMismatch` when a bare scalar query argument is offered as a shape its declared
+    /// type cannot hold, worded as a command's numeric field is. Ruby's `Value::FieldChecks#mistyped?`
+    /// is the rule: an Integer must be a number, a Float a number, and a String (or boolean) must not
+    /// be a composite. A null is absent, so it passes. `owner` is the aggregate's bare name.
+    pub fn expect_scalar_shape(
+        &self,
+        owner: &str,
+        field: &str,
+        type_name: &str,
+    ) -> Result<(), Refusal> {
+        if matches!(self, Self::Null) || !self.mistyped_scalar(type_name) {
+            return Ok(());
+        }
+        Err(Refusal::TypeMismatch(
+            super::refusal_wording::TypeMismatchNumericFieldArgs {
+                r#type: owner,
+                field,
+                expected: type_name,
+                offered: &self.describe(),
+            }
+            .render_args(),
+        ))
+    }
+
+    fn mistyped_scalar(&self, type_name: &str) -> bool {
+        match type_name {
+            "Integer" => !matches!(self, Self::Num(n, _) if n.fract() == 0.0),
+            "Float" => !matches!(self, Self::Num(..)),
+            "String" => matches!(self, Self::Array(_) | Self::Object(_)),
+            _ => false,
+        }
+    }
+
     /// Refuses `TypeMismatch` when a multi-field value object is offered as a non-object.
     ///
     /// Runs at the `from_json` call site, since only the caller knows `name`.
@@ -919,3 +952,32 @@ impl Parser<'_> {
         Ok(Json::Num(value, raw))
     }
 }
+
+#[cfg(test)]
+mod scalar_shape_tests {
+    use super::*;
+
+    fn refused(value: &Json, type_name: &str) -> bool {
+        value
+            .expect_scalar_shape("Account", "reference", type_name)
+            .is_err()
+    }
+
+    #[test]
+    fn a_string_argument_refuses_a_composite_and_takes_a_scalar() {
+        assert!(refused(&Json::obj(vec![("cents", Json::int(0))]), "String"));
+        assert!(!refused(&Json::int(7), "String"));
+    }
+
+    #[test]
+    fn an_integer_argument_refuses_a_fraction_and_a_string() {
+        assert!(refused(&Json::Num(1.5, None), "Integer"));
+        assert!(refused(&Json::str("1"), "Integer"));
+        assert!(!refused(&Json::int(1), "Integer"));
+    }
+
+    #[test]
+    fn a_null_argument_is_absent_not_mistyped() {
+        assert!(!refused(&Json::Null, "String"));
+    }
+}

data/rust/src/kernel/orchestrate.rs

@@ -783,7 +783,7 @@ impl<S: AggregateScan> Cascade<'_, S> {
                 Json::obj(fields)
             };
 
-            if depth + 1 >= MAX_REACTION_DEPTH {
+            if depth >= MAX_REACTION_DEPTH {
                 self.reaction_log.push(record(vec![
                     ("delivered", Json::Bool(false)),
                     (
@@ -1055,7 +1055,7 @@ impl<S: AggregateScan> Cascade<'_, S> {
             Json::obj(fields)
         };
 
-        if depth + 1 >= MAX_REACTION_DEPTH {
+        if depth >= MAX_REACTION_DEPTH {
             self.saga_log.push(record(vec![
                 ("delivered", Json::Bool(false)),
                 (
@@ -1126,7 +1126,7 @@ impl<S: AggregateScan> Cascade<'_, S> {
             Json::obj(fields)
         };
 
-        if depth + 1 >= MAX_REACTION_DEPTH {
+        if depth >= MAX_REACTION_DEPTH {
             self.saga_log.push(record(vec![
                 ("delivered", Json::Bool(false)),
                 (
@@ -1306,6 +1306,31 @@ mod tests {
         None
     }
 
+    // The emitting record's id is offered once, and an empty id is never offered: offering on
+    // either condition alone duplicates the field or invents an empty one.
+    #[test]
+    fn offer_emitter_id_adds_the_id_once_and_never_an_empty_one() {
+        let event = |id: &str| Event {
+            name: "SomeEvent".to_string(),
+            aggregate: "Domain::Thing".to_string(),
+            id: id.to_string(),
+            payload: Json::Object(vec![]),
+            occurred_at: None,
+            correlation: None,
+        };
+        let mut fresh = vec![];
+        offer_emitter_id(&mut fresh, &event("thing-1"));
+        assert_eq!(fresh, vec![("id".to_string(), Json::str("thing-1"))]);
+
+        let mut held = vec![("id".to_string(), Json::str("given"))];
+        offer_emitter_id(&mut held, &event("thing-1"));
+        assert_eq!(held, vec![("id".to_string(), Json::str("given"))]);
+
+        let mut empty = vec![];
+        offer_emitter_id(&mut empty, &event(""));
+        assert!(empty.is_empty());
+    }
+
     // Tier 2 alone: tier 1 finds nothing and tier 3 is unconfigured, so only the stamp can
     // resolve it.
     #[test]

data/rust/src/kernel/orchestrate_guard_tests.rs

@@ -511,7 +511,7 @@ fn a_cross_domain_policy_honours_its_event_qualifier_and_where_clause() {
 
 #[test]
 fn a_reaction_below_the_depth_ceiling_is_delivered_and_one_at_it_is_logged_undelivered() {
-    for (depth, delivers) in [(0, true), (3, true), (4, false), (5, false)] {
+    for (depth, delivers) in [(0, true), (4, true), (5, false), (6, false)] {
         let mut w = world();
 
         w.react(&event("Placed", "D::Order", "o1", Json::obj(vec![])), depth);
@@ -529,19 +529,19 @@ fn a_reaction_below_the_depth_ceiling_is_delivered_and_one_at_it_is_logged_undel
 }
 
 #[test]
-fn a_policy_that_re_triggers_itself_stops_after_five_dispatches() {
+fn a_policy_that_re_triggers_itself_stops_after_five_reactions() {
     let mut w = world();
 
     w.orchestrate("D::Order.Ping", 0).unwrap();
 
-    assert_eq!(w.verbs(), ["D::Order.Ping"; 5]);
+    assert_eq!(w.verbs(), ["D::Order.Ping"; 6]);
     let delivered: Vec<bool> = w
         .reaction_log
         .iter()
         .map(|entry| reaction(entry).1)
         .collect();
-    // The innermost reaction is logged first: the ceiling, then the four that delivered.
-    assert_eq!(delivered, [false, true, true, true, true]);
+    // The innermost reaction is logged first: the ceiling, then the five that delivered.
+    assert_eq!(delivered, [false, true, true, true, true, true]);
     assert_eq!(reason(&w.reaction_log[0]), Some(DEPTH_REACHED));
 }
 
@@ -549,9 +549,9 @@ fn a_policy_that_re_triggers_itself_stops_after_five_dispatches() {
 fn a_fan_out_dispatches_once_per_row_with_the_row_id_under_the_declared_key_one_level_deeper() {
     let mut w = world();
 
-    w.react(&event("Fan", "D::Order", "o1", Json::obj(vec![])), 3);
+    w.react(&event("Fan", "D::Order", "o1", Json::obj(vec![])), 4);
 
-    // Each row dispatches `Ping` at depth 4, whose own `Pinger` reaction is stopped there.
+    // Each row dispatches `Ping` at depth 5, whose own `Pinger` reaction is stopped there.
     assert_eq!(w.verbs(), ["D::Order.Ping", "D::Order.Ping"]);
     assert_eq!(
         w.bus.calls[0].1,
@@ -586,7 +586,7 @@ fn a_fan_out_over_a_query_nothing_declares_logs_the_missing_query() {
 fn a_saga_leg_stopped_at_the_ceiling_logs_it_and_never_dispatches() {
     let mut w = world();
 
-    assert_eq!(w.deliver_saga(4), None);
+    assert_eq!(w.deliver_saga(5), None);
 
     assert!(w.bus.calls.is_empty());
     assert_eq!(reason(&w.saga_log[0]), Some(DEPTH_REACHED));
@@ -596,9 +596,9 @@ fn a_saga_leg_stopped_at_the_ceiling_logs_it_and_never_dispatches() {
 fn a_saga_leg_just_under_the_ceiling_dispatches_one_level_deeper() {
     let mut w = world();
 
-    assert_eq!(w.deliver_saga(3), Some(true));
+    assert_eq!(w.deliver_saga(4), Some(true));
 
-    // Dispatched at depth 4, so the `Ping` it emits meets the ceiling and is not re-triggered.
+    // Dispatched at depth 5, so the `Ping` it emits meets the ceiling and is not re-triggered.
     assert_eq!(w.verbs(), ["D::Order.Ping"]);
     assert_eq!(reason(&w.reaction_log[0]), Some(DEPTH_REACHED));
 }
@@ -607,7 +607,7 @@ fn a_saga_leg_just_under_the_ceiling_dispatches_one_level_deeper() {
 fn a_derived_compensation_stopped_at_the_ceiling_is_logged_failed_and_never_dispatches() {
     let mut w = world();
 
-    w.deliver_compensation(4);
+    w.deliver_compensation(5);
 
     assert!(w.bus.calls.is_empty());
     assert_eq!(reason(&w.saga_log[0]), Some(DEPTH_REACHED));
@@ -621,7 +621,7 @@ fn a_derived_compensation_stopped_at_the_ceiling_is_logged_failed_and_never_disp
 fn a_derived_compensation_just_under_the_ceiling_dispatches_one_level_deeper() {
     let mut w = world();
 
-    w.deliver_compensation(3);
+    w.deliver_compensation(4);
 
     assert_eq!(w.verbs(), ["D::Order.Ping"]);
     assert_eq!(reason(&w.reaction_log[0]), Some(DEPTH_REACHED));

data/rust/web/Cargo.toml

@@ -18,7 +18,7 @@ rust = { path = ".." }
 wasm-bindgen = "=0.2.126"
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }