hecks 3.0.3 → 3.0.4

data/rust/host/src/resend.rs

@@ -43,7 +43,7 @@ impl Delivery {
 
 /// How email leaves the host: really, through Resend, or logged and dropped.
 pub enum Mailer {
-    Live { http: reqwest::Client, api_key: String, from: String, base_url: String },
+    Live { http: reqwest::Client, api_key: String, from: String, reply_to: Option<String>, base_url: String },
     Mock,
 }
 
@@ -53,6 +53,7 @@ impl Mailer {
     pub fn from_env() -> Result<Option<Mailer>, String> {
         let var = |name: &str| std::env::var(name).unwrap_or_default();
         Self::configured(&var("RESEND_API_KEY"), &var("RESEND_FROM"), &var("RESEND_MOCK"))
+            .map(|mailer| mailer.map(|mailer| mailer.replying_to(&var("RESEND_REPLY_TO"))))
     }
 
     fn configured(api_key: &str, from: &str, mock: &str) -> Result<Option<Mailer>, String> {
@@ -69,7 +70,19 @@ impl Mailer {
     /// A mailer that posts to `base_url` (Resend's API, or a stand-in in tests).
     pub fn live(api_key: &str, from: &str, base_url: &str) -> Mailer {
         let http = reqwest::Client::builder().timeout(TIMEOUT).build().expect("a reqwest client with a timeout always builds");
-        Mailer::Live { http, api_key: api_key.to_string(), from: from.to_string(), base_url: base_url.to_string() }
+        Mailer::Live { http, api_key: api_key.to_string(), from: from.to_string(), reply_to: None, base_url: base_url.to_string() }
+    }
+
+    /// Sets where replies go (`Reply-To`), when the address people reply to is not the one the mail
+    /// is sent from. Blank leaves replies going to the From address. A mock mailer has no replies.
+    pub fn replying_to(self, reply_to: &str) -> Mailer {
+        match self {
+            Mailer::Live { http, api_key, from, base_url, .. } => {
+                let reply_to = (!reply_to.trim().is_empty()).then(|| reply_to.trim().to_string());
+                Mailer::Live { http, api_key, from, reply_to, base_url }
+            }
+            mock => mock,
+        }
     }
 
     #[cfg(test)]
@@ -80,7 +93,7 @@ impl Mailer {
     pub async fn deliver(&self, email: &Email<'_>) -> Delivery {
         match self {
             Mailer::Mock => mock_deliver(email),
-            Mailer::Live { http, api_key, from, base_url } => live_deliver(http, api_key, from, base_url, email).await,
+            Mailer::Live { http, api_key, from, reply_to, base_url } => live_deliver(http, api_key, from, reply_to.as_deref(), base_url, email).await,
         }
     }
 }
@@ -93,8 +106,11 @@ fn mock_deliver(email: &Email<'_>) -> Delivery {
     Delivery::sent(format!("re_{}", uuid::Uuid::new_v4().simple()))
 }
 
-fn payload(from: &str, email: &Email<'_>) -> Value {
+fn payload(from: &str, reply_to: Option<&str>, email: &Email<'_>) -> Value {
     let mut payload = json!({ "from": from, "to": [email.to], "subject": email.subject });
+    if let Some(reply_to) = reply_to {
+        payload["reply_to"] = json!(reply_to);
+    }
     let content_key = if email.body.trim_start().starts_with('<') { "html" } else { "text" };
     payload[content_key] = json!(email.body);
     if let Some(url) = email.unsubscribe_url {
@@ -113,8 +129,8 @@ fn retry_delay(response: &reqwest::Response) -> Duration {
     Duration::from_secs(secs.min(MAX_RETRY_SECS))
 }
 
-async fn live_deliver(http: &reqwest::Client, api_key: &str, from: &str, base_url: &str, email: &Email<'_>) -> Delivery {
-    let body = payload(from, email);
+async fn live_deliver(http: &reqwest::Client, api_key: &str, from: &str, reply_to: Option<&str>, base_url: &str, email: &Email<'_>) -> Delivery {
+    let body = payload(from, reply_to, email);
     for attempt in 1..=MAX_ATTEMPTS {
         let response = match http.post(format!("{base_url}/emails")).bearer_auth(api_key).json(&body).send().await {
             Ok(r) => r,
@@ -225,19 +241,45 @@ mod tests {
 
     #[test]
     fn an_html_body_goes_as_html_and_a_plain_one_as_text() {
-        assert!(payload("f", &email("a@b.com", "  <p>hi</p>")).get("html").is_some());
-        let plain = payload("f", &email("a@b.com", "just a link"));
+        assert!(payload("f", None, &email("a@b.com", "  <p>hi</p>")).get("html").is_some());
+        let plain = payload("f", None, &email("a@b.com", "just a link"));
         assert!(plain.get("text").is_some() && plain.get("html").is_none());
     }
 
     #[test]
     fn the_unsubscribe_url_rides_as_a_list_unsubscribe_header() {
-        let with = payload("f", &email("a@b.com", "x"));
+        let with = payload("f", None, &email("a@b.com", "x"));
         assert_eq!(with["headers"]["List-Unsubscribe"], "<https://example.com/newsletter-unsubscribed.html?email=a%40b.com>");
-        let without = payload("f", &Email { to: "a@b.com", subject: "s", body: "x", unsubscribe_url: None });
+        let without = payload("f", None, &Email { to: "a@b.com", subject: "s", body: "x", unsubscribe_url: None });
         assert!(without.get("headers").is_none());
     }
 
+    #[test]
+    fn a_reply_to_address_rides_in_the_payload_and_is_absent_without_one() {
+        let with = payload("f", Some("lifeadelics@gmail.com"), &email("a@b.com", "x"));
+        assert_eq!(with["reply_to"], "lifeadelics@gmail.com");
+        assert!(payload("f", None, &email("a@b.com", "x")).get("reply_to").is_none());
+    }
+
+    #[test]
+    fn replying_to_trims_the_address_and_a_blank_one_sets_none() {
+        let set = Mailer::live("re_x", "n@mail.example.com", "http://x").replying_to("  me@example.com ");
+        assert!(matches!(&set, Mailer::Live { reply_to: Some(r), .. } if r == "me@example.com"));
+        let blank = Mailer::live("re_x", "n@mail.example.com", "http://x").replying_to("   ");
+        assert!(matches!(&blank, Mailer::Live { reply_to: None, .. }));
+        assert!(Mailer::Mock.replying_to("me@example.com").is_mock(), "a mock mailer has no replies");
+    }
+
+    #[tokio::test]
+    async fn a_live_send_carries_the_reply_to_address_to_resend() {
+        let fake = FakeResend::start(vec![("200 OK", "", r#"{"id":"em_9"}"#)]);
+        let mailer = Mailer::live("re_x", "News <n@mail.example.com>", &fake.base).replying_to("lifeadelics@gmail.com");
+
+        mailer.deliver(&email("a@b.com", "x")).await;
+
+        assert!(fake.requests()[0].contains(r#""reply_to":"lifeadelics@gmail.com""#), "{}", fake.requests()[0]);
+    }
+
     #[test]
     fn the_mock_logs_instead_of_sending_and_bounces_the_test_address() {
         let sent = mock_deliver(&email("a@b.com", "x"));

data/rust/host/src/server.rs

@@ -53,25 +53,29 @@ pub async fn dispatch_body(
         .ok_or("event missing \"verb\"")?
         .to_string();
     let role = body.get("role").and_then(|v| v.as_str()).map(|s| s.to_string());
+    // Who the caller is, for Governance. Honored only where the internal protocol is: from this
+    // host's own peers (`trusts_internal_dispatch`), never from a public caller.
+    let actor_id = body.get("actor_id").and_then(|v| v.as_str()).map(|s| s.to_string());
+    let caller = dispatch::Caller { role: role.as_deref(), actor_id: actor_id.as_deref() };
 
     let outcome = if let Some(to) = body.get("to").cloned() {
         if body.get("args").is_some() {
             return Err("cannot combine to/with with legacy args".into());
         }
         let facts = body.get("with").cloned().unwrap_or_else(|| serde_json::json!({}));
-        dispatch::handle_routed(client, wasm_path, &verb, to, facts, role.as_deref(), config, invoker)
+        dispatch::handle_routed_as(client, wasm_path, &verb, to, facts, caller, config, invoker)
             .await
             .map_err(|e| format!("{e:#}"))?
     } else if let Some(facts) = body.get("with").cloned() {
         if body.get("args").is_some() {
             return Err("cannot combine \"with\" with legacy args".into());
         }
-        dispatch::handle_facts(client, wasm_path, &verb, facts, role.as_deref(), config, invoker)
+        dispatch::handle_facts_as(client, wasm_path, &verb, facts, caller, config, invoker)
             .await
             .map_err(|e| format!("{e:#}"))?
     } else {
         let args = body.get("args").cloned().unwrap_or_else(|| serde_json::json!({}));
-        dispatch::handle(client, wasm_path, &verb, args, role.as_deref(), config, invoker)
+        dispatch::handle_as(client, wasm_path, &verb, args, caller, config, invoker)
             .await
             .map_err(|e| format!("{e:#}"))?
     };

data/rust/parser/src/canonical.rs

@@ -1,5 +1,5 @@
 //! Source-body slicing and whitespace collapse, mirroring Ruby's `CanonicalForm`.
-//! Hand-mirrored from projection.json: a third rule there needs a matching rule here.
+//! Hand-mirrored from projection.json: a rule there (collapse_whitespace, replace, scale_call) needs a matching rule here.
 
 /// Slices the raw source between two byte offsets, before any normalisation.
 pub fn slice(source: &str, start: usize, end: usize) -> &str {
@@ -11,7 +11,87 @@ pub fn slice(source: &str, start: usize, end: usize) -> &str {
 pub fn apply(source: &str) -> String {
     let collapsed = map_outside_strings(source, collapse_whitespace);
     let replaced = map_outside_strings(&collapsed, |run| replace_word_boundary(run, ".length", ".size"));
-    replaced.trim().to_string()
+    let scaled = SCALE_CALLS.iter().fold(replaced, |text, (token, seconds)| {
+        map_outside_strings(&text, |run| scale_call(run, token, seconds))
+    });
+    scaled.trim().to_string()
+}
+
+/// The `scale_call` rows of projection.json, in position order: (call name, seconds per unit).
+const SCALE_CALLS: [(&str, &str); 3] = [("days", "86400"), ("hours", "3600"), ("minutes", "60")];
+
+/// Every normalisation row of projection.json as (strategy, source_token, replacement,
+/// boundary, position), in position order; emitted into the IR's expression table.
+pub const TABLE: [(&str, &str, &str, &str, &str); 5] = [
+    ("collapse_whitespace", "", "", "none", "1"),
+    ("replace", ".length", ".size", "word", "2"),
+    ("scale_call", "days", "86400", "word", "3"),
+    ("scale_call", "hours", "3600", "word", "4"),
+    ("scale_call", "minutes", "60", "word", "5"),
+];
+
+/// Folds `token(<whole number>)` into the number times `seconds`, as Ruby's `scale_call` does.
+/// The name must not follow a word character, digit, underscore or dot; spaces inside the
+/// parentheses are allowed; any other argument leaves the call as written.
+fn scale_call(text: &str, token: &str, seconds: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut i = 0;
+    while i < text.len() {
+        if text[i..].starts_with(token) {
+            let preceded = text[..i]
+                .chars()
+                .next_back()
+                .map_or(false, |c| c.is_alphanumeric() || c == '_' || c == '.');
+            if !preceded {
+                if let Some((digits, len)) = whole_number_call(&text[i + token.len()..]) {
+                    out.push_str(&multiply(digits, seconds));
+                    i += token.len() + len;
+                    continue;
+                }
+            }
+        }
+        let ch = text[i..].chars().next().unwrap();
+        out.push(ch);
+        i += ch.len_utf8();
+    }
+    out
+}
+
+/// Matches `(` spaces digits spaces `)` at the start of `rest`; returns the digits and the
+/// matched length.
+fn whole_number_call(rest: &str) -> Option<(&str, usize)> {
+    let inner = rest.strip_prefix('(')?;
+    let digits_at = inner.len() - inner.trim_start_matches(char::is_whitespace).len();
+    let body = &inner[digits_at..];
+    let digit_len = body.bytes().take_while(|b| b.is_ascii_digit()).count();
+    if digit_len == 0 {
+        return None;
+    }
+    let tail = &body[digit_len..];
+    let close = tail.len() - tail.trim_start_matches(char::is_whitespace).len();
+    tail[close..].strip_prefix(')')?;
+    Some((&body[..digit_len], 1 + digits_at + digit_len + close + 1))
+}
+
+/// Decimal `digits` times the decimal `factor`, as text with no leading zeros (any length).
+fn multiply(digits: &str, factor: &str) -> String {
+    let factor: u32 = factor.parse().expect("scale factor is a whole number");
+    let mut carry = 0u32;
+    let mut out: Vec<u8> = Vec::with_capacity(digits.len() + 6);
+    for d in digits.bytes().rev() {
+        let v = (d - b'0') as u32 * factor + carry;
+        out.push(b'0' + (v % 10) as u8);
+        carry = v / 10;
+    }
+    while carry > 0 {
+        out.push(b'0' + (carry % 10) as u8);
+        carry /= 10;
+    }
+    while out.len() > 1 && out.last() == Some(&b'0') {
+        out.pop();
+    }
+    out.reverse();
+    String::from_utf8(out).unwrap()
 }
 
 /// Applies `transform` to the unquoted runs of `text` and copies quoted runs verbatim;
@@ -104,6 +184,61 @@ mod tests {
         assert_eq!(apply("lengthy"), "lengthy");
     }
 
+    #[test]
+    fn folds_duration_calls_into_seconds() {
+        assert_eq!(apply("days(730)"), "63072000");
+        assert_eq!(apply("days( 1 ) + hours(2) + minutes(15)"), "86400 + 7200 + 900");
+        assert_eq!(
+            apply("x.days(3) workdays(3) days(n) days(1.5)"),
+            "x.days(3) workdays(3) days(n) days(1.5)"
+        );
+        assert_eq!(apply("'days(2)' == days(0)"), "'days(2)' == 0");
+    }
+
+    /// Splits JSON text into its string literals, decoding escapes.
+    fn json_strings(text: &str) -> Vec<String> {
+        let mut out = Vec::new();
+        let mut chars = text.chars();
+        while let Some(c) = chars.next() {
+            if c != '"' {
+                continue;
+            }
+            let mut s = String::new();
+            while let Some(c) = chars.next() {
+                match c {
+                    '"' => break,
+                    '\\' => match chars.next().unwrap() {
+                        'n' => s.push('\n'),
+                        't' => s.push('\t'),
+                        'r' => s.push('\r'),
+                        'u' => {
+                            let hex: String = chars.by_ref().take(4).collect();
+                            s.push(char::from_u32(u32::from_str_radix(&hex, 16).unwrap()).unwrap());
+                        }
+                        other => s.push(other),
+                    },
+                    c => s.push(c),
+                }
+            }
+            out.push(s);
+        }
+        out
+    }
+
+    #[test]
+    fn matches_the_shared_canonical_form_cases() {
+        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../../spec/fixtures/canonical_form_cases.json");
+        let text = std::fs::read_to_string(path).expect("shared cases file");
+        let strings = json_strings(&text);
+        let start = strings.iter().position(|s| s == "cases").expect("cases key") + 1;
+        let rows: Vec<&[String]> = strings[start..].chunks(4).collect();
+        assert!(!rows.is_empty());
+        for row in rows {
+            assert_eq!((row[0].as_str(), row[2].as_str()), ("source", "canonical"));
+            assert_eq!(apply(&row[1]), row[3], "source {:?}", row[1]);
+        }
+    }
+
     #[test]
     fn slices_the_exact_source_span() {
         let source = "given(\"ok\") { balance >= amount }";

data/rust/parser/src/emit.rs

@@ -43,25 +43,20 @@ pub fn write(value: &JsonValue) -> String {
 /// The pinned `Expression::CanonicalForm.table` rules from projection.json, in Ruby's field
 /// order; `position` is a string.
 fn canonical_form_table() -> JsonValue {
-    JsonValue::Array(vec![
-        JsonValue::Object(vec![
-            (
-                "strategy".to_string(),
-                JsonValue::str("collapse_whitespace"),
-            ),
-            ("source_token".to_string(), JsonValue::str("")),
-            ("replacement".to_string(), JsonValue::str("")),
-            ("boundary".to_string(), JsonValue::str("none")),
-            ("position".to_string(), JsonValue::str("1")),
-        ]),
-        JsonValue::Object(vec![
-            ("strategy".to_string(), JsonValue::str("replace")),
-            ("source_token".to_string(), JsonValue::str(".length")),
-            ("replacement".to_string(), JsonValue::str(".size")),
-            ("boundary".to_string(), JsonValue::str("word")),
-            ("position".to_string(), JsonValue::str("2")),
-        ]),
-    ])
+    JsonValue::Array(
+        crate::canonical::TABLE
+            .iter()
+            .map(|(strategy, token, replacement, boundary, position)| {
+                JsonValue::Object(vec![
+                    ("strategy".to_string(), JsonValue::str(*strategy)),
+                    ("source_token".to_string(), JsonValue::str(*token)),
+                    ("replacement".to_string(), JsonValue::str(*replacement)),
+                    ("boundary".to_string(), JsonValue::str(*boundary)),
+                    ("position".to_string(), JsonValue::str(*position)),
+                ])
+            })
+            .collect(),
+    )
 }
 
 /// `IR::Bluebook#to_h`; field order is pinned there.
@@ -304,6 +299,17 @@ fn command_json(c: &ir::Command) -> JsonValue {
             "ensures".to_string(),
             JsonValue::Array(c.ensures.iter().map(given_json).collect()),
         ),
+        (
+            "needs".to_string(),
+            JsonValue::Array(
+                c.needs
+                    .iter()
+                    .map(|fact| {
+                        JsonValue::Object(vec![("fact".to_string(), JsonValue::str(fact.clone()))])
+                    })
+                    .collect(),
+            ),
+        ),
         (
             "mutations".to_string(),
             JsonValue::Array(c.mutations.iter().map(mutation_json).collect()),

data/rust/parser/src/ir.rs

@@ -98,6 +98,8 @@ pub struct Command {
     pub attributes: Vec<Attribute>,
     pub givens: Vec<Given>,
     pub ensures: Vec<Ensures>,
+    // Outside facts the runtime supplies before any given runs (`needs :now`); only `now` today.
+    pub needs: Vec<String>,
     pub mutations: Vec<Mutation>,
     pub emits: Vec<String>,
     // The lifecycle state this command is admissible from; see `CommandFrom`.

data/rust/parser/src/keywords.rs

@@ -107,6 +107,7 @@ pub static KEYWORDS: &[KeywordRow] = &[
     KeywordRow { word: "state", context: "Command", body: "none", inner: "", opens: "", fills: "mutations", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "attribute", context: "Command", body: "none", inner: "", opens: "", fills: "attributes", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "ensures", context: "Command", body: "source", inner: "", opens: "", fills: "ensures", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
+    KeywordRow { word: "needs", context: "Command", body: "none", inner: "", opens: "", fills: "needs", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "corrects", context: "Command", body: "none", inner: "", opens: "", fills: "mutations", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "description", context: "Entity", body: "none", inner: "", opens: "", fills: "description", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
     KeywordRow { word: "identified_by", context: "Entity", body: "keywords", inner: "ValueObject", opens: "ValueObject", fills: "identified_by", status: "admitted", was: "", resolves_via: "", disambiguator: "" },
@@ -308,6 +309,7 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
     ArgumentRow { keyword: "reference_to", context: "Command", at: "", named: "optional", kind: "flag", required: "false", fills: "optional", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "given", context: "Command", at: "1", named: "", kind: "text", required: "true", fills: "description", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "ensures", context: "Command", at: "1", named: "", kind: "text", required: "true", fills: "description", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
+    ArgumentRow { keyword: "needs", context: "Command", at: "1", named: "", kind: "symbol", required: "true", fills: "fact", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "sets", context: "Command", at: "1", named: "", kind: "symbol", required: "true", fills: "target", selects: "", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "sets", context: "Command", at: "", named: "to", kind: "literal", required: "false", fills: "source", selects: "op=set", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },
     ArgumentRow { keyword: "sets", context: "Command", at: "", named: "append", kind: "literal", required: "false", fills: "source", selects: "op=append", pair_key_fills: "", pair_value_fills: "", pairs_shape: "", status: "admitted", variadic: "", minimum: "" },

data/rust/parser/src/main.rs

@@ -179,6 +179,7 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("reference_to", "Command"),
     ("given", "Command"),
     ("ensures", "Command"),
+    ("needs", "Command"),
     ("sets", "Command"),
     ("corrects", "Command"),
     ("delegates_to", "Command"),

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

@@ -164,6 +164,7 @@ pub fn parse_body(
                 owner_entities,
             );
             refuse_duplicate_targets(file, *pos, &command)?;
+            refuse_undeclared_needs(file, *pos, &command)?;
             return Ok((command, pending));
         };
         let line = gated.line.number;
@@ -205,6 +206,27 @@ pub fn parse_body(
                     canonical: canonical::apply(&raw),
                 });
             }
+            "needs" => {
+                let fact = super::positional_symbol(file, line, "needs", &gated.args, 1)?;
+                if !NEEDABLE_FACTS.contains(&fact.as_str()) {
+                    return Err(Diagnostic::new(
+                        file,
+                        line,
+                        format!(
+                            "{} needs :{fact}, which the runtime cannot supply — it supplies :now",
+                            command.name
+                        ),
+                    ));
+                }
+                if command.needs.contains(&fact) {
+                    return Err(Diagnostic::new(
+                        file,
+                        line,
+                        format!("{} declares needs :{fact} twice", command.name),
+                    ));
+                }
+                command.needs.push(fact);
+            }
             "provenance" => {
                 let raw = super::named_raw(&gated.args, "from")
                     .ok_or_else(|| Diagnostic::new(file, line, "'provenance' requires a from:"))?;
@@ -297,6 +319,28 @@ fn state_ref(raw: &str) -> Option<String> {
     Some(inner.to_string())
 }
 
+/// The outside facts a command may declare it needs; mirrors `CommandBuilder::NEEDABLE_FACTS`.
+const NEEDABLE_FACTS: &[&str] = &["now"];
+
+/// A need names the attribute the runtime fills, so the command must declare it.
+fn refuse_undeclared_needs(file: &str, line: usize, command: &ir::Command) -> ParseResult<()> {
+    match command
+        .needs
+        .iter()
+        .find(|fact| !command.attributes.iter().any(|a| &a.name == *fact))
+    {
+        Some(fact) => Err(Diagnostic::new(
+            file,
+            line,
+            format!(
+                "{} needs :{fact} but declares no attribute :{fact} for the runtime to fill — add `attribute :{fact}, <type>`",
+                command.name
+            ),
+        )),
+        None => Ok(()),
+    }
+}
+
 /// Refuses a field written twice: a command's effects are one update set (C4.2).
 /// `delegates_to`/`corrects` name no field and are not counted.
 fn refuse_duplicate_targets(file: &str, line: usize, command: &ir::Command) -> ParseResult<()> {

data/rust/project/naming.rb

@@ -100,12 +100,14 @@ module RustProjection
 
     # Every declared `name` in the IR, in document order. The `fields` maps under
     # `mutations` are skipped: their keys are attribute names and their values
-    # are source text, not declarations.
+    # are source text, not declarations. So is `translations`: an era edge names
+    # data paths (`attendee.first_name`, a backfill into a nested value object)
+    # that the host applies to stored rows and never writes into Rust.
     def declared_names(node, out = [])
       case node
       when Hash
         node.each do |key, value|
-          if key.to_s == "fields"
+          if %w[fields translations].include?(key.to_s)
             next
           elsif key.to_s == "name" && value.is_a?(String)
             out << value

data/rust/src/kernel/cli.rs

@@ -16,6 +16,9 @@ pub fn run(input: &str) -> String {
         Err(e) => return error_output(&format!("invalid JSON on stdin: {e}")),
     };
 
+    // Optional `"needs"`: which commands need which outside facts (ADR 0081), passed by the host.
+    super::needs::install(parsed.get("needs"));
+
     let steps = match parsed.get("steps").and_then(Json::as_array) {
         Some(s) => s,
         None => return error_output("expected a top-level {\"steps\": [...]} object"),

data/rust/src/kernel/mod.rs

@@ -7,6 +7,7 @@ pub mod expr;
 pub mod expression_operators;
 pub mod json;
 pub mod named_query;
+pub mod needs;
 pub mod orchestrate;
 pub mod pattern;
 pub mod query_ordering;