hecks 3.1.0 → 3.1.2

data/rust/codegen/src/mutations.rs

@@ -392,6 +392,23 @@ pub struct Transition {
     pub field: String,
     pub to_state: String,
     pub from_states: Vec<String>,
+    /// A row with no `from:` admits every state, so no check is emitted for the command.
+    pub unconstrained: bool,
+}
+
+/// The `Option<TransitionCheck>` expression a dispatch function is generated with.
+///
+/// `None` covers both "no transition" and an unconstrained one; an empty `from_states` slice
+/// would refuse every state instead of admitting every state.
+pub fn transition_check_arg(transition: Option<&Transition>) -> String {
+    match transition {
+        Some(t) if !t.unconstrained => format!(
+            "Some(crate::kernel::TransitionCheck {{ field: {}, from_states: &[{}] }})",
+            naming::ruby_inspect_string(&t.field),
+            t.from_states.iter().map(|s| naming::ruby_inspect_string(s)).collect::<Vec<_>>().join(", ")
+        ),
+        _ => "None".to_string(),
+    }
 }
 
 /// Collapses a command's transition rows into the shape `TransitionCheck` wants.
@@ -417,19 +434,25 @@ pub fn lifecycle_transition_for(command: &Json, aggregate: &Json) -> Option<Tran
             }
         }
         let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("").to_string();
-        return Some(Transition { field, to_state: String::new(), from_states });
+        return Some(Transition { field, to_state: String::new(), from_states, unconstrained: false });
     }
 
     let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("").to_string();
     let to_state = rows[0].get("to_state").map(Json::to_s).unwrap_or_default();
     let mut from_states: Vec<String> = Vec::new();
+    let mut unconstrained = false;
     for row in &rows {
-        let from = row.get("from_state").map(Json::to_s).unwrap_or_default();
-        if !from_states.contains(&from) {
-            from_states.push(from);
+        match row.get_raw("from_state") {
+            None | Some(Json::Null) => unconstrained = true,
+            Some(from) => {
+                let from = from.to_s();
+                if !from_states.contains(&from) {
+                    from_states.push(from);
+                }
+            }
         }
     }
-    Some(Transition { field, to_state, from_states })
+    Some(Transition { field, to_state, from_states, unconstrained })
 }
 
 /// Right-hand side for a `set`, coercing the source into the target attribute's declared type.
@@ -782,3 +805,49 @@ fn emit_mutation_line_body(
         other => panic!("unsupported mutation op {other:?} — command_skip_reason should have caught this"),
     }
 }
