hecks 3.9.1 → 3.11.0

data/rust/parser/src/expr/resolver.rs

@@ -1,7 +1,7 @@
 //! Parses value expressions into a `Resolver` tree (port of `resolver.rb#parse`).
 
 use super::evaluator::Evaluator;
-use super::{find_operator, top_level_index, Operator};
+use super::{find_operator, Operator};
 
 /// Which of `all?`, `any?` or `none?` a block predicate uses.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -39,6 +39,10 @@ pub enum Resolver {
     BoolLiteral(bool),
     NilLiteral,
     Addition(Box<Resolver>, Box<Resolver>),
+    Subtraction(Box<Resolver>, Box<Resolver>),
+    Multiplication(Box<Resolver>, Box<Resolver>),
+    /// Integer operands floor toward negative infinity; a zero divisor is an evaluation fault.
+    Division(Box<Resolver>, Box<Resolver>),
     SignTest { operator: Operator, receiver: Box<Resolver> },
     Empty(Box<Resolver>),
     ToS(Box<Resolver>),
@@ -57,6 +61,8 @@ pub enum Resolver {
     Assignment { receiver: Box<Resolver>, negated: bool },
     /// `receiver.split("sep")`: the separator is sliced verbatim between the quotes.
     Split { receiver: Box<Resolver>, separator: String },
+    /// `receiver.strip` / `.lstrip` / `.rstrip`; `side` is `both`, `left` or `right`.
+    Strip { receiver: Box<Resolver>, side: &'static str },
     /// `receiver.first`.
     First(Box<Resolver>),
     /// `receiver.last`.
@@ -100,8 +106,16 @@ pub fn parse(expr: &str) -> Resolver {
         return Resolver::ArrayLiteral(elements.iter().map(|element| parse(element)).collect());
     }
 
-    if let Some((left, right)) = split_addition(expr) {
-        return Resolver::Addition(Box::new(parse(left)), Box::new(parse(right)));
+    if let Some((operator, left, right)) = split_last_binary(expr, b"+-") {
+        let (left, right) = (Box::new(parse(left)), Box::new(parse(right)));
+        return if operator == b'+' { Resolver::Addition(left, right) } else { Resolver::Subtraction(left, right) };
+    }
+    if let Some((operator, left, right)) = split_last_binary(expr, b"*/") {
+        let (left, right) = (Box::new(parse(left)), Box::new(parse(right)));
+        return if operator == b'*' { Resolver::Multiplication(left, right) } else { Resolver::Division(left, right) };
+    }
+    if grouped(expr) {
+        return parse(&expr[1..expr.len() - 1]);
     }
 
     if let Some((receiver, test)) = match_suffix(expr, &SIGN_TESTS.map(|(s, _)| s)) {
@@ -139,6 +153,12 @@ pub fn parse(expr: &str) -> Resolver {
         }
     }
 
+    for (suffix, side) in [("strip", "both"), ("lstrip", "left"), ("rstrip", "right")] {
+        if let Some(inner) = strip_suffix_dotted(expr, suffix) {
+            return Resolver::Strip { receiver: Box::new(parse(inner)), side };
+        }
+    }
+
     if let Some((receiver, separator)) = match_string_call(expr, "split") {
         return Resolver::Split { receiver: Box::new(parse(receiver)), separator: separator.to_string() };
     }
@@ -351,9 +371,118 @@ fn array_elements(expr: &str) -> Option<Vec<String>> {
     Some(elements.into_iter().filter(|element| !element.is_empty()).collect())
 }
 
-fn split_addition(expr: &str) -> Option<(&str, &str)> {
-    let index = top_level_index(expr, "+", |_| true)?;
-    Some((expr[..index].trim(), expr[index + 1..].trim()))
+/// The canonical text of an arithmetic expression over names and numbers, as the Ruby DSL prints
+/// it: one space around each operator, parentheses only where the grouping needs them. `None` when
+/// `expr` is not arithmetic, or holds anything but names and numbers.
+pub fn arithmetic_text(expr: &str) -> Option<String> {
+    let node = parse(expr);
+    match node {
+        Resolver::Addition(..) | Resolver::Subtraction(..) | Resolver::Multiplication(..) | Resolver::Division(..) => render_arithmetic(&node),
+        _ => None,
+    }
+}
+
+fn render_arithmetic(node: &Resolver) -> Option<String> {
+    match node {
+        Resolver::Addition(l, r) => render_binary(l, '+', r),
+        Resolver::Subtraction(l, r) => render_binary(l, '-', r),
+        Resolver::Multiplication(l, r) => render_binary(l, '*', r),
+        Resolver::Division(l, r) => render_binary(l, '/', r),
+        Resolver::Lookup(path) => Some(path.clone()),
+        Resolver::IntegerLiteral(n) => Some(n.to_string()),
+        Resolver::FloatLiteral(f) => Some(crate::ruby_value::format_ruby_float(*f)),
+        _ => None,
+    }
+}
+
+fn binding_strength(operator: char) -> u8 {
+    if matches!(operator, '*' | '/') { 2 } else { 1 }
+}
+
+fn node_strength(node: &Resolver) -> u8 {
+    match node {
+        Resolver::Addition(..) | Resolver::Subtraction(..) => 1,
+        Resolver::Multiplication(..) | Resolver::Division(..) => 2,
+        _ => 0,
+    }
+}
+
+// A joined side is parenthesised when it binds looser than the operator, or equally on the right,
+// so the printed text parses back to the same grouping.
+fn render_binary(left: &Resolver, operator: char, right: &Resolver) -> Option<String> {
+    let strength = binding_strength(operator);
+    let side = |node: &Resolver, on_right: bool| -> Option<String> {
+        let text = render_arithmetic(node)?;
+        let held = node_strength(node);
+        Some(if held != 0 && (held < strength || (on_right && held == strength)) { format!("({text})") } else { text })
+    };
+    Some(format!("{} {operator} {}", side(left, false)?, side(right, true)?))
+}
+
+/// The operator and the texts either side of the LAST top-level binary operator in `operators`, so
+/// a chain splits left-associatively. A `-` is binary only after an operand (`a - b`, not `a - -b`
+/// or a leading `-5`). Brackets of every kind count toward depth, quotes hide their contents.
+fn split_last_binary<'a>(expr: &'a str, operators: &[u8]) -> Option<(u8, &'a str, &'a str)> {
+    let bytes = expr.as_bytes();
+    let mut depth: i32 = 0;
+    let mut quote: Option<u8> = None;
+    let mut found: Option<usize> = None;
+
+    for (index, &byte) in bytes.iter().enumerate() {
+        if let Some(open) = quote {
+            if byte == open {
+                quote = None;
+            }
+            continue;
+        }
+        match byte {
+            b'"' | b'\'' => quote = Some(byte),
+            b'(' | b'{' | b'[' => depth += 1,
+            b')' | b'}' | b']' => depth -= 1,
+            _ if depth == 0 && operators.contains(&byte) && binary_position(bytes, index) => found = Some(index),
+            _ => {}
+        }
+    }
+    found.map(|index| (bytes[index], expr[..index].trim(), expr[index + 1..].trim()))
+}
+
+// Only `-` can also be a sign, so it needs an operand ending on its left.
+fn binary_position(bytes: &[u8], index: usize) -> bool {
+    if bytes[index] != b'-' {
+        return true;
+    }
+    let before = bytes[..index].iter().rev().find(|b| !b.is_ascii_whitespace());
+    matches!(before, Some(b) if b.is_ascii_alphanumeric() || matches!(b, b'_' | b')' | b']' | b'"' | b'\''))
+}
+
+/// Whether `expr` is one parenthesised group: its first `(` closes at its last character.
+fn grouped(expr: &str) -> bool {
+    let bytes = expr.as_bytes();
+    if bytes.first() != Some(&b'(') || bytes.last() != Some(&b')') {
+        return false;
+    }
+    let mut depth: i32 = 0;
+    let mut quote: Option<u8> = None;
+    for (index, &byte) in bytes.iter().enumerate() {
+        if let Some(open) = quote {
+            if byte == open {
+                quote = None;
+            }
+            continue;
+        }
+        match byte {
+            b'"' | b'\'' => quote = Some(byte),
+            b'(' => depth += 1,
+            b')' => {
+                depth -= 1;
+                if depth == 0 {
+                    return index == bytes.len() - 1;
+                }
+            }
+            _ => {}
+        }
+    }
+    false
 }
 
 fn match_suffix<'a>(expr: &'a str, suffixes: &[&'a str]) -> Option<(&'a str, &'a str)> {
@@ -485,6 +614,9 @@ mod tests {
             ("a.set?", format!(r#"{{"op":"assignment","receiver":{a},"negated":false}}"#)),
             ("a.unset?", format!(r#"{{"op":"assignment","receiver":{a},"negated":true}}"#)),
             ("a.split(\"/\")", format!(r#"{{"op":"split","receiver":{a},"separator":"/"}}"#)),
+            ("a.strip", format!(r#"{{"op":"strip","receiver":{a},"side":"both"}}"#)),
+            ("a.lstrip", format!(r#"{{"op":"strip","receiver":{a},"side":"left"}}"#)),
+            ("a.rstrip", format!(r#"{{"op":"strip","receiver":{a},"side":"right"}}"#)),
             ("a.first", format!(r#"{{"op":"first","receiver":{a}}}"#)),
             ("a.last", format!(r#"{{"op":"last","receiver":{a}}}"#)),
             ("a.start_with?(\"x\")", format!(r#"{{"op":"starts_with","receiver":{a},"substring":"x"}}"#)),
@@ -494,4 +626,37 @@ mod tests {
             assert_eq!(compact(text), expected, "{text}");
         }
     }
+
+    #[test]
+    fn splits_arithmetic_by_level_and_left_to_right() {
+        assert!(matches!(parse("a + b * c"), Resolver::Addition(..)));
+        assert!(matches!(parse("a - b - c"), Resolver::Subtraction(left, _) if matches!(*left, Resolver::Subtraction(..))));
+        assert!(matches!(parse("a * b / c"), Resolver::Division(left, _) if matches!(*left, Resolver::Multiplication(..))));
+    }
+
+    #[test]
+    fn a_minus_is_binary_only_after_an_operand() {
+        assert!(matches!(parse("a - -5"), Resolver::Subtraction(_, right) if matches!(*right, Resolver::IntegerLiteral(-5))));
+        assert!(matches!(parse("-5"), Resolver::IntegerLiteral(-5)));
+    }
+
+    #[test]
+    fn a_parenthesised_group_reads_as_what_it_wraps() {
+        assert!(matches!(parse("(a + b) * c"), Resolver::Multiplication(left, _) if matches!(*left, Resolver::Addition(..))));
+    }
+
+    #[test]
+    fn prints_arithmetic_with_parentheses_only_where_the_grouping_needs_them() {
+        assert_eq!(arithmetic_text("a*b/100").as_deref(), Some("a * b / 100"));
+        assert_eq!(arithmetic_text("(a+b)*2").as_deref(), Some("(a + b) * 2"));
+        assert_eq!(arithmetic_text("a-(b-c)").as_deref(), Some("a - (b - c)"));
+        assert_eq!(arithmetic_text("(a*b)+c").as_deref(), Some("a * b + c"));
+    }
+
+    #[test]
+    fn text_that_is_not_arithmetic_over_names_and_numbers_prints_nothing() {
+        assert_eq!(arithmetic_text("paid"), None);
+        assert_eq!(arithmetic_text("a.size + 1"), None);
+        assert_eq!(arithmetic_text("\"x\""), None);
+    }
 }

data/rust/parser/src/ir.rs

@@ -60,6 +60,8 @@ pub enum MutationSource {
     Literal(crate::ruby_value::Value),
     /// `state(:field)`: the record's own field, read from the pre-dispatch state.
     State(String),
+    /// Arithmetic over argument names, record fields and numbers: its canonical text.
+    Expression(String),
 }
 
 #[derive(Debug, Clone)]
@@ -120,6 +122,8 @@ pub struct Lifecycle {
     pub field: String,
     pub default: String,
     pub transitions: Vec<StateTransitionRow>,
+    // `mark :name, "state", ...`: each meaning and its states, in declared order.
+    pub marks: Vec<(String, Vec<String>)>,
 }
 
 #[derive(Debug, Clone, Default)]
@@ -285,6 +289,9 @@ pub struct Policy {
     pub name: String,
     pub on_event: Option<String>,
     pub trigger_command: Option<String>,
+    // `ask :name`: the need, in the domain's words. Emitted in place of `trigger_command`; the
+    // hecksagon's declared asks say which port operation answers.
+    pub ask: Option<String>,
     pub target_domain: Option<String>,
     // `across "X", expect_undelivered: true`; emitted as a boolean, `false` when not declared.
     pub expect_undelivered: bool,

data/rust/parser/src/keywords.rs

@@ -82,6 +82,7 @@ pub static KEYWORDS: &[KeywordRow] = &[
     KeywordRow { word: "given", context: "Aggregate", body: "source", inner: "", opens: "", fills: "preconditions", status: "admitted", was: "", resolves_via: "owner_keyed", disambiguator: "declared_by" },
     KeywordRow { word: "projects", context: "Aggregate", body: "none", inner: "", opens: "", fills: "projected_fields", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "transition", context: "Lifecycle", body: "none", inner: "", opens: "", fills: "transitions", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
+    KeywordRow { word: "mark", context: "Lifecycle", body: "none", inner: "", opens: "", fills: "marks", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "bluebook", context: "File", body: "keywords", inner: "Bluebook", opens: "Bluebook", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "vision", context: "Bluebook", body: "none", inner: "", opens: "", fills: "vision", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "formerly_known_as", context: "Bluebook", body: "none", inner: "", opens: "", fills: "formerly_known_as", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
@@ -125,6 +126,7 @@ pub static KEYWORDS: &[KeywordRow] = &[
     KeywordRow { word: "entity", context: "Entity", body: "keywords", inner: "Entity", opens: "Entity", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "on", context: "Policy", body: "none", inner: "", opens: "", fills: "on_event", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "trigger", context: "Policy", body: "none", inner: "", opens: "", fills: "trigger_command", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
+    KeywordRow { word: "ask", context: "Policy", body: "none", inner: "", opens: "", fills: "ask", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "across", context: "Policy", body: "none", inner: "", opens: "", fills: "target_domain", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "where", context: "Policy", body: "source", inner: "", opens: "", fills: "where", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "for_each", context: "Policy", body: "none", inner: "", opens: "", fills: "for_each", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
@@ -184,6 +186,7 @@ pub static KEYWORDS: &[KeywordRow] = &[
     KeywordRow { word: "hecksagon", context: "File", body: "keywords", inner: "Hecksagon", opens: "Hecksagon", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "subscribe", context: "Hecksagon", body: "none", inner: "", opens: "", fills: "subscriptions", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "attaches", context: "Hecksagon", body: "none", inner: "", opens: "", fills: "attachments", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
+    KeywordRow { word: "driven_by", context: "Hecksagon", body: "none", inner: "", opens: "", fills: "driving", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "port", context: "Hecksagon", body: "keywords", inner: "DomainPort", opens: "DomainPort", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "translates", context: "Hecksagon", body: "keywords", inner: "Policy", opens: "Policy", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "bounded", context: "Hecksagon", body: "none", inner: "", opens: "", fills: "", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
@@ -263,6 +266,8 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "transition", context: "Lifecycle", at: "1", named: "", kind: "pairs", required: "true", fills: "", selects: "", pair_key_fills: "command", pair_value_fills: "to_state", pairs_shape: "fields", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "transition", context: "Lifecycle", at: "", named: "from", kind: "text", required: "false", fills: "from_state", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "transition", context: "Lifecycle", at: "", named: "from", kind: "list", required: "false", fills: "from_state", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "mark", context: "Lifecycle", at: "1", named: "", kind: "symbol", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "mark", context: "Lifecycle", at: "2", named: "", kind: "text", required: "true", fills: "state", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "true", minimum: "" },
     ArgumentRow { keyword: "bluebook", context: "File", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "bluebook", context: "File", at: "", named: "version", kind: "text", required: "false", fills: "version", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "vision", context: "Bluebook", at: "1", named: "", kind: "text", required: "true", fills: "vision", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
@@ -282,13 +287,24 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "add_name", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "confirm", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "unsubscribe", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "awaiting_confirmation", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "receives_issues", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "left", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "confirm_window", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "unsubscribe_window", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "webhook_tolerance", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "session_hold", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "initiate", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "succeeded", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "failed", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "lapse_reason", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "holds_seat", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "send_issue", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "record_delivery", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "schedule", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "request", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "registered_at", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "frees_seat", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "connect", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "reconnect", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "disconnect", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
@@ -296,6 +312,10 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "resume", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "enable", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "disable", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "mark_sensitive", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "markings_for", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "key_for", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "provides", context: "Bluebook", at: "", named: "shred", kind: "text", required: "false", fills: "provides", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "aggregate", context: "Bluebook", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "read_model", context: "Bluebook", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "policy", context: "Bluebook", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
@@ -377,10 +397,12 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "on", context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "on_event", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "trigger", context: "Policy", at: "1", named: "", kind: "constant", required: "true", fills: "trigger_command", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "trigger", context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "trigger_command", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "ask", context: "Policy", at: "1", named: "", kind: "symbol", required: "true", fills: "ask", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "across", context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "target_domain", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "across", context: "Policy", at: "", named: "expect_undelivered", kind: "flag", required: "false", fills: "expect_undelivered", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "for_each", context: "Policy", at: "1", named: "", kind: "text", required: "true", fills: "for_each", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "trigger", context: "Policy", at: "", named: "with", kind: "pairs", required: "false", fills: "with_spec", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "verbatim", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "ask", context: "Policy", at: "", named: "with", kind: "pairs", required: "false", fills: "with_spec", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "verbatim", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "correlates_by", context: "ProcessManager", at: "1", named: "", kind: "symbol", required: "true", fills: "correlates_by", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "starts_on", context: "ProcessManager", at: "1", named: "", kind: "constant", required: "true", fills: "starts_on", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "starts_on", context: "ProcessManager", at: "1", named: "", kind: "text", required: "true", fills: "starts_on", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
@@ -468,6 +490,7 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "subscribe", context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "subscriptions", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "attaches", context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "attachments", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "attaches", context: "Hecksagon", at: "", named: "from", kind: "symbol", required: "false", fills: "source", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "driven_by", context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "driving", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "port", context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "translates", context: "Hecksagon", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "reference_to", context: "PortOperation", at: "1", named: "", kind: "constant", required: "true", fills: "type", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
@@ -489,6 +512,7 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "adapter", context: "File", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "port", context: "Adapter", at: "1", named: "", kind: "text", required: "true", fills: "port", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "field", context: "Adapter", at: "1", named: "", kind: "symbol", required: "true", fills: "fields", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "field", context: "Adapter", at: "", named: "default", kind: "literal", required: "false", fills: "default", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "secret", context: "Adapter", at: "1", named: "", kind: "symbol", required: "true", fills: "secrets", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "data_translation", context: "File", at: "1", named: "", kind: "text", required: "true", fills: "name", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "data_translation", context: "File", at: "", named: "from", kind: "text", required: "true", fills: "from", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },

data/rust/parser/src/main.rs

@@ -198,6 +198,7 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("invariant", "ValueObject"),
     ("member", "OneOf"),
     ("transition", "Lifecycle"),
+    ("mark", "Lifecycle"),
     ("description", "Query"),
     ("attribute", "Query"),
     ("where", "Query"),
@@ -208,6 +209,7 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("needs", "Query"),
     ("on", "Policy"),
     ("trigger", "Policy"),
+    ("ask", "Policy"),
     ("across", "Policy"),
     ("where", "Policy"),
     ("for_each", "Policy"),
@@ -220,6 +222,7 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("translates", "Hecksagon"),
     ("bounded", "Hecksagon"),
     ("attaches", "Hecksagon"),
+    ("driven_by", "Hecksagon"),
     ("operation", "DomainPort"),
     ("reference_to", "PortOperation"),
     ("attribute", "PortOperation"),

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

@@ -425,7 +425,7 @@ pub fn parse_body(
                         .chain(closed_sets.iter())
                         .cloned()
                         .collect();
-                    let vo = super::parse_nested_body(
+                    let (vo, nested_sets) = super::parse_nested_body(
                         file,
                         lines,
                         pos,
@@ -434,6 +434,7 @@ pub fn parse_body(
                         |f, l, p| value_object::parse_body(f, l, p, &vo_name, &owner_value_objects),
                     )?;
                     aggregate.value_objects.push(vo);
+                    aggregate.value_objects.extend(nested_sets);
                 }
             }
             "lifecycle" => {

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

@@ -297,7 +297,7 @@ pub fn parse_chapter(chapter_name: &str, files: &[(String, String)]) -> ParseRes
                     &mut discarded,
                     &mut Vec::new(),
                     &mut Vec::new(),
-                    true,
+                    false,
                 )?;
             }
         }
@@ -355,7 +355,7 @@ pub fn resolve_hecksagon_dependencies(
                 &mut discarded,
                 &mut Vec::new(),
                 &mut Vec::new(),
-                true,
+                false,
             )?;
         }
     }

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

@@ -544,8 +544,10 @@ fn build_mutation(
     }
     // `state(:field)` is the record's own field, neither argument nor literal; classified
     // before the Symbol/literal split.
+    let computed = if op == "set" { crate::expr::resolver::arithmetic_text(raw.trim()) } else { None };
     let source = match state_ref(raw.trim()) {
         Some(name) => ir::MutationSource::State(name),
+        None if computed.is_some() => ir::MutationSource::Expression(computed.unwrap_or_default()),
         None => match value {
             ruby_value::Value::Symbol(name) => ir::MutationSource::Argument(name),
             other => ir::MutationSource::Literal(other),

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

@@ -1,5 +1,6 @@
 //! The `Hecksagon` construct: a `.hecksagon` file's `port` blocks and `attaches` words.
-//! Adapter binds (`persisted_by`, `projected_by`, `subscribe`) are shape-matched and dropped.
+//! Adapter binds (`persisted_by`, `projected_by`, `subscribe`, `driven_by`) are shape-matched and
+//! dropped.
 
 use super::domain_port;
 use super::policy;
@@ -64,7 +65,7 @@ pub fn apply(
         if let LineShape::Call(call) = lex::classify(file, &line)? {
             if !matches!(
                 call.word.as_str(),
-                "port" | "subscribe" | "attaches" | "translates" | "bounded" | "end"
+                "port" | "subscribe" | "attaches" | "translates" | "bounded" | "driven_by" | "end"
             ) {
                 let instead = match call.word.as_str() {
                     "uses_framework" => Some("attaches \"Name\""),
@@ -130,6 +131,8 @@ pub fn apply(
                 }
                 // Consumer-owned bounded-context mark; a wiring fact, dropped like `subscribe`.
                 "bounded" => {}
+                // A driving adapter the domain admits; Ruby's boot enforces it, `ir.json` carries none.
+                "driven_by" => {}
                 _ => {
                     return Err(super::not_built_yet(
                         "Hecksagon",

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

@@ -22,11 +22,13 @@ pub fn parse_body(
         field: field.to_string(),
         default: default.to_string(),
         transitions: Vec::new(),
+        marks: Vec::new(),
     };
 
     loop {
         let Some(gated) = super::next_line(file, lines, pos, "Lifecycle")? else {
             refuse_ambiguity(file, *pos, &lifecycle)?;
+            refuse_unknown_mark_states(file, *pos, &lifecycle)?;
             return Ok(lifecycle);
         };
 
@@ -52,6 +54,47 @@ pub fn parse_body(
                     });
                 }
             }
+            "mark" => {
+                let line = gated.line.number;
+                let name = super::positional_symbol_raw(file, line, "mark", &gated.args, 1)?;
+                if !is_lowercase_word(&name) {
+                    return Err(Diagnostic::new(
+                        file,
+                        line,
+                        format!(
+                            "lifecycle :{field} mark {:?} is not a lowercase word (such as :holds_seat)",
+                            format!(":{name}")
+                        ),
+                    ));
+                }
+                if lifecycle.marks.iter().any(|(held, _)| *held == name) {
+                    return Err(Diagnostic::new(
+                        file,
+                        line,
+                        format!("lifecycle :{field} declares mark :{name} twice"),
+                    ));
+                }
+                let mut states: Vec<String> = Vec::new();
+                for (_, raw) in gated.args.positional.iter().filter(|(idx, _)| *idx > 1) {
+                    let state = text_value(raw);
+                    if states.contains(&state) {
+                        return Err(Diagnostic::new(
+                            file,
+                            line,
+                            format!("lifecycle :{field} mark :{name} names state {state:?} twice"),
+                        ));
+                    }
+                    states.push(state);
+                }
+                if states.is_empty() {
+                    return Err(Diagnostic::new(
+                        file,
+                        line,
+                        format!("lifecycle :{field} mark :{name} names no states"),
+                    ));
+                }
+                lifecycle.marks.push((name, states));
+            }
             _ => {
                 return Err(super::not_built_yet(
                     "Lifecycle",
@@ -65,6 +108,44 @@ pub fn parse_body(
     }
 }
 
+// A lowercase word: a letter a-z, then lowercase letters, digits and underscores.
+fn is_lowercase_word(name: &str) -> bool {
+    let mut chars = name.chars();
+    matches!(chars.next(), Some('a'..='z'))
+        && chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_')
+}
+
+// Refuses a mark naming a state that is neither the default nor a transition target. Wording
+// matches Ruby's.
+fn refuse_unknown_mark_states(file: &str, line: usize, lifecycle: &ir::Lifecycle) -> ParseResult<()> {
+    let mut known: Vec<&str> = vec![lifecycle.default.as_str()];
+    for row in &lifecycle.transitions {
+        if !known.contains(&row.to_state.as_str()) {
+            known.push(row.to_state.as_str());
+        }
+    }
+    for (name, states) in &lifecycle.marks {
+        let unknown: Vec<String> = states
+            .iter()
+            .filter(|s| !known.contains(&s.as_str()))
+            .map(|s| format!("{s:?}"))
+            .collect();
+        if !unknown.is_empty() {
+            return Err(Diagnostic::new(
+                file,
+                line,
+                format!(
+                    "lifecycle :{} mark :{name} names {}, which is not a state of the lifecycle (states: {})",
+                    lifecycle.field,
+                    unknown.join(", "),
+                    known.join(", ")
+                ),
+            ));
+        }
+    }
+    Ok(())
+}
+
 // Refuses one command reaching two targets from overlapping `from:` states (`None` overlaps all).
 // Rows are already expanded one per `from:` state. A `from:` naming an undeclared state is left
 // to `hecks model_check`, since a bluebook may exhibit it on purpose. Wording matches Ruby's.

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

@@ -1070,7 +1070,9 @@ pub(crate) fn parse_identified_by(
                     "'identified_by' cannot combine a value-object type with a block",
                 ));
             }
-            let value_object = parse_nested_body(file, lines, pos, opener, line, |f, l, p| {
+            // An identity block's own `one_of(...)` sets are not installed (its builder is not
+            // the aggregate's `value_object` verb).
+            let (value_object, _) = parse_nested_body(file, lines, pos, opener, line, |f, l, p| {
                 value_object::parse_body(f, l, p, inline_type_name, owner_value_objects)
             })?;
             if value_object.attributes.is_empty() {
@@ -1090,6 +1092,18 @@ pub(crate) fn parse_identified_by(
     }
 }
 
+/// The N'th positional as a symbol name (`:holds_seat` gives `holds_seat`).
+pub(crate) fn positional_symbol_raw(
+    file: &str,
+    line: usize,
+    word: &str,
+    args: &ArgumentGateResult,
+    at: usize,
+) -> ParseResult<String> {
+    let raw = positional_raw(file, line, word, args, at)?;
+    positional_symbol_text(file, line, word, raw)
+}
+
 /// Symbol name for one raw positional token, for variadic callers such as `identified_by`.
 fn positional_symbol_text(file: &str, line: usize, word: &str, raw: &str) -> ParseResult<String> {
     let trimmed = raw.trim();