+
+#[cfg(test)]
+mod transition_tests {
+    use super::*;
+
+    fn aggregate(rows: &str) -> Json {
+        Json::parse(&format!(
+            r#"{{"name":"Account","lifecycle":{{"field":"status","default":"draft","transitions":[{rows}]}}}}"#
+        ))
+        .unwrap()
+    }
+
+    fn command(name: &str) -> Json {
+        Json::parse(&format!(r#"{{"name":"{name}"}}"#)).unwrap()
+    }
+
+    #[test]
+    fn a_transition_without_from_admits_every_state() {
+        let account = aggregate(r#"{"command":"Open","to_state":"open","from_state":null}"#);
+        let transition = lifecycle_transition_for(&command("Open"), &account).unwrap();
+        assert!(transition.unconstrained);
+        assert_eq!(transition.to_state, "open");
+        assert_eq!(transition_check_arg(Some(&transition)), "None");
+    }
+
+    #[test]
+    fn a_transition_with_from_checks_that_state() {
+        let account = aggregate(r#"{"command":"Close","to_state":"closed","from_state":"open"}"#);
+        let transition = lifecycle_transition_for(&command("Close"), &account).unwrap();
+        assert!(!transition.unconstrained);
+        assert_eq!(
+            transition_check_arg(Some(&transition)),
+            r#"Some(crate::kernel::TransitionCheck { field: "status", from_states: &["open"] })"#
+        );
+    }
+
+    #[test]
+    fn one_unconstrained_row_among_constrained_ones_admits_every_state() {
+        let account = aggregate(
+            r#"{"command":"Reopen","to_state":"open","from_state":"closed"},
+               {"command":"Reopen","to_state":"open","from_state":null}"#,
+        );
+        let transition = lifecycle_transition_for(&command("Reopen"), &account).unwrap();
+        assert_eq!(transition_check_arg(Some(&transition)), "None");
+    }
+}

data/rust/codegen/src/naming.rs

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

data/rust/codegen/src/types.rs

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

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-3.1.0
+3.1.2

data/rust/host/src/web/registration_receipt/tests.rs

@@ -0,0 +1,39 @@
+use super::*;
+
+#[test]
+fn cents_render_as_dollars_with_two_places() {
+    assert_eq!(dollars(10800), "$108.00");
+    assert_eq!(dollars(14805), "$148.05");
+    assert_eq!(dollars(5), "$0.05");
+}
+
+#[test]
+fn the_built_in_receipt_names_the_event_the_first_name_and_the_amount() {
+    let body = built_in_body(Some("Ada"), "Yogadelics", Some(10800));
+    assert!(body.starts_with("Hi Ada,"));
+    assert!(body.contains("You're registered for Yogadelics."));
+    assert!(body.contains("$108.00"));
+    assert_eq!(receipt_subject("Yogadelics"), "You're registered for Yogadelics");
+}
+
+#[test]
+fn a_built_in_receipt_without_a_name_or_amount_still_reads_cleanly() {
+    let body = built_in_body(None, "Yogadelics", None);
+    assert!(body.starts_with("Hi,"));
+    assert!(!body.contains("payment of"));
+}
+
+#[test]
+fn the_sites_finished_email_is_read() {
+    let answer = serde_json::json!({"subject": "You're registered for Yogadelics", "body": "Hi Ada,\n\nWhere: Somewhere\n"});
+    assert_eq!(
+        site_email_from_json(&answer),
+        Some(SiteEmail { subject: "You're registered for Yogadelics".into(), body: "Hi Ada,\n\nWhere: Somewhere\n".into() })
+    );
+}
+
+#[test]
+fn an_incomplete_answer_from_the_site_falls_back_to_the_built_in_wording() {
+    assert_eq!(site_email_from_json(&serde_json::json!({"error": "no such session"})), None);
+    assert_eq!(site_email_from_json(&serde_json::json!({"subject": "Hi", "body": "  "})), None);
+}

data/rust/host/src/web/registration_receipt.rs

@@ -0,0 +1,122 @@
+// The email a registrant gets once their payment has gone through: what they
+// booked and what they paid. Best-effort, like every other mail the host
+// sends: the payment stands whatever delivery does.
+
+use super::instances_for;
+use crate::dispatch;
+use crate::ir::PaymentsProvider;
+use crate::journal::LineageConfig;
+use crate::resend::{Email, Mailer};
+use serde_json::{json, Value};
+use std::path::Path;
+use tokio::sync::Mutex;
+use tokio_postgres::Client;
+
+#[cfg(test)]
+mod tests;
+
+fn dollars(cents: i64) -> String {
+    format!("${}.{:02}", cents / 100, cents % 100)
+}
+
+fn receipt_subject(event_name: &str) -> String {
+    format!("You're registered for {event_name}")
+}
+
+/// The subject and body the site built from the wording an editor keeps in
+/// the CMS (when, where and how-to-prepare are filled in there: the venue lives
+/// only in the CMS).
+#[derive(Debug, PartialEq)]
+struct SiteEmail {
+    subject: String,
+    body: String,
+}
+
+fn site_email_from_json(body: &Value) -> Option<SiteEmail> {
+    let text = |key: &str| body.get(key).and_then(Value::as_str).filter(|s| !s.trim().is_empty()).map(String::from);
+    Some(SiteEmail { subject: text("subject")?, body: text("body")? })
+}
+
+/// Asks the site for the finished email (signed, short-lived, bound to this
+/// one event). Best effort: any failure means the host's own built-in wording
+/// goes out instead, so a receipt is always sent.
+async fn site_email(event_slug: &str, first_name: Option<&str>, amount_cents: Option<i64>) -> Option<SiteEmail> {
+    let secret = std::env::var("SESSION_SECRET").ok().filter(|s| !s.is_empty())?;
+    let token = crate::auth::purpose_token(&secret, "confirmation-email", json!({ "event": event_slug }), 300);
+    let mut url = reqwest::Url::parse(&format!("{}/api/confirmation-email", super::newsletter_send::site_url())).ok()?;
+    {
+        let mut query = url.query_pairs_mut();
+        query.append_pair("event", event_slug);
+        if let Some(name) = first_name {
+            query.append_pair("first_name", name);
+        }
+        if let Some(cents) = amount_cents {
+            query.append_pair("amount_cents", &cents.to_string());
+        }
+    }
+    let response = reqwest::Client::new().get(url).header("x-internal-auth", token).timeout(std::time::Duration::from_secs(8)).send().await.ok()?;
+    if !response.status().is_success() {
+        return None;
+    }
+    site_email_from_json(&response.json::<Value>().await.ok()?)
+}
+
+/// The host's own wording, used when the site cannot be asked.
+fn built_in_body(first_name: Option<&str>, event_name: &str, amount_cents: Option<i64>) -> String {
+    let greeting = first_name.map(|name| format!("Hi {name},")).unwrap_or_else(|| "Hi,".to_string());
+    let paid = amount_cents.map(|cents| format!(" We received your payment of {}.", dollars(cents))).unwrap_or_default();
+    format!("{greeting}\n\nYou're registered for {event_name}.{paid}\n\nYour seat is held. If anything changes, just reply to this email.\n")
+}
+
+/// Mails the receipt for `reference` if its Payment has succeeded. A missing
+/// mailer, registrant address or event is skipped quietly.
+pub(super) async fn send_receipt(reference: &str, client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, payments: &PaymentsProvider) {
+    let mailer = match Mailer::from_env() {
+        Ok(Some(mailer)) => mailer,
+        Ok(None) => return,
+        Err(e) => {
+            eprintln!("registration receipt: {e}");
+            return;
+        }
+    };
+    let Ok(read) = dispatch::read(client, wasm_path).await else {
+        return;
+    };
+    let binding = crate::ir::registrations_binding(&config.domain);
+    let registrations = instances_for(&read, &binding.registration_prefix());
+    let Some((_, registration)) = registrations.iter().find(|(id, _)| id == reference) else {
+        return;
+    };
+    let payment_instances = instances_for(&read, &payments.instance_prefix());
+    let payment = payment_instances.iter().find(|(id, _)| id == reference).map(|(_, p)| p);
+    if payment.and_then(|p| p.get("status")).and_then(|s| s.as_str()) != Some("succeeded") {
+        return;
+    }
+    let attendee = registration.get("attendee").cloned().unwrap_or_else(|| serde_json::json!({}));
+    let Some(to) = attendee.get("email").and_then(|v| v.as_str()).filter(|s| !s.is_empty()) else {
+        return;
+    };
+    let events = instances_for(&read, &binding.event_prefix());
+    let event_name = registration
+        .get("event_slug")
+        .and_then(|v| v.as_str())
+        .and_then(|slug| events.iter().find(|(id, _)| id == slug))
+        .and_then(|(_, e)| e.get("name"))
+        .and_then(|n| n.get("value"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("your event");
+    let amount = payment.and_then(|p| p.get("amount")).and_then(|a| a.get("cents")).and_then(Value::as_i64);
+    let first_name = attendee.get("first_name").and_then(|v| v.as_str()).filter(|s| !s.is_empty());
+    let from_site = match registration.get("event_slug").and_then(|v| v.as_str()) {
+        Some(slug) => site_email(slug, first_name, amount).await,
+        None => None,
+    };
+    let (subject, body) = match from_site {
+        Some(email) => (email.subject, email.body),
+        None => (receipt_subject(event_name), built_in_body(first_name, event_name, amount)),
+    };
+    let delivery = mailer.deliver(&Email { to, subject: &subject, body: &body, unsubscribe_url: None }).await;
+    if !delivery.ok {
+        eprintln!("registration receipt: not delivered: {}", delivery.reason.unwrap_or_default());
+    }
+}

data/rust/host/src/web/registrations.rs

@@ -367,6 +367,12 @@ pub(crate) async fn registration_complete_route(
         }
     }
 
+    // Only a payment that settled just now earns a receipt; a repeat click was
+    // refused above as already settled.
+    if outcome == "succeeded" && outcome_result.accepted {
+        super::registration_receipt::send_receipt(registration_id, client, wasm_path, config, payments).await;
+    }
+
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
@@ -675,8 +681,14 @@ pub(crate) async fn webhook_route(
             // A refusal here (e.g. a redelivered webhook — Stripe's delivery
             // is at-least-once) is a benign no-op: the payment already holds
             // the right status, and 200 tells Stripe's retry logic to stop.
-            if let Err(e) = dispatch::handle_routed(client, wasm_path, verb, json!(reference), facts, None, config, invoker).await {
-                return respond(500, "text/plain", &format!("{e:#}"));
+            match dispatch::handle_routed(client, wasm_path, verb, json!(reference), facts, None, config, invoker).await {
+                Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
+                // Only the delivery that settles the payment sends the receipt;
+                // a redelivery is refused and stays quiet.
+                Ok(settled) if settled.accepted && event_type == "checkout.session.completed" => {
+                    super::registration_receipt::send_receipt(&reference, client, wasm_path, config, payments).await;
+                }
+                Ok(_) => {}
             }
         }
     }

data/rust/host/src/web.rs

@@ -18,6 +18,7 @@ use tokio_postgres::Client;
 
 mod newsletter;
 mod newsletter_send;
+mod registration_receipt;
 mod registrations;
 
 use registrations::payments_routes;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - Chris Young
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -216,10 +216,14 @@ files:
 - lib/hecks/cli/doc_coverage.rb
 - lib/hecks/cli/document.rb
 - lib/hecks/cli/domain_stub.rb
+- lib/hecks/cli/domain_writer.rb
 - lib/hecks/cli/expression_projection.rb
 - lib/hecks/cli/follow.rb
 - lib/hecks/cli/history.rb
+- lib/hecks/cli/interview_agent.rb
 - lib/hecks/cli/interview_draft.rb
+- lib/hecks/cli/interview_run.rb
+- lib/hecks/cli/interview_session.rb
 - lib/hecks/cli/ir.rb
 - lib/hecks/cli/mcp.rb
 - lib/hecks/cli/model_check.rb
@@ -264,6 +268,7 @@ files:
 - lib/hecks/doors/ruby_door.rb
 - lib/hecks/doors/ruby_door/aggregate_door.rb
 - lib/hecks/doors/ruby_door/chapter.rb
+- lib/hecks/doors/usage_cache.rb
 - lib/hecks/embryonaut_bluebook.rb
 - lib/hecks/embryonaut_bluebook/lock.rb
 - lib/hecks/embryonaut_bluebook/shape.rb
@@ -369,6 +374,8 @@ files:
 - lib/hecks/hecks/adapters/console_capture.rb
 - lib/hecks/hecks/adapters/deploy_toolchain.adapter
 - lib/hecks/hecks/adapters/deploy_toolchain.rb
+- lib/hecks/hecks/adapters/finding_github.adapter
+- lib/hecks/hecks/adapters/finding_github.rb
 - lib/hecks/hecks/adapters/git.adapter
 - lib/hecks/hecks/adapters/git.rb
 - lib/hecks/hecks/adapters/host_http.adapter
@@ -533,7 +540,10 @@ files:
 - lib/hecks/projections/deploy/box/templates/deploy-box.sh.tmpl
 - lib/hecks/projections/deploy/box/templates/fetch-secrets.sh
 - lib/hecks/projections/deploy/box/templates/rds.yaml.tmpl
+- lib/hecks/projections/deploy/box/templates/render-compose-taskdef.sh.tmpl
 - lib/hecks/projections/deploy/box/templates/render-compose.sh.tmpl
+- lib/hecks/projections/deploy/box/templates/restore-to-rds.sh.tmpl
+- lib/hecks/projections/deploy/box/templates/verify-copy.sh.tmpl
 - lib/hecks/projections/deploy/fargate.rb
 - lib/hecks/projections/deploy/fargate/assembly.rb
 - lib/hecks/projections/deploy/fargate/cdn.rb
@@ -763,6 +773,9 @@ files:
 - lib/hecks/tenancy/bluebook/tenancy.hecksagon
 - lib/hecks/three_zero.rb
 - lib/hecks/three_zero/forms.yml
+- lib/hecks/tickets/bluebook/tickets.bluebook
+- lib/hecks/tickets/bluebook/tickets.hecksagon
+- lib/hecks/tickets/bluebook/tickets.ports.hecksagon
 - lib/hecks/tools.rb
 - lib/hecks/tools/argument_gate_matrix.rb
 - lib/hecks/tools/ci_gate_decision.rb
@@ -897,6 +910,8 @@ files:
 - rust/host/src/web/newsletter/template.rs
 - rust/host/src/web/newsletter/tests.rs
 - rust/host/src/web/newsletter_send.rs
+- rust/host/src/web/registration_receipt.rs
+- rust/host/src/web/registration_receipt/tests.rs
 - rust/host/src/web/registrations.rs
 - rust/lsp/.gitignore
 - rust/lsp/Cargo.lock