hecks 3.14.0 → 5.0.0

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

@@ -1,9 +1,10 @@
 use super::{instances_for, last_refusal, respond, with_id};
 use crate::checkout;
-use crate::dispatch;
+use crate::clock::unix_now;
 use crate::commerce_ir::{payments_provider, PaymentsProvider};
+use crate::dispatch;
+use crate::host::Host;
 use crate::journal::LineageConfig;
-use crate::lambda_client::LambdaInvoker;
 use crate::payments;
 use serde_json::{json, Value};
 use std::path::Path;
@@ -31,7 +32,13 @@ fn payment_processor(read: &Value, payments: &PaymentsProvider, reference: &str)
     instances_for(read, &payments.instance_prefix())
         .into_iter()
         .find(|(id, _)| id == reference)
-        .and_then(|(_, payment)| payment.get("processor").and_then(|p| p.get("value")).and_then(|v| v.as_str()).map(String::from))
+        .and_then(|(_, payment)| {
+            payment
+                .get("processor")
+                .and_then(|p| p.get("value"))
+                .and_then(|v| v.as_str())
+                .map(String::from)
+        })
 }
 
 // Payment statuses whose registration still holds a seat come from the
@@ -55,22 +62,40 @@ fn plain_id(raw: Option<&Value>) -> Option<String> {
 
 /// Seats used per event slug: Registrations not in a seat-freeing state whose Payment (same
 /// reference) is in a seat-holding status.
-fn seat_counts(read: &Value, domain: &str, payments: &PaymentsProvider) -> std::collections::HashMap<String, usize> {
+fn seat_counts(
+    read: &Value,
+    domain: &str,
+    payments: &PaymentsProvider,
+) -> std::collections::HashMap<String, usize> {
     let binding = crate::commerce_ir::registrations_binding(domain);
     count_seats(read, &binding, payments)
 }
 
 /// The seat count of `seat_counts` against an explicit registrations binding.
-fn count_seats(read: &Value, binding: &crate::commerce_ir::RegistrationsProvider, payments: &PaymentsProvider) -> std::collections::HashMap<String, usize> {
-    let statuses: std::collections::HashMap<String, String> = instances_for(read, &payments.instance_prefix())
-        .into_iter()
-        .filter_map(|(id, payment)| payment.get("status").and_then(|s| s.as_str()).map(|s| (id, s.to_string())))
-        .collect();
+fn count_seats(
+    read: &Value,
+    binding: &crate::commerce_ir::RegistrationsProvider,
+    payments: &PaymentsProvider,
+) -> std::collections::HashMap<String, usize> {
+    let statuses: std::collections::HashMap<String, String> =
+        instances_for(read, &payments.instance_prefix())
+            .into_iter()
+            .filter_map(|(id, payment)| {
+                payment
+                    .get("status")
+                    .and_then(|s| s.as_str())
+                    .map(|s| (id, s.to_string()))
+            })
+            .collect();
     let mut counts = std::collections::HashMap::new();
     for (id, registration) in instances_for(read, &binding.registration_prefix()) {
-        let holds = statuses.get(&id).is_some_and(|status| payments.holds_seat.iter().any(|held| held == status));
+        let holds = statuses
+            .get(&id)
+            .is_some_and(|status| payments.holds_seat.iter().any(|held| held == status));
         let freed = registration_frees_seat(&registration, &binding.frees_seat);
-        if let (true, false, Some(event_slug)) = (holds, freed, plain_id(registration.get("event_slug"))) {
+        if let (true, false, Some(event_slug)) =
+            (holds, freed, plain_id(registration.get("event_slug")))
+        {
             *counts.entry(event_slug).or_insert(0) += 1;
         }
     }
@@ -78,13 +103,24 @@ fn count_seats(read: &Value, binding: &crate::commerce_ir::RegistrationsProvider
 }
 
 /// How many seats one event has used.
-pub(crate) fn seats_taken(read: &Value, domain: &str, payments: &PaymentsProvider, event_slug: &str) -> usize {
-    seat_counts(read, domain, payments).get(event_slug).copied().unwrap_or(0)
+pub(crate) fn seats_taken(
+    read: &Value,
+    domain: &str,
+    payments: &PaymentsProvider,
+    event_slug: &str,
+) -> usize {
+    seat_counts(read, domain, payments)
+        .get(event_slug)
+        .copied()
+        .unwrap_or(0)
 }
 
 /// An event's capacity, when it carries a readable one.
 fn event_capacity(event: &Value) -> Option<i64> {
-    event.get("capacity").and_then(|c| c.get("value")).and_then(|v| v.as_i64())
+    event
+        .get("capacity")
+        .and_then(|c| c.get("value"))
+        .and_then(serde_json::Value::as_i64)
 }
 
 /// A whole-number field read as a bare number or as a single-field value
@@ -92,7 +128,9 @@ fn event_capacity(event: &Value) -> Option<i64> {
 /// never blocks a registration.
 fn whole_number(field: Option<&Value>) -> Option<i64> {
     let field = field?;
-    field.as_i64().or_else(|| field.get("value").and_then(|v| v.as_i64()))
+    field
+        .as_i64()
+        .or_else(|| field.get("value").and_then(serde_json::Value::as_i64))
 }
 
 /// Whether an event's registration window has shut because its start is
@@ -102,7 +140,10 @@ fn whole_number(field: Option<&Value>) -> Option<i64> {
 /// cutoff is still open. Either field absent, null or unreadable means no
 /// cutoff, the stance the seat check takes.
 fn registration_cutoff_passed(event: &Value, now_secs: i64) -> bool {
-    let (Some(starts_at), Some(hours)) = (whole_number(event.get("starts_at")), whole_number(event.get("registration_cutoff_hours"))) else {
+    let (Some(starts_at), Some(hours)) = (
+        whole_number(event.get("starts_at")),
+        whole_number(event.get("registration_cutoff_hours")),
+    ) else {
         return false;
     };
     now_secs.saturating_add(hours.saturating_mul(3600)) > starts_at
@@ -115,10 +156,21 @@ fn open_seats(capacity: i64, taken: usize) -> i64 {
 
 /// Seats still open on one event, never below zero; `None` when there is no
 /// such event or it carries no readable capacity.
-pub(crate) fn seats_left(read: &Value, domain: &str, payments: &PaymentsProvider, event_slug: &str) -> Option<i64> {
-    let events = instances_for(read, &crate::commerce_ir::registrations_binding(domain).event_prefix());
+pub(crate) fn seats_left(
+    read: &Value,
+    domain: &str,
+    payments: &PaymentsProvider,
+    event_slug: &str,
+) -> Option<i64> {
+    let events = instances_for(
+        read,
+        &crate::commerce_ir::registrations_binding(domain).event_prefix(),
+    );
     let (_, event) = events.iter().find(|(id, _)| id == event_slug)?;
-    Some(open_seats(event_capacity(event)?, seats_taken(read, domain, payments, event_slug)))
+    Some(open_seats(
+        event_capacity(event)?,
+        seats_taken(read, domain, payments, event_slug),
+    ))
 }
 
 /// The seat figures a caller reads for one event: `capacity` and `seats_left`
@@ -131,15 +183,33 @@ fn seat_figures(event: &Value, taken: usize) -> Value {
 /// The seat figures of every event, keyed by event slug.
 fn all_seat_figures(read: &Value, domain: &str, payments: &PaymentsProvider) -> Value {
     let counts = seat_counts(read, domain, payments);
-    let events = instances_for(read, &crate::commerce_ir::registrations_binding(domain).event_prefix());
-    let figures: serde_json::Map<String, Value> =
-        events.iter().map(|(slug, event)| (slug.clone(), seat_figures(event, counts.get(slug).copied().unwrap_or(0)))).collect();
+    let events = instances_for(
+        read,
+        &crate::commerce_ir::registrations_binding(domain).event_prefix(),
+    );
+    let figures: serde_json::Map<String, Value> = events
+        .iter()
+        .map(|(slug, event)| {
+            (
+                slug.clone(),
+                seat_figures(event, counts.get(slug).copied().unwrap_or(0)),
+            )
+        })
+        .collect();
     json!({"events": figures})
 }
 
 /// The seat figures of one event, with its `slug`; `None` when there is no such event.
-fn one_seat_figures(read: &Value, domain: &str, payments: &PaymentsProvider, event_slug: &str) -> Option<Value> {
-    let events = instances_for(read, &crate::commerce_ir::registrations_binding(domain).event_prefix());
+fn one_seat_figures(
+    read: &Value,
+    domain: &str,
+    payments: &PaymentsProvider,
+    event_slug: &str,
+) -> Option<Value> {
+    let events = instances_for(
+        read,
+        &crate::commerce_ir::registrations_binding(domain).event_prefix(),
+    );
     let (_, event) = events.iter().find(|(id, _)| id == event_slug)?;
     let mut figures = seat_figures(event, seats_taken(read, domain, payments, event_slug));
     figures["slug"] = json!(event_slug);
@@ -154,7 +224,13 @@ fn seats_path_slug(path: &str) -> Option<&str> {
 
 /// GET /events/seats and GET /events/<slug>/seats: the seat rule as a read,
 /// so a site never has to count registrations itself.
-async fn seats_route(path: &str, client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, payments: &PaymentsProvider) -> Value {
+async fn seats_route(
+    path: &str,
+    client: &Mutex<Client>,
+    wasm_path: &Path,
+    config: &LineageConfig,
+    payments: &PaymentsProvider,
+) -> Value {
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
@@ -163,106 +239,162 @@ async fn seats_route(path: &str, client: &Mutex<Client>, wasm_path: &Path, confi
         None => all_seat_figures(&read, &config.domain, payments),
         Some(slug) => match one_seat_figures(&read, &config.domain, payments, slug) {
             Some(figures) => figures,
-            None => return respond(404, "application/json", &json!({"error": "no such event"}).to_string()),
+            None => {
+                return respond(
+                    404,
+                    "application/json",
+                    &json!({"error": "no such event"}).to_string(),
+                )
+            }
         },
     };
     respond(200, "application/json", &body.to_string())
 }
 
-fn unix_now() -> i64 {
-    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() as i64
-}
-
-#[allow(clippy::too_many_arguments)]
 // Serves the checkout, registration-payment and webhook routes only when the
 // domain's IR declares `provides "payments"`. Takes the IR as a parameter,
 // not `ir()`, so the gate can be tested against one that lacks the key.
-#[allow(clippy::too_many_arguments)]
 pub(super) async fn payments_routes(
     domain_ir: Option<&Value>,
     method: &str,
     path: &str,
     raw_body: &str,
     stripe_signature: &str,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
 ) -> Option<Value> {
     let payments = domain_ir.and_then(payments_provider)?;
-    checkout_route(method, path, raw_body, stripe_signature, client, wasm_path, config, invoker, &payments).await
+    checkout_route(method, path, raw_body, stripe_signature, host, &payments).await
 }
-
 pub(super) async fn checkout_route(
     method: &str,
     path: &str,
     raw_body: &str,
     stripe_signature: &str,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
     payments: &PaymentsProvider,
 ) -> Option<Value> {
+    let Host {
+        client,
+        wasm_path,
+        config,
+        ..
+    } = host;
     match (method, path) {
-        ("POST", "/registrations") => {
-            Some(registrations_route(raw_body, &payments::PlatformConfig::load().await, client, wasm_path, config, invoker, payments).await)
-        }
+        ("POST", "/registrations") => Some(
+            registrations_route(
+                raw_body,
+                &payments::PlatformConfig::load().await,
+                host,
+                payments,
+            )
+            .await,
+        ),
         // GET /registrations/:id: read-only, re-derives state server-side
         // for the confirmation and pay pages rather than trusting their own
         // query string.
         ("GET", path) if path.starts_with("/registrations/") && !path.ends_with("/complete") => {
             let registration_id = path.trim_start_matches("/registrations/");
-            Some(registration_show_route(registration_id, client, wasm_path, config, payments).await)
+            Some(
+                registration_show_route(registration_id, client, wasm_path, config, payments).await,
+            )
         }
         // POST /registrations/:id/complete: mock checkout's Pay/Cancel button,
         // refused unless the Payment's own processor is "mock_stripe". Settles
         // through the same PaymentGateway port as POST /webhooks/stripe.
         ("POST", path) if path.starts_with("/registrations/") && path.ends_with("/complete") => {
-            let registration_id = path.trim_start_matches("/registrations/").trim_end_matches("/complete").trim_end_matches('/');
-            Some(registration_complete_route(registration_id, raw_body, client, wasm_path, config, invoker, payments).await)
-        }
-        ("POST", "/webhooks/stripe") => {
-            Some(webhook_route(raw_body, stripe_signature, &payments::PlatformConfig::load().await, client, wasm_path, config, invoker, payments).await)
+            let registration_id = path
+                .trim_start_matches("/registrations/")
+                .trim_end_matches("/complete")
+                .trim_end_matches('/');
+            Some(registration_complete_route(registration_id, raw_body, host, payments).await)
         }
+        ("POST", "/webhooks/stripe") => Some(
+            webhook_route(
+                raw_body,
+                stripe_signature,
+                &payments::PlatformConfig::load().await,
+                host,
+                payments,
+            )
+            .await,
+        ),
         // POST /events: a mock-payments service schedules a new session
         // when an editor picks a date. Idempotent — Event.find first means
         // a repeat call for the same slug is a no-op, not an error.
-        ("GET", "/events/seats") => Some(seats_route(path, client, wasm_path, config, payments).await),
-        ("GET", path) if seats_path_slug(path).is_some() => Some(seats_route(path, client, wasm_path, config, payments).await),
-        ("POST", "/events") => Some(events_route(raw_body, client, wasm_path, config, invoker).await),
+        ("GET", "/events/seats") => {
+            Some(seats_route(path, client, wasm_path, config, payments).await)
+        }
+        ("GET", path) if seats_path_slug(path).is_some() => {
+            Some(seats_route(path, client, wasm_path, config, payments).await)
+        }
+        ("POST", "/events") => Some(events_route(raw_body, host).await),
         _ => None,
     }
 }
 
 /// POST /events. Dispatches `<domain>::Event.Schedule` — Event is this
 /// deploy's own top-level aggregate, not a vendored chapter like Payments.
-async fn events_route(raw_body: &str, client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, invoker: &dyn LambdaInvoker) -> Value {
+async fn events_route(raw_body: &str, host: Host<'_>) -> Value {
+    let Host {
+        client,
+        wasm_path,
+        config,
+        ..
+    } = host;
     let body: Value = match serde_json::from_str(raw_body) {
         Ok(v) => v,
-        Err(e) => return respond(400, "application/json", &json!({"error": format!("invalid JSON: {e}")}).to_string()),
+        Err(e) => {
+            return respond(
+                400,
+                "application/json",
+                &json!({"error": format!("invalid JSON: {e}")}).to_string(),
+            )
+        }
     };
     let Some(slug) = body.get("slug").and_then(|v| v.as_str()) else {
-        return respond(400, "application/json", &json!({"error": "missing slug"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing slug"}).to_string(),
+        );
     };
 
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
-    let events = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).event_prefix());
+    let events = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).event_prefix(),
+    );
     if let Some((_, existing)) = events.iter().find(|(id, _)| id == slug) {
-        return respond(200, "application/json", &serde_json::to_string_pretty(&with_id(slug, existing)).unwrap_or_default());
+        return respond(
+            200,
+            "application/json",
+            &serde_json::to_string_pretty(&with_id(slug, existing)).unwrap_or_default(),
+        );
     }
 
     let Some(name) = body.get("name").and_then(|v| v.as_str()) else {
-        return respond(400, "application/json", &json!({"error": "missing name"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing name"}).to_string(),
+        );
     };
-    let Some(price_cents) = body.get("price_cents").and_then(|v| v.as_i64()) else {
-        return respond(400, "application/json", &json!({"error": "missing price_cents"}).to_string());
+    let Some(price_cents) = body.get("price_cents").and_then(serde_json::Value::as_i64) else {
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing price_cents"}).to_string(),
+        );
     };
-    let Some(capacity) = body.get("capacity").and_then(|v| v.as_i64()) else {
-        return respond(400, "application/json", &json!({"error": "missing capacity"}).to_string());
+    let Some(capacity) = body.get("capacity").and_then(serde_json::Value::as_i64) else {
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing capacity"}).to_string(),
+        );
     };
 
     let args = json!({
@@ -272,44 +404,83 @@ async fn events_route(raw_body: &str, client: &Mutex<Client>, wasm_path: &Path,
         "capacity": {"value": capacity},
     });
     let verb = crate::commerce_ir::registrations_binding(&config.domain).schedule;
-    let outcome = match dispatch::handle(client, wasm_path, &verb, args, None, config, invoker).await {
+    let outcome = match dispatch::handle(host, &verb, args, None).await {
         Ok(o) => o,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
     if !outcome.accepted {
-        return respond(422, "application/json", &last_refusal(&outcome.result).to_string());
+        return respond(
+            422,
+            "application/json",
+            &last_refusal(&outcome.result).to_string(),
+        );
     }
 
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
-    let events = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).event_prefix());
+    let events = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).event_prefix(),
+    );
     let Some((_, event)) = events.iter().find(|(id, _)| id == slug) else {
-        return respond(500, "text/plain", "event vanished immediately after being scheduled");
+        return respond(
+            500,
+            "text/plain",
+            "event vanished immediately after being scheduled",
+        );
     };
-    respond(201, "application/json", &serde_json::to_string_pretty(&with_id(slug, event)).unwrap_or_default())
+    respond(
+        201,
+        "application/json",
+        &serde_json::to_string_pretty(&with_id(slug, event)).unwrap_or_default(),
+    )
 }
 
 /// GET /registrations/:id: event and attendee fields, plus amount_cents and
 /// payment_status from the same-reference Payment.
-async fn registration_show_route(registration_id: &str, client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, payments: &PaymentsProvider) -> Value {
+async fn registration_show_route(
+    registration_id: &str,
+    client: &Mutex<Client>,
+    wasm_path: &Path,
+    config: &LineageConfig,
+    payments: &PaymentsProvider,
+) -> Value {
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
-    let registrations = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).registration_prefix());
+    let registrations = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).registration_prefix(),
+    );
     let Some((_, registration)) = registrations.iter().find(|(id, _)| id == registration_id) else {
-        return respond(404, "application/json", &json!({"error": "no such registration"}).to_string());
+        return respond(
+            404,
+            "application/json",
+            &json!({"error": "no such registration"}).to_string(),
+        );
     };
     let event_slug = registration.get("event_slug").and_then(|v| v.as_str());
-    let events = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).event_prefix());
-    let event = event_slug.and_then(|slug| events.iter().find(|(id, _)| id == slug)).map(|(_, e)| e);
+    let events = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).event_prefix(),
+    );
+    let event = event_slug
+        .and_then(|slug| events.iter().find(|(id, _)| id == slug))
+        .map(|(_, e)| e);
 
     let payment_instances = instances_for(&read, &payments.instance_prefix());
-    let payment = payment_instances.iter().find(|(id, _)| id == registration_id).map(|(_, p)| p);
-
-    let attendee = registration.get("attendee").cloned().unwrap_or_else(|| json!({}));
+    let payment = payment_instances
+        .iter()
+        .find(|(id, _)| id == registration_id)
+        .map(|(_, p)| p);
+
+    let attendee = registration
+        .get("attendee")
+        .cloned()
+        .unwrap_or_else(|| json!({}));
     respond(200, "application/json", &json!({
         "registration_id": registration_id,
         "event": {
@@ -332,35 +503,65 @@ async fn registration_show_route(registration_id: &str, client: &Mutex<Client>,
 pub(crate) async fn registration_complete_route(
     registration_id: &str,
     raw_body: &str,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
     payments: &PaymentsProvider,
 ) -> Value {
+    let Host {
+        client,
+        wasm_path,
+        config,
+        ..
+    } = host;
     let body: Value = match serde_json::from_str(raw_body) {
         Ok(v) => v,
-        Err(e) => return respond(400, "application/json", &json!({"error": format!("invalid JSON: {e}")}).to_string()),
+        Err(e) => {
+            return respond(
+                400,
+                "application/json",
+                &json!({"error": format!("invalid JSON: {e}")}).to_string(),
+            )
+        }
     };
     let Some(outcome) = body.get("outcome").and_then(|v| v.as_str()) else {
-        return respond(400, "application/json", &json!({"error": "missing outcome"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing outcome"}).to_string(),
+        );
     };
     if outcome != "succeeded" && outcome != "failed" {
-        return respond(400, "application/json", &json!({"error": "outcome must be \"succeeded\" or \"failed\""}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "outcome must be \"succeeded\" or \"failed\""}).to_string(),
+        );
     }
 
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
-    let registrations = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).registration_prefix());
+    let registrations = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).registration_prefix(),
+    );
     if !registrations.iter().any(|(id, _)| id == registration_id) {
-        return respond(404, "application/json", &json!({"error": "no such registration"}).to_string());
+        return respond(
+            404,
+            "application/json",
+            &json!({"error": "no such registration"}).to_string(),
+        );
     }
 
     let processor = match payment_processor(&read, payments, registration_id) {
         Some(processor) if processor == "mock_stripe" => processor,
-        _ => return respond(403, "application/json", &json!({"error": "not available with a real payment processor"}).to_string()),
+        _ => {
+            return respond(
+                403,
+                "application/json",
+                &json!({"error": "not available with a real payment processor"}).to_string(),
+            )
+        }
     };
     let reported_processor = json!({"value": processor});
     // `reference_to Payment, as: :reference` keeps `reference` inside `with:`
@@ -378,16 +579,20 @@ pub(crate) async fn registration_complete_route(
             json!({"reference": reference_fact, "reason": {"value": "declined_at_local_checkout"}, "reported_processor": reported_processor}),
         )
     };
-    let outcome_result = match dispatch::handle_routed(client, wasm_path, verb, json!(registration_id), facts, None, config, invoker).await {
-        Ok(o) => o,
-        Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
-    };
+    let outcome_result =
+        match dispatch::handle_routed(host, verb, json!(registration_id), facts, None).await {
+            Ok(o) => o,
+            Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
+        };
     // A repeat Succeeded/Failed on an already-settled Payment is a silent
     // no-op on Payment's own `given`, so it isn't surfaced as a 422 here
     // either.
     if !outcome_result.accepted {
         let refusal = last_refusal(&outcome_result.result);
-        let already_settled = refusal.get("error").and_then(|v| v.as_str()).map(|s| s.contains("pending")).unwrap_or(false);
+        let already_settled = refusal
+            .get("error")
+            .and_then(|v| v.as_str())
+            .is_some_and(|s| s.contains("pending"));
         if !already_settled {
             return respond(422, "application/json", &refusal.to_string());
         }
@@ -396,7 +601,7 @@ 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;
+        super::registration_receipt::deliver_receipt(registration_id, host, payments).await;
     }
 
     let read = match dispatch::read(client, wasm_path).await {
@@ -404,8 +609,17 @@ pub(crate) async fn registration_complete_route(
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
     let payment_instances = instances_for(&read, &payments.instance_prefix());
-    let status = payment_instances.iter().find(|(id, _)| id == registration_id).and_then(|(_, p)| p.get("status")).and_then(|v| v.as_str()).unwrap_or("");
-    respond(200, "application/json", &json!({"registration_id": registration_id, "payment_status": status}).to_string())
+    let status = payment_instances
+        .iter()
+        .find(|(id, _)| id == registration_id)
+        .and_then(|(_, p)| p.get("status"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+    respond(
+        200,
+        "application/json",
+        &json!({"registration_id": registration_id, "payment_status": status}).to_string(),
+    )
 }
 
 // Attendee shape varies per domain, so this forwards the caller's fields
@@ -436,83 +650,133 @@ fn display_name_from(body: &Value) -> Option<String> {
 // POST /registrations. Payment first, then Registration, sharing one
 // reference minted here; `role: None` throughout since the site calls in
 // server-to-server, not as a signed-in user.
-#[allow(clippy::too_many_arguments)]
 pub(crate) async fn registrations_route(
     raw_body: &str,
     platform: &payments::PlatformConfig,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
     payments: &PaymentsProvider,
 ) -> Value {
-    registrations_route_at(raw_body, platform, client, wasm_path, config, invoker, payments, unix_now()).await
+    registrations_route_at(raw_body, platform, host, payments, unix_now()).await
 }
 
 // The route with the wall clock passed in, so a test can fix the time the
 // registration cutoff is measured against.
-#[allow(clippy::too_many_arguments)]
 pub(crate) async fn registrations_route_at(
     raw_body: &str,
     platform: &payments::PlatformConfig,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
     payments: &PaymentsProvider,
     now_secs: i64,
 ) -> Value {
+    let Host {
+        client,
+        wasm_path,
+        config,
+        ..
+    } = host;
     let body: Value = match serde_json::from_str(raw_body) {
         Ok(v) => v,
-        Err(e) => return respond(400, "application/json", &json!({"error": format!("invalid JSON: {e}")}).to_string()),
+        Err(e) => {
+            return respond(
+                400,
+                "application/json",
+                &json!({"error": format!("invalid JSON: {e}")}).to_string(),
+            )
+        }
     };
     let Some(event_slug) = body.get("event_slug").and_then(|v| v.as_str()) else {
-        return respond(400, "application/json", &json!({"error": "missing event_slug"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing event_slug"}).to_string(),
+        );
     };
     // Cheap early exits before dispatching Payment.Initiate — full Attendee
     // validation still happens downstream in Registration.Request's own
     // given/invariant checks.
     let Some(name) = display_name_from(&body) else {
-        return respond(400, "application/json", &json!({"error": "missing name (or first_name and last_name)"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing name (or first_name and last_name)"}).to_string(),
+        );
     };
     let Some(email) = body.get("email").and_then(|v| v.as_str()) else {
-        return respond(400, "application/json", &json!({"error": "missing email"}).to_string());
+        return respond(
+            400,
+            "application/json",
+            &json!({"error": "missing email"}).to_string(),
+        );
     };
 
     let read = match dispatch::read(client, wasm_path).await {
         Ok(r) => r,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
-    let events = instances_for(&read, &crate::commerce_ir::registrations_binding(&config.domain).event_prefix());
+    let events = instances_for(
+        &read,
+        &crate::commerce_ir::registrations_binding(&config.domain).event_prefix(),
+    );
     let Some((_, event)) = events.iter().find(|(id, _)| id == event_slug) else {
-        return respond(404, "application/json", &json!({"error": "no such event"}).to_string());
+        return respond(
+            404,
+            "application/json",
+            &json!({"error": "no such event"}).to_string(),
+        );
     };
     if event.get("status").and_then(|v| v.as_str()) != Some("open") {
-        return respond(422, "application/json", &json!({"error": "registration is closed for this event"}).to_string());
+        return respond(
+            422,
+            "application/json",
+            &json!({"error": "registration is closed for this event"}).to_string(),
+        );
     }
     // An event that opted into a cutoff stops taking registrations that many
     // hours before it starts; a missing or unreadable field is no cutoff.
     if registration_cutoff_passed(event, now_secs) {
-        return respond(422, "application/json", &json!({"error": "registration has closed for this event"}).to_string());
+        return respond(
+            422,
+            "application/json",
+            &json!({"error": "registration has closed for this event"}).to_string(),
+        );
     }
     // A full event refuses before any Stripe call or write. An event whose
     // capacity cannot be read is not blocked: capacity is required when an
     // event is scheduled, so its absence means nothing to enforce.
     if seats_left(&read, &config.domain, payments, event_slug) == Some(0) {
-        return respond(409, "application/json", &json!({"error": "this event is full"}).to_string());
+        return respond(
+            409,
+            "application/json",
+            &json!({"error": "this event is full"}).to_string(),
+        );
     }
-    let price_cents = event.get("price").and_then(|p| p.get("cents")).and_then(|v| v.as_i64()).unwrap_or(0);
-    let event_name = event.get("name").and_then(|n| n.get("value")).and_then(|v| v.as_str()).unwrap_or("");
+    let price_cents = event
+        .get("price")
+        .and_then(|p| p.get("cents"))
+        .and_then(serde_json::Value::as_i64)
+        .unwrap_or(0);
+    let event_name = event
+        .get("name")
+        .and_then(|n| n.get("value"))
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
 
     // What checkout does is decided per request from this tenant's own
     // PaymentConnection, before anything is written — a paused connection
     // must never fall back to the mock walkthrough.
-    let plan = payments::checkout_plan(payments::connection(&read, &config.domain).as_ref(), platform);
+    let plan = payments::checkout_plan(
+        payments::connection(&read, &config.domain).as_ref(),
+        platform,
+    );
     let processor = match plan {
         payments::CheckoutPlan::Mock => "mock_stripe",
         payments::CheckoutPlan::Stripe { .. } => "stripe",
         payments::CheckoutPlan::Paused => {
-            return respond(503, "application/json", &json!({"error": "payments are temporarily unavailable"}).to_string());
+            return respond(
+                503,
+                "application/json",
+                &json!({"error": "payments are temporarily unavailable"}).to_string(),
+            );
         }
     };
     let site_url = platform.site_url.as_str();
@@ -522,9 +786,27 @@ pub(crate) async fn registrations_route_at(
     // A Stripe plan opens its embedded session before anything is written, so
     // a failure leaves no Payment or Registration behind. If a domain refusal
     // follows, the unused session simply expires.
-    let embedded_checkout = if let payments::CheckoutPlan::Stripe { api_key, publishable_key } = &plan {
-        let auth = checkout::StripeAuth { api_key, base_url: &platform.api_base };
-        match checkout::create_checkout_session(&auth, price_cents, event_name, &reference, checkout::session_expires_at(now_secs, crate::commerce_ir::checkout_windows_binding().session_hold)).await {
+    let embedded_checkout = if let payments::CheckoutPlan::Stripe {
+        api_key,
+        publishable_key,
+    } = &plan
+    {
+        let auth = checkout::StripeAuth {
+            api_key,
+            base_url: &platform.api_base,
+        };
+        match checkout::create_checkout_session(
+            &auth,
+            price_cents,
+            event_name,
+            &reference,
+            checkout::session_expires_at(
+                now_secs,
+                crate::commerce_ir::checkout_windows_binding().session_hold,
+            ),
+        )
+        .await
+        {
             // Stripe.js is opened with the publishable key; the answer carries
             // no `checkout_url`.
             Ok(session) => Some(json!({
@@ -533,8 +815,14 @@ pub(crate) async fn registrations_route_at(
                 "session_id": session.session_id,
             })),
             Err(e) => {
-                eprintln!("registrations: opening the Stripe session failed, nothing was recorded: {e:#}");
-                return respond(502, "application/json", &json!({"error": "payments are temporarily unavailable"}).to_string());
+                eprintln!(
+                    "registrations: opening the Stripe session failed, nothing was recorded: {e:#}"
+                );
+                return respond(
+                    502,
+                    "application/json",
+                    &json!({"error": "payments are temporarily unavailable"}).to_string(),
+                );
             }
         }
     } else {
@@ -548,12 +836,16 @@ pub(crate) async fn registrations_route_at(
         "amount": {"cents": price_cents},
         "client": {"name": name, "email": email},
     });
-    let outcome = match dispatch::handle(client, wasm_path, &payments.initiate, initiate_args, None, config, invoker).await {
+    let outcome = match dispatch::handle(host, &payments.initiate, initiate_args, None).await {
         Ok(o) => o,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
     if !outcome.accepted {
-        return respond(422, "application/json", &last_refusal(&outcome.result).to_string());
+        return respond(
+            422,
+            "application/json",
+            &last_refusal(&outcome.result).to_string(),
+        );
     }
 
     let mut request_args = json!({
@@ -564,10 +856,17 @@ pub(crate) async fn registrations_route_at(
     // A reaction reads only fields its event carries, never ones nested
     // inside `attendee`, so newsletter fields are declared flat on
     // Registration.Request; a command refuses args it doesn't declare.
-    let news_signup = body.get("news_signup").and_then(|v| v.as_bool()).unwrap_or(false);
+    let news_signup = body
+        .get("news_signup")
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false);
     let binding = crate::commerce_ir::registrations_binding(&config.domain);
     let forwards_newsletter = crate::ir::ir().is_some_and(|ir| {
-        binding.request_target().is_some_and(|(aggregate, command)| crate::commerce_ir::command_declares(ir, aggregate, command, "news_signup"))
+        binding
+            .request_target()
+            .is_some_and(|(aggregate, command)| {
+                crate::commerce_ir::command_declares(ir, aggregate, command, "news_signup")
+            })
     });
     if forwards_newsletter {
         request_args["news_signup"] = json!(news_signup);
@@ -579,12 +878,16 @@ pub(crate) async fn registrations_route_at(
         }
     }
     let request_verb = crate::commerce_ir::registrations_binding(&config.domain).request;
-    let outcome = match dispatch::handle(client, wasm_path, &request_verb, request_args, None, config, invoker).await {
+    let outcome = match dispatch::handle(host, &request_verb, request_args, None).await {
         Ok(o) => o,
         Err(e) => return respond(500, "text/plain", &format!("{e:#}")),
     };
     if !outcome.accepted {
-        return respond(422, "application/json", &last_refusal(&outcome.result).to_string());
+        return respond(
+            422,
+            "application/json",
+            &last_refusal(&outcome.result).to_string(),
+        );
     }
 
     // The domain's reaction has already subscribed the address by now; a
@@ -595,7 +898,11 @@ pub(crate) async fn registrations_route_at(
     }
 
     if let Some(embedded) = embedded_checkout {
-        return respond(200, "application/json", &json!({"registration_id": reference, "embedded_checkout": embedded}).to_string());
+        return respond(
+            200,
+            "application/json",
+            &json!({"registration_id": reference, "embedded_checkout": embedded}).to_string(),
+        );
     }
 
     // `return_to` is guest-supplied and never trusted raw — only a same-site
@@ -606,21 +913,35 @@ pub(crate) async fn registrations_route_at(
         _ => "/".to_string(),
     };
     let confirm_query = |outcome: &str| -> String {
-        let mut url = reqwest::Url::parse("http://placeholder.invalid/").unwrap();
+        // The base is only a carrier for the query encoder; it always parses.
+        let Ok(mut url) = reqwest::Url::parse("http://placeholder.invalid/") else {
+            return String::new();
+        };
         url.query_pairs_mut()
             .append_pair("registration_id", &reference)
             .append_pair("outcome", outcome)
             .append_pair("return_to", &return_to);
         url.query().unwrap_or("").to_string()
     };
-    let success_url = format!("{site_url}/registration-confirmed.html?{}", confirm_query("succeeded"));
-    let cancel_url = format!("{site_url}/registration-confirmed.html?{}", confirm_query("cancelled"));
+    let success_url = format!(
+        "{site_url}/registration-confirmed.html?{}",
+        confirm_query("succeeded")
+    );
+    let cancel_url = format!(
+        "{site_url}/registration-confirmed.html?{}",
+        confirm_query("cancelled")
+    );
 
     // A tenant with no connection, or a disabled one, is on the mock
     // walkthrough, never a misconfiguration to refuse. success_url/cancel_url
     // belong to this walkthrough only — an embedded session redirects nowhere.
-    let checkout_url = checkout::mock_checkout_session(&reference, &success_url, &cancel_url, site_url);
-    respond(200, "application/json", &json!({"checkout_url": checkout_url, "registration_id": reference}).to_string())
+    let checkout_url =
+        checkout::mock_checkout_session(&reference, &success_url, &cancel_url, site_url);
+    respond(
+        200,
+        "application/json",
+        &json!({"checkout_url": checkout_url, "registration_id": reference}).to_string(),
+    )
 }
 
 // The answer for an event that only the public mock secret could vouch for.
@@ -642,13 +963,13 @@ pub(crate) async fn webhook_route(
     raw_body: &str,
     signature_header: &str,
     platform: &payments::PlatformConfig,
-    client: &Mutex<Client>,
-    wasm_path: &Path,
-    config: &LineageConfig,
-    invoker: &dyn LambdaInvoker,
+    host: Host<'_>,
     payments: &PaymentsProvider,
 ) -> Value {
-    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs() as i64;
+    let Host {
+        client, wasm_path, ..
+    } = host;
+    let now = unix_now();
     // The environment's signing secret and any saved with the business's own
     // keys are all accepted; with none configured only the mock secret is.
     let configured = platform.webhook_secrets();
@@ -657,11 +978,16 @@ pub(crate) async fn webhook_route(
         // mock secret must not stand in for it.
         return mock_secret_refused();
     }
-    let candidates = if configured.is_empty() { vec![MOCK_STRIPE_WEBHOOK_SECRET] } else { configured };
+    let candidates = if configured.is_empty() {
+        vec![MOCK_STRIPE_WEBHOOK_SECRET]
+    } else {
+        configured
+    };
     let tolerance = crate::commerce_ir::checkout_windows_binding().webhook_tolerance;
     let mut verification = Ok(());
     for secret in &candidates {
-        verification = checkout::verify_signature(raw_body, signature_header, secret, now, tolerance);
+        verification =
+            checkout::verify_signature(raw_body, signature_header, secret, now, tolerance);
         if verification.is_ok() {
             break;
         }
@@ -687,12 +1013,21 @@ pub(crate) async fn webhook_route(
     let refuse_fallback = mock_secret_refused;
 
     let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
-    let object = event.get("data").and_then(|d| d.get("object")).cloned().unwrap_or_else(|| json!({}));
-    let reference = object.get("metadata").and_then(|m| m.get("registration_id")).and_then(|v| v.as_str()).map(String::from);
+    let object = event
+        .get("data")
+        .and_then(|d| d.get("object"))
+        .cloned()
+        .unwrap_or_else(|| json!({}));
+    let reference = object
+        .get("metadata")
+        .and_then(|m| m.get("registration_id"))
+        .and_then(|v| v.as_str())
+        .map(String::from);
 
     if let Some(reference) = reference {
         // Defaults to "stripe" when there's no matching Payment.
-        let processor = payment_processor(&read, payments, &reference).unwrap_or_else(|| "stripe".to_string());
+        let processor =
+            payment_processor(&read, payments, &reference).unwrap_or_else(|| "stripe".to_string());
         if fallback_secret && processor != "mock_stripe" {
             return refuse_fallback();
         }
@@ -707,21 +1042,29 @@ pub(crate) async fn webhook_route(
                 // The PaymentIntent id when one exists, else the Checkout
                 // Session's own id — `.get`, not a panic, since a synthetic
                 // test payload carries no payment_intent at all.
-                let transaction_id = object.get("payment_intent").and_then(|v| v.as_str())
+                let transaction_id = object
+                    .get("payment_intent")
+                    .and_then(|v| v.as_str())
                     .or_else(|| object.get("id").and_then(|v| v.as_str()))
                     .unwrap_or("")
                     .to_string();
-                Some((payments.succeeded.as_str(), json!({
+                Some((
+                    payments.succeeded.as_str(),
+                    json!({
+                        "reference": reference_fact,
+                        "transaction_id": {"value": transaction_id},
+                        "reported_processor": reported_processor,
+                    }),
+                ))
+            }
+            "checkout.session.expired" => Some((
+                payments.failed.as_str(),
+                json!({
                     "reference": reference_fact,
-                    "transaction_id": {"value": transaction_id},
+                    "reason": {"value": payments.lapse_reason},
                     "reported_processor": reported_processor,
-                })))
-            }
-            "checkout.session.expired" => Some((payments.failed.as_str(), json!({
-                "reference": reference_fact,
-                "reason": {"value": payments.lapse_reason},
-                "reported_processor": reported_processor,
-            }))),
+                }),
+            )),
             _ => None,
         };
 
@@ -729,12 +1072,12 @@ 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.
-            match dispatch::handle_routed(client, wasm_path, verb, json!(reference), facts, None, config, invoker).await {
+            match dispatch::handle_routed(host, verb, json!(reference), facts, None).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;
+                    super::registration_receipt::deliver_receipt(&reference, host, payments).await;
                 }
                 Ok(_) => {}
             }
@@ -751,34 +1094,65 @@ mod tests {
     use crate::web::tests::{provision_lineage, scratch_db};
 
     fn checkout_config(era: i32) -> LineageConfig {
-        LineageConfig { domain: "CheckoutFixture".to_string(), era: Some(era), mirrored: None }
+        LineageConfig {
+            domain: "CheckoutFixture".to_string(),
+            era: Some(era),
+            mirrored: None,
+        }
     }
 
     fn checkout_wasm_path() -> std::path::PathBuf {
         std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../dist/checkout_fixture.wasm")
     }
 
-    async fn schedule_event(client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, slug: &str, price_cents: i64) {
+    async fn schedule_event(
+        client: &Mutex<Client>,
+        wasm_path: &Path,
+        config: &LineageConfig,
+        slug: &str,
+        price_cents: i64,
+    ) {
         let args = json!({
             "slug": {"value": slug}, "name": {"value": "Sample Studio"},
             "price": {"cents": price_cents}, "capacity": {"value": 20},
         });
-        let outcome = dispatch::handle(client, wasm_path, "CheckoutFixture::Event.Schedule", args, None, config, &lambda_client::NeverInvoker)
-            .await
-            .unwrap();
-        assert!(outcome.accepted, "scheduling the fixture event should succeed: {:?}", outcome.result);
+        let outcome = dispatch::handle(
+            Host::new(client, wasm_path, config, &lambda_client::NeverInvoker),
+            "CheckoutFixture::Event.Schedule",
+            args,
+            None,
+        )
+        .await
+        .unwrap();
+        assert!(
+            outcome.accepted,
+            "scheduling the fixture event should succeed: {:?}",
+            outcome.result
+        );
     }
 
     fn sign_stripe_header(secret: &str, now: i64, payload: &str) -> String {
         use hmac::{Hmac, Mac};
         use sha2::Sha256;
+        use std::fmt::Write;
         let mut mac = Hmac::<Sha256>::new_from_slice(secret.as_bytes()).unwrap();
         mac.update(format!("{now}.{payload}").as_bytes());
-        format!("t={now},v1={}", mac.finalize().into_bytes().iter().map(|b| format!("{b:02x}")).collect::<String>())
+        let digest = mac
+            .finalize()
+            .into_bytes()
+            .iter()
+            .fold(String::new(), |mut hex, b| {
+                let _ = write!(hex, "{b:02x}"); // writing to a String cannot fail
+                hex
+            });
+        format!("t={now},v1={digest}")
     }
 
     fn now_secs() -> i64 {
-        std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs() as i64
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs() as i64
     }
 
     // A read of the domain: one `yoga` event of `capacity` seats, one `other`
@@ -786,11 +1160,23 @@ mod tests {
     // (reference, event slug, payment status).
     fn read_with(capacity: i64, rows: &[(&str, &str, &str)]) -> Value {
         let mut instances = serde_json::Map::new();
-        instances.insert("CheckoutFixture::Event#yoga".into(), json!({"capacity": {"value": capacity}}));
-        instances.insert("CheckoutFixture::Event#other".into(), json!({"capacity": {"value": 5}}));
+        instances.insert(
+            "CheckoutFixture::Event#yoga".into(),
+            json!({"capacity": {"value": capacity}}),
+        );
+        instances.insert(
+            "CheckoutFixture::Event#other".into(),
+            json!({"capacity": {"value": 5}}),
+        );
         for (reference, event, status) in rows {
-            instances.insert(format!("CheckoutFixture::Registration#{reference}"), json!({"event_slug": event}));
-            instances.insert(format!("Payments::Payment#{reference}"), json!({"status": status}));
+            instances.insert(
+                format!("CheckoutFixture::Registration#{reference}"),
+                json!({"event_slug": event}),
+            );
+            instances.insert(
+                format!("Payments::Payment#{reference}"),
+                json!({"status": status}),
+            );
         }
         json!({"instances": instances})
     }
@@ -800,10 +1186,18 @@ mod tests {
         let payments = four_state_payments();
         let read = read_with(
             10,
-            &[("a", "yoga", "pending"), ("b", "yoga", "succeeded"), ("c", "yoga", "refunding"), ("d", "yoga", "disputed")],
+            &[
+                ("a", "yoga", "pending"),
+                ("b", "yoga", "succeeded"),
+                ("c", "yoga", "refunding"),
+                ("d", "yoga", "disputed"),
+            ],
         );
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 4);
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(6));
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(6)
+        );
     }
 
     #[test]
@@ -811,34 +1205,67 @@ mod tests {
         let payments = crate::commerce_ir::fixture_payments();
         let read = read_with(
             3,
-            &[("a", "yoga", "failed"), ("b", "yoga", "refunded"), ("c", "yoga", "charged_back"), ("d", "yoga", "succeeded")],
+            &[
+                ("a", "yoga", "failed"),
+                ("b", "yoga", "refunded"),
+                ("c", "yoga", "charged_back"),
+                ("d", "yoga", "succeeded"),
+            ],
         );
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 1);
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(2));
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(2)
+        );
     }
 
     #[test]
     fn seats_are_counted_per_event_and_a_registration_without_a_payment_holds_none() {
         let payments = crate::commerce_ir::fixture_payments();
-        let mut read = read_with(4, &[("a", "yoga", "succeeded"), ("b", "other", "succeeded")]);
+        let mut read = read_with(
+            4,
+            &[("a", "yoga", "succeeded"), ("b", "other", "succeeded")],
+        );
         read["instances"]["CheckoutFixture::Registration#orphan"] = json!({"event_slug": "yoga"});
-        assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 1, "only this event's registrations, and only those with a payment");
+        assert_eq!(
+            seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+            1,
+            "only this event's registrations, and only those with a payment"
+        );
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "other"), 1);
     }
 
     #[test]
     fn an_archived_registration_gives_its_seat_back_whatever_its_payment_says() {
         let payments = crate::commerce_ir::fixture_payments();
-        let mut read = read_with(3, &[("a", "yoga", "succeeded"), ("b", "yoga", "pending"), ("c", "yoga", "succeeded")]);
+        let mut read = read_with(
+            3,
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "pending"),
+                ("c", "yoga", "succeeded"),
+            ],
+        );
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 3);
         read["instances"]["CheckoutFixture::Registration#a"]["status"] = json!("archived");
-        assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 2, "a paid but archived registration frees its seat");
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(1));
+        assert_eq!(
+            seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+            2,
+            "a paid but archived registration frees its seat"
+        );
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(1)
+        );
     }
 
     fn binding_freeing(states: &[&str]) -> crate::commerce_ir::RegistrationsProvider {
-        let mut binding = crate::commerce_ir::RegistrationsProvider::conventional("CheckoutFixture");
-        binding.frees_seat = states.iter().map(|s| s.to_string()).collect();
+        let mut binding =
+            crate::commerce_ir::RegistrationsProvider::conventional("CheckoutFixture");
+        binding.frees_seat = states
+            .iter()
+            .map(std::string::ToString::to_string)
+            .collect();
         binding
     }
 
@@ -848,17 +1275,32 @@ mod tests {
         let mut read = read_with(3, &[("a", "yoga", "succeeded"), ("b", "yoga", "succeeded")]);
         set_registration_status(&mut read, "a", "cancelled");
         let counts = count_seats(&read, &binding_freeing(&["cancelled"]), &payments);
-        assert_eq!(counts.get("yoga"), Some(&1), "cancelled is declared, so it frees the seat");
+        assert_eq!(
+            counts.get("yoga"),
+            Some(&1),
+            "cancelled is declared, so it frees the seat"
+        );
     }
 
     #[test]
     fn the_fixture_declared_cancelled_state_frees_its_seat_beside_archived() {
         let payments = crate::commerce_ir::fixture_payments();
-        let binding = crate::commerce_ir::registrations_provider(&crate::commerce_ir::fixture_ir()).expect("registrations");
-        let mut read = read_with(3, &[("a", "yoga", "succeeded"), ("b", "yoga", "succeeded"), ("c", "yoga", "succeeded")]);
+        let binding = crate::commerce_ir::registrations_provider(&crate::commerce_ir::fixture_ir())
+            .expect("registrations");
+        let mut read = read_with(
+            3,
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "succeeded"),
+                ("c", "yoga", "succeeded"),
+            ],
+        );
         set_registration_status(&mut read, "a", "cancelled");
         set_registration_status(&mut read, "b", "archived");
-        assert_eq!(count_seats(&read, &binding, &payments).get("yoga"), Some(&1));
+        assert_eq!(
+            count_seats(&read, &binding, &payments).get("yoga"),
+            Some(&1)
+        );
     }
 
     #[test]
@@ -867,7 +1309,11 @@ mod tests {
         let mut read = read_with(3, &[("a", "yoga", "succeeded")]);
         set_registration_status(&mut read, "a", "archived");
         let counts = count_seats(&read, &binding_freeing(&["cancelled"]), &payments);
-        assert_eq!(counts.get("yoga"), Some(&1), "only the declared states free a seat");
+        assert_eq!(
+            counts.get("yoga"),
+            Some(&1),
+            "only the declared states free a seat"
+        );
     }
 
     #[test]
@@ -875,8 +1321,12 @@ mod tests {
         let payments = crate::commerce_ir::fixture_payments();
         let mut read = read_with(3, &[("a", "yoga", "succeeded")]);
         set_registration_status(&mut read, "a", "archived");
-        let conventional = crate::commerce_ir::RegistrationsProvider::conventional("CheckoutFixture");
-        assert_eq!(count_seats(&read, &conventional, &payments).get("yoga"), None);
+        let conventional =
+            crate::commerce_ir::RegistrationsProvider::conventional("CheckoutFixture");
+        assert_eq!(
+            count_seats(&read, &conventional, &payments).get("yoga"),
+            None
+        );
     }
 
     #[test]
@@ -888,7 +1338,11 @@ mod tests {
         read["instances"]["CheckoutFixture::Registration#b"]["status"] = json!("active");
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 2);
         read["instances"]["CheckoutFixture::Registration#a"]["status"] = json!(null);
-        assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 2, "a null status is not archived either");
+        assert_eq!(
+            seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+            2,
+            "a null status is not archived either"
+        );
     }
 
     #[test]
@@ -896,9 +1350,15 @@ mod tests {
         let payments = crate::commerce_ir::fixture_payments();
         let mut read = read_with(2, &[("a", "yoga", "succeeded")]);
         read["instances"]["CheckoutFixture::Registration#a"]["status"] = json!("archived");
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(2));
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(2)
+        );
         read["instances"]["CheckoutFixture::Registration#a"]["status"] = json!("active");
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(1));
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(1)
+        );
     }
 
     #[test]
@@ -906,7 +1366,13 @@ mod tests {
         let payments = crate::commerce_ir::fixture_payments();
         let mut read = read_with(
             6,
-            &[("a", "yoga", "succeeded"), ("b", "yoga", "succeeded"), ("c", "yoga", "pending"), ("d", "yoga", "failed"), ("e", "other", "succeeded")],
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "succeeded"),
+                ("c", "yoga", "pending"),
+                ("d", "yoga", "failed"),
+                ("e", "other", "succeeded"),
+            ],
         );
         read["instances"]["CheckoutFixture::Registration#a"]["status"] = json!("archived");
         read["instances"]["CheckoutFixture::Registration#b"]["status"] = json!("active");
@@ -915,18 +1381,35 @@ mod tests {
         // b (active, paid) and c (no status, pending) hold; a is archived, d's
         // payment failed, and e is another event's.
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 2);
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "yoga"), Some(4));
-        assert_eq!(seats_left(&read, "CheckoutFixture", &payments, "other"), Some(5), "the archived registration on `other` frees its seat");
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(4)
+        );
+        assert_eq!(
+            seats_left(&read, "CheckoutFixture", &payments, "other"),
+            Some(5),
+            "the archived registration on `other` frees its seat"
+        );
     }
 
     #[test]
     fn seats_left_never_goes_below_zero_and_is_none_without_an_event_or_capacity() {
         let payments = crate::commerce_ir::fixture_payments();
         let oversold = read_with(1, &[("a", "yoga", "succeeded"), ("b", "yoga", "succeeded")]);
-        assert_eq!(seats_left(&oversold, "CheckoutFixture", &payments, "yoga"), Some(0));
-        assert_eq!(seats_left(&oversold, "CheckoutFixture", &payments, "nowhere"), None);
-        let no_capacity = json!({"instances": {"CheckoutFixture::Event#yoga": {"name": {"value": "Yoga"}}}});
-        assert_eq!(seats_left(&no_capacity, "CheckoutFixture", &payments, "yoga"), None);
+        assert_eq!(
+            seats_left(&oversold, "CheckoutFixture", &payments, "yoga"),
+            Some(0)
+        );
+        assert_eq!(
+            seats_left(&oversold, "CheckoutFixture", &payments, "nowhere"),
+            None
+        );
+        let no_capacity =
+            json!({"instances": {"CheckoutFixture::Event#yoga": {"name": {"value": "Yoga"}}}});
+        assert_eq!(
+            seats_left(&no_capacity, "CheckoutFixture", &payments, "yoga"),
+            None
+        );
     }
 
     // The site's own JavaScript tests of this rule (its seat-count spec) use the
@@ -935,20 +1418,27 @@ mod tests {
     const FREEING: [&str; 3] = ["failed", "refunded", "charged_back"];
 
     fn set_registration_status(read: &mut Value, reference: &str, status: &str) {
-        read["instances"][format!("CheckoutFixture::Registration#{reference}")]["status"] = json!(status);
+        read["instances"][format!("CheckoutFixture::Registration#{reference}")]["status"] =
+            json!(status);
     }
 
     /// The fixture's payments binding with the production table: the fixture lifecycle has only
     /// pending, succeeded and failed, so refunding and disputed need the table set here.
     fn four_state_payments() -> crate::commerce_ir::PaymentsProvider {
         let mut payments = crate::commerce_ir::fixture_payments();
-        payments.holds_seat = HOLDING.iter().map(|s| s.to_string()).collect();
+        payments.holds_seat = HOLDING
+            .iter()
+            .map(std::string::ToString::to_string)
+            .collect();
         payments
     }
 
     #[test]
     fn the_seat_holding_table_comes_from_the_fixture_ir_mark() {
-        assert_eq!(crate::commerce_ir::fixture_payments().holds_seat, vec!["pending", "succeeded"]);
+        assert_eq!(
+            crate::commerce_ir::fixture_payments().holds_seat,
+            vec!["pending", "succeeded"]
+        );
     }
 
     #[test]
@@ -956,11 +1446,19 @@ mod tests {
         let payments = four_state_payments();
         for status in HOLDING {
             let read = read_with(10, &[("r", "yoga", status)]);
-            assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 1, "{status} should hold a seat");
+            assert_eq!(
+                seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+                1,
+                "{status} should hold a seat"
+            );
         }
         for status in FREEING {
             let read = read_with(10, &[("r", "yoga", status)]);
-            assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 0, "{status} should free the seat");
+            assert_eq!(
+                seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+                0,
+                "{status} should free the seat"
+            );
         }
     }
 
@@ -969,13 +1467,23 @@ mod tests {
         let payments = crate::commerce_ir::fixture_payments();
         let mut read = read_with(
             10,
-            &[("a", "yoga", "succeeded"), ("b", "yoga", "pending"), ("c", "other", "pending"), ("d", "yoga", "failed")],
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "pending"),
+                ("c", "other", "pending"),
+                ("d", "yoga", "failed"),
+            ],
         );
-        read["instances"]["CheckoutFixture::Registration#b"]["event_slug"] = json!({"value": "yoga"});
+        read["instances"]["CheckoutFixture::Registration#b"]["event_slug"] =
+            json!({"value": "yoga"});
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 2);
         assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "other"), 1);
         read["instances"]["CheckoutFixture::Registration#a"]["event_slug"] = json!("");
-        assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 1, "an empty event id is no reference");
+        assert_eq!(
+            seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+            1,
+            "an empty event id is no reference"
+        );
     }
 
     #[test]
@@ -997,14 +1505,25 @@ mod tests {
         for status in HOLDING {
             let mut read = read_with(10, &[("r", "yoga", status)]);
             set_registration_status(&mut read, "r", "archived");
-            assert_eq!(seats_taken(&read, "CheckoutFixture", &payments, "yoga"), 0, "archived + {status} should not hold a seat");
+            assert_eq!(
+                seats_taken(&read, "CheckoutFixture", &payments, "yoga"),
+                0,
+                "archived + {status} should not hold a seat"
+            );
         }
     }
 
     #[test]
     fn archiving_one_of_several_guests_frees_exactly_one_seat() {
         let payments = crate::commerce_ir::fixture_payments();
-        let mut read = read_with(10, &[("a", "yoga", "succeeded"), ("b", "yoga", "succeeded"), ("c", "yoga", "pending")]);
+        let mut read = read_with(
+            10,
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "succeeded"),
+                ("c", "yoga", "pending"),
+            ],
+        );
         set_registration_status(&mut read, "a", "active");
         set_registration_status(&mut read, "b", "archived");
         set_registration_status(&mut read, "c", "active");
@@ -1014,9 +1533,23 @@ mod tests {
     #[test]
     fn seat_figures_carry_capacity_taken_and_left_and_null_without_a_capacity() {
         let payments = crate::commerce_ir::fixture_payments();
-        let read = read_with(3, &[("a", "yoga", "succeeded"), ("b", "yoga", "pending"), ("c", "yoga", "succeeded"), ("d", "yoga", "succeeded")]);
-        assert_eq!(one_seat_figures(&read, "CheckoutFixture", &payments, "yoga"), Some(json!({"slug": "yoga", "capacity": 3, "seats_taken": 4, "seats_left": 0})));
-        assert_eq!(one_seat_figures(&read, "CheckoutFixture", &payments, "nowhere"), None);
+        let read = read_with(
+            3,
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "pending"),
+                ("c", "yoga", "succeeded"),
+                ("d", "yoga", "succeeded"),
+            ],
+        );
+        assert_eq!(
+            one_seat_figures(&read, "CheckoutFixture", &payments, "yoga"),
+            Some(json!({"slug": "yoga", "capacity": 3, "seats_taken": 4, "seats_left": 0}))
+        );
+        assert_eq!(
+            one_seat_figures(&read, "CheckoutFixture", &payments, "nowhere"),
+            None
+        );
         assert_eq!(
             all_seat_figures(&read, "CheckoutFixture", &payments),
             json!({"events": {
@@ -1024,7 +1557,8 @@ mod tests {
                 "other": {"capacity": 5, "seats_taken": 0, "seats_left": 5},
             }})
         );
-        let no_capacity = json!({"instances": {"CheckoutFixture::Event#yoga": {"name": {"value": "Yoga"}}}});
+        let no_capacity =
+            json!({"instances": {"CheckoutFixture::Event#yoga": {"name": {"value": "Yoga"}}}});
         assert_eq!(
             one_seat_figures(&no_capacity, "CheckoutFixture", &payments, "yoga"),
             Some(json!({"slug": "yoga", "capacity": null, "seats_taken": 0, "seats_left": null}))
@@ -1034,19 +1568,42 @@ mod tests {
     #[test]
     fn the_seat_figures_agree_with_seats_left_for_every_event() {
         let payments = crate::commerce_ir::fixture_payments();
-        let mut read = read_with(6, &[("a", "yoga", "succeeded"), ("b", "yoga", "refunding"), ("c", "other", "pending"), ("d", "yoga", "failed")]);
+        let mut read = read_with(
+            6,
+            &[
+                ("a", "yoga", "succeeded"),
+                ("b", "yoga", "refunding"),
+                ("c", "other", "pending"),
+                ("d", "yoga", "failed"),
+            ],
+        );
         set_registration_status(&mut read, "b", "archived");
         let all = all_seat_figures(&read, "CheckoutFixture", &payments);
         for slug in ["yoga", "other"] {
-            assert_eq!(all["events"][slug]["seats_left"].as_i64(), seats_left(&read, "CheckoutFixture", &payments, slug), "{slug}");
-            assert_eq!(all["events"][slug]["seats_taken"].as_u64(), Some(seats_taken(&read, "CheckoutFixture", &payments, slug) as u64), "{slug}");
+            assert_eq!(
+                all["events"][slug]["seats_left"].as_i64(),
+                seats_left(&read, "CheckoutFixture", &payments, slug),
+                "{slug}"
+            );
+            assert_eq!(
+                all["events"][slug]["seats_taken"].as_u64(),
+                Some(seats_taken(&read, "CheckoutFixture", &payments, slug) as u64),
+                "{slug}"
+            );
         }
     }
 
     #[test]
     fn only_a_single_segment_slug_between_events_and_seats_names_an_event() {
         assert_eq!(seats_path_slug("/events/yoga/seats"), Some("yoga"));
-        for path in ["/events/seats", "/events//seats", "/events/a/b/seats", "/events/yoga", "/events/yoga/seats/x", "/registrations/x/seats"] {
+        for path in [
+            "/events/seats",
+            "/events//seats",
+            "/events/a/b/seats",
+            "/events/yoga",
+            "/events/yoga/seats/x",
+            "/registrations/x/seats",
+        ] {
             assert_eq!(seats_path_slug(path), None, "{path}");
         }
     }
@@ -1054,7 +1611,13 @@ mod tests {
     #[tokio::test]
     async fn the_seat_routes_answer_from_a_real_read_and_404_an_unknown_event() {
         let client = scratch_db("hecks_host_web_test_seat_routes").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
         schedule_event(&client, &wasm_path, &config, "yoga", 4200).await;
@@ -1062,13 +1625,40 @@ mod tests {
         let get = |path: &'static str| {
             let (client, wasm_path, config, ir) = (&client, &wasm_path, &config, &ir);
             async move {
-                let response = payments_routes(Some(ir), "GET", path, "", "", client, wasm_path, config, &lambda_client::NeverInvoker).await.expect("a seats path");
-                (response["statusCode"].as_u64().unwrap(), serde_json::from_str::<Value>(response["body"].as_str().unwrap()).unwrap())
+                let response = payments_routes(
+                    Some(ir),
+                    "GET",
+                    path,
+                    "",
+                    "",
+                    Host::new(client, wasm_path, config, &lambda_client::NeverInvoker),
+                )
+                .await
+                .expect("a seats path");
+                (
+                    response["statusCode"].as_u64().unwrap(),
+                    serde_json::from_str::<Value>(response["body"].as_str().unwrap()).unwrap(),
+                )
             }
         };
-        assert_eq!(get("/events/yoga/seats").await, (200, json!({"slug": "yoga", "capacity": 20, "seats_taken": 0, "seats_left": 20})));
-        assert_eq!(get("/events/seats").await, (200, json!({"events": {"yoga": {"capacity": 20, "seats_taken": 0, "seats_left": 20}}})));
-        assert_eq!(get("/events/nowhere/seats").await, (404, json!({"error": "no such event"})));
+        assert_eq!(
+            get("/events/yoga/seats").await,
+            (
+                200,
+                json!({"slug": "yoga", "capacity": 20, "seats_taken": 0, "seats_left": 20})
+            )
+        );
+        assert_eq!(
+            get("/events/seats").await,
+            (
+                200,
+                json!({"events": {"yoga": {"capacity": 20, "seats_taken": 0, "seats_left": 20}}})
+            )
+        );
+        assert_eq!(
+            get("/events/nowhere/seats").await,
+            (404, json!({"error": "no such event"}))
+        );
     }
 
     #[test]
@@ -1096,8 +1686,16 @@ mod tests {
 
         let attendee = attendee_from(&body);
 
-        assert_eq!(attendee.get("event_slug"), None, "routing metadata must not leak into Attendee");
-        assert_eq!(attendee.get("return_to"), None, "routing metadata must not leak into Attendee");
+        assert_eq!(
+            attendee.get("event_slug"),
+            None,
+            "routing metadata must not leak into Attendee"
+        );
+        assert_eq!(
+            attendee.get("return_to"),
+            None,
+            "routing metadata must not leak into Attendee"
+        );
         assert_eq!(attendee["first_name"], "Ada");
         assert_eq!(attendee["last_name"], "Lovelace");
         assert_eq!(attendee["email"], "ada@example.com");
@@ -1113,7 +1711,10 @@ mod tests {
         // Must round-trip byte-for-byte — this exact shape is what
         // CheckoutFixture's tests, and any simple-Attendee domain, send.
         let body = json!({"event_slug": "happy-event", "name": "Ada Lovelace", "email": "ada@example.com"});
-        assert_eq!(attendee_from(&body), json!({"name": "Ada Lovelace", "email": "ada@example.com"}));
+        assert_eq!(
+            attendee_from(&body),
+            json!({"name": "Ada Lovelace", "email": "ada@example.com"})
+        );
     }
 
     #[test]
@@ -1130,17 +1731,45 @@ mod tests {
 
     #[test]
     fn display_name_from_is_none_when_neither_shape_is_present() {
-        assert_eq!(display_name_from(&json!({"email": "ada@example.com"})), None);
-        assert_eq!(display_name_from(&json!({"first_name": "Ada"})), None, "last_name alone is missing");
-        assert_eq!(display_name_from(&json!({"last_name": "Lovelace"})), None, "first_name alone is missing");
+        assert_eq!(
+            display_name_from(&json!({"email": "ada@example.com"})),
+            None
+        );
+        assert_eq!(
+            display_name_from(&json!({"first_name": "Ada"})),
+            None,
+            "last_name alone is missing"
+        );
+        assert_eq!(
+            display_name_from(&json!({"last_name": "Lovelace"})),
+            None,
+            "first_name alone is missing"
+        );
     }
 
     #[tokio::test]
     async fn registrations_route_refuses_a_body_missing_any_required_field() {
         let client = scratch_db("hecks_host_web_test_registrations_missing_fields").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
-
-        let response = registrations_route(r#"{"event_slug":"yoga-aug"}"#, &payments::test_platform(), &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
+
+        let response = registrations_route(
+            r#"{"event_slug":"yoga-aug"}"#,
+            &payments::test_platform(),
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 400);
         assert!(response["body"].as_str().unwrap().contains("missing name"));
     }
@@ -1149,9 +1778,16 @@ mod tests {
     // `name`-only Attendee — proves display_name_from composes a real Client
     // name and attendee_from forwards fields verbatim, without a second fixture.
     #[tokio::test]
-    async fn registrations_route_forwards_a_new_shaped_attendee_verbatim_even_against_an_old_shaped_fixture() {
+    async fn registrations_route_forwards_a_new_shaped_attendee_verbatim_even_against_an_old_shaped_fixture(
+    ) {
         let client = scratch_db("hecks_host_web_test_registrations_new_shape").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
@@ -1164,7 +1800,13 @@ mod tests {
             "email": "ada@example.com",
         })
         .to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
 
         // Registration.Request refuses (no first_name/last_name in this
         // Attendee) but only after Payment.Initiate already ran, proving
@@ -1182,7 +1824,9 @@ mod tests {
             "Payment.Initiate should have committed for real using the composed display name: {instances:?}"
         );
         assert!(
-            instances.keys().all(|k| !k.starts_with("CheckoutFixture::Registration#")),
+            instances
+                .keys()
+                .all(|k| !k.starts_with("CheckoutFixture::Registration#")),
             "Registration.Request must never have committed: {instances:?}"
         );
     }
@@ -1207,40 +1851,109 @@ mod tests {
             ("GET", "/events/yoga/seats"),
         ] {
             for ir in [Some(&no_payments), None] {
-                let response = payments_routes(ir, method, path, "not json", "", &client, &wasm_path, &config, &lambda_client::NeverInvoker).await;
-                assert!(response.is_none(), "{method} {path} answered although the IR declares no payments: {response:?}");
+                let response = payments_routes(
+                    ir,
+                    method,
+                    path,
+                    "not json",
+                    "",
+                    Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+                )
+                .await;
+                assert!(
+                    response.is_none(),
+                    "{method} {path} answered although the IR declares no payments: {response:?}"
+                );
             }
         }
 
         let fixture_ir = crate::commerce_ir::fixture_ir();
-        let response = payments_routes(Some(&fixture_ir), "POST", "/registrations", "not json", "", &client, &wasm_path, &config, &lambda_client::NeverInvoker).await;
-        assert_eq!(response.expect("the fixture IR declares payments, so the route answers")["statusCode"], 400);
+        let response = payments_routes(
+            Some(&fixture_ir),
+            "POST",
+            "/registrations",
+            "not json",
+            "",
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+        )
+        .await;
+        assert_eq!(
+            response.expect("the fixture IR declares payments, so the route answers")["statusCode"],
+            400
+        );
     }
 
     #[tokio::test]
     async fn registrations_route_refuses_invalid_json_outright() {
         let client = scratch_db("hecks_host_web_test_registrations_bad_json").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
-
-        let response = registrations_route("not json", &payments::test_platform(), &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
+
+        let response = registrations_route(
+            "not json",
+            &payments::test_platform(),
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 400);
     }
 
     #[tokio::test]
     async fn events_route_refuses_invalid_json_outright() {
         let client = scratch_db("hecks_host_web_test_events_bad_json").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
-
-        let response = events_route("not json", &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
+
+        let response = events_route(
+            "not json",
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+        )
+        .await;
         assert_eq!(response["statusCode"], 400);
     }
 
     #[tokio::test]
     async fn events_route_refuses_a_body_missing_any_required_field() {
         let client = scratch_db("hecks_host_web_test_events_missing_fields").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
-
-        let response = events_route(r#"{"slug":"new-event"}"#, &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
+
+        let response = events_route(
+            r#"{"slug":"new-event"}"#,
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+        )
+        .await;
         assert_eq!(response["statusCode"], 400);
         assert!(response["body"].as_str().unwrap().contains("missing name"));
     }
@@ -1248,14 +1961,25 @@ mod tests {
     #[tokio::test]
     async fn events_route_schedules_a_new_event_and_returns_201() {
         let client = scratch_db("hecks_host_web_test_events_new").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         let body = json!({"slug": "mock-payments-event", "name": "Mock Payments Event", "price_cents": 4200, "capacity": 20}).to_string();
-        let response = events_route(&body, &client, &wasm_path, &config, &lambda_client::NeverInvoker).await;
+        let response = events_route(
+            &body,
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+        )
+        .await;
         assert_eq!(response["statusCode"], 201, "{response:?}");
-        let response_body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
+        let response_body: Value =
+            serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
         assert_eq!(response_body["slug"]["value"], "mock-payments-event");
         assert_eq!(response_body["name"]["value"], "Mock Payments Event");
         assert_eq!(response_body["price"]["cents"], 4200);
@@ -1265,7 +1989,9 @@ mod tests {
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
         assert!(
-            instances.keys().any(|k| k == "CheckoutFixture::Event#mock-payments-event"),
+            instances
+                .keys()
+                .any(|k| k == "CheckoutFixture::Event#mock-payments-event"),
             "Event.Schedule should have committed for real: {instances:?}"
         );
     }
@@ -1275,27 +2001,47 @@ mod tests {
     #[tokio::test]
     async fn events_route_is_idempotent_on_a_repeat_slug() {
         let client = scratch_db("hecks_host_web_test_events_idempotent").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         let body = json!({"slug": "repeat-event", "name": "Repeat Event", "price_cents": 1000, "capacity": 5}).to_string();
-        let first = events_route(&body, &client, &wasm_path, &config, &lambda_client::NeverInvoker).await;
+        let first = events_route(
+            &body,
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+        )
+        .await;
         assert_eq!(first["statusCode"], 201, "{first:?}");
 
         // A second call with different name/price/capacity still returns the
         // original event's state, 200 not 201 — idempotency keys only on slug.
         let second_body = json!({"slug": "repeat-event", "name": "Different Name", "price_cents": 9999, "capacity": 1}).to_string();
-        let second = events_route(&second_body, &client, &wasm_path, &config, &lambda_client::NeverInvoker).await;
+        let second = events_route(
+            &second_body,
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+        )
+        .await;
         assert_eq!(second["statusCode"], 200, "{second:?}");
         let second_body: Value = serde_json::from_str(second["body"].as_str().unwrap()).unwrap();
-        assert_eq!(second_body["name"]["value"], "Repeat Event", "must return the ORIGINAL event, not re-schedule with the new fields");
+        assert_eq!(
+            second_body["name"]["value"], "Repeat Event",
+            "must return the ORIGINAL event, not re-schedule with the new fields"
+        );
         assert_eq!(second_body["price"]["cents"], 1000);
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
         assert_eq!(
-            instances.keys().filter(|k| k.starts_with("CheckoutFixture::Event#repeat-event")).count(),
+            instances
+                .keys()
+                .filter(|k| k.starts_with("CheckoutFixture::Event#repeat-event"))
+                .count(),
             1,
             "exactly one Event, never a second dispatch: {instances:?}"
         );
@@ -1304,35 +2050,82 @@ mod tests {
     #[tokio::test]
     async fn registrations_route_404s_an_unknown_event_slug() {
         let client = scratch_db("hecks_host_web_test_registrations_no_event").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
-
-        let body = json!({"event_slug": "nope", "name": "Ada", "email": "ada@example.com"}).to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
+
+        let body =
+            json!({"event_slug": "nope", "name": "Ada", "email": "ada@example.com"}).to_string();
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 404);
     }
 
     #[tokio::test]
     async fn registrations_route_refuses_a_closed_event() {
         let client = scratch_db("hecks_host_web_test_registrations_closed_event").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         schedule_event(&client, &wasm_path, &config, "closed-event", 4200).await;
-        let close = dispatch::handle(&client, &wasm_path, "CheckoutFixture::Event.Close", json!({"id": "closed-event"}), None, &config, &lambda_client::NeverInvoker)
-            .await
-            .unwrap();
-        assert!(close.accepted, "closing the fixture event should succeed: {:?}", close.result);
+        let close = dispatch::handle(
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            "CheckoutFixture::Event.Close",
+            json!({"id": "closed-event"}),
+            None,
+        )
+        .await
+        .unwrap();
+        assert!(
+            close.accepted,
+            "closing the fixture event should succeed: {:?}",
+            close.result
+        );
 
-        let body = json!({"event_slug": "closed-event", "name": "Ada", "email": "ada@example.com"}).to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let body = json!({"event_slug": "closed-event", "name": "Ada", "email": "ada@example.com"})
+            .to_string();
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 422);
         assert!(response["body"].as_str().unwrap().contains("closed"));
     }
 
     // Schedules `slug` starting at `starts_at` with the optional cutoff set
     // (or absent), through the real Event.Schedule command.
-    async fn schedule_timed_event(client: &Mutex<Client>, wasm_path: &Path, config: &LineageConfig, slug: &str, starts_at: i64, cutoff_hours: Option<i64>) {
+    async fn schedule_timed_event(
+        client: &Mutex<Client>,
+        wasm_path: &Path,
+        config: &LineageConfig,
+        slug: &str,
+        starts_at: i64,
+        cutoff_hours: Option<i64>,
+    ) {
         let mut args = json!({
             "slug": {"value": slug}, "name": {"value": "Sample Studio"},
             "price": {"cents": 4200}, "capacity": {"value": 20},
@@ -1341,25 +2134,57 @@ mod tests {
         if let Some(hours) = cutoff_hours {
             args["registration_cutoff_hours"] = json!({"value": hours});
         }
-        let outcome = dispatch::handle(client, wasm_path, "CheckoutFixture::Event.Schedule", args, None, config, &lambda_client::NeverInvoker)
-            .await
-            .unwrap();
-        assert!(outcome.accepted, "scheduling the timed fixture event should succeed: {:?}", outcome.result);
+        let outcome = dispatch::handle(
+            Host::new(client, wasm_path, config, &lambda_client::NeverInvoker),
+            "CheckoutFixture::Event.Schedule",
+            args,
+            None,
+        )
+        .await
+        .unwrap();
+        assert!(
+            outcome.accepted,
+            "scheduling the timed fixture event should succeed: {:?}",
+            outcome.result
+        );
     }
 
     #[tokio::test]
-    async fn registrations_route_refuses_a_session_inside_its_registration_cutoff_and_writes_nothing() {
+    async fn registrations_route_refuses_a_session_inside_its_registration_cutoff_and_writes_nothing(
+    ) {
         let client = scratch_db("hecks_host_web_test_registrations_cutoff_passed").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         // Starts in 5 hours with a 6 hour cutoff: registration closed an hour ago.
         let now = 1_800_000_000;
-        schedule_timed_event(&client, &wasm_path, &config, "too-late", now + 5 * 3600, Some(6)).await;
+        schedule_timed_event(
+            &client,
+            &wasm_path,
+            &config,
+            "too-late",
+            now + 5 * 3600,
+            Some(6),
+        )
+        .await;
 
-        let body = json!({"event_slug": "too-late", "name": "Ada", "email": "ada@example.com"}).to_string();
-        let response = registrations_route_at(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments(), now).await;
+        let body = json!({"event_slug": "too-late", "name": "Ada", "email": "ada@example.com"})
+            .to_string();
+        let response = registrations_route_at(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+            now,
+        )
+        .await;
         assert_eq!(response["statusCode"], 422, "{response:?}");
         assert_eq!(
             serde_json::from_str::<Value>(response["body"].as_str().unwrap()).unwrap(),
@@ -1369,7 +2194,10 @@ mod tests {
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
         assert!(
-            instances.keys().all(|k| !k.starts_with("Payments::Payment#") && !k.starts_with("CheckoutFixture::Registration#")),
+            instances
+                .keys()
+                .all(|k| !k.starts_with("Payments::Payment#")
+                    && !k.starts_with("CheckoutFixture::Registration#")),
             "a refused registration must write no Payment and no Registration: {instances:?}"
         );
     }
@@ -1377,7 +2205,13 @@ mod tests {
     #[tokio::test]
     async fn registrations_route_accepts_a_session_with_no_cutoff_even_when_it_has_a_start() {
         let client = scratch_db("hecks_host_web_test_registrations_cutoff_absent").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
@@ -1385,14 +2219,32 @@ mod tests {
         let now = 1_800_000_000;
         schedule_timed_event(&client, &wasm_path, &config, "no-cutoff", now - 3600, None).await;
 
-        let body = json!({"event_slug": "no-cutoff", "name": "Ada", "email": "ada@example.com"}).to_string();
-        let response = registrations_route_at(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments(), now).await;
+        let body = json!({"event_slug": "no-cutoff", "name": "Ada", "email": "ada@example.com"})
+            .to_string();
+        let response = registrations_route_at(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+            now,
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
-        assert!(instances.keys().any(|k| k.starts_with("CheckoutFixture::Registration#")), "{instances:?}");
-        assert!(instances.keys().any(|k| k.starts_with("Payments::Payment#")), "{instances:?}");
+        assert!(
+            instances
+                .keys()
+                .any(|k| k.starts_with("CheckoutFixture::Registration#")),
+            "{instances:?}"
+        );
+        assert!(
+            instances
+                .keys()
+                .any(|k| k.starts_with("Payments::Payment#")),
+            "{instances:?}"
+        );
     }
 
     #[test]
@@ -1400,13 +2252,34 @@ mod tests {
         let now = 1_000_000;
         let past_start = json!({"starts_at": 0});
         assert!(!registration_cutoff_passed(&json!({}), now));
-        assert!(!registration_cutoff_passed(&past_start, now), "a start with no cutoff hours is no cutoff");
-        assert!(!registration_cutoff_passed(&json!({"registration_cutoff_hours": 48}), now), "hours with no start is no cutoff");
-        assert!(!registration_cutoff_passed(&json!({"starts_at": null, "registration_cutoff_hours": 48}), now));
-        assert!(!registration_cutoff_passed(&json!({"starts_at": 0, "registration_cutoff_hours": null}), now));
-        assert!(!registration_cutoff_passed(&json!({"starts_at": "soon", "registration_cutoff_hours": 48}), now));
-        assert!(!registration_cutoff_passed(&json!({"starts_at": 0, "registration_cutoff_hours": "two"}), now));
-        assert!(!registration_cutoff_passed(&json!({"starts_at": {"value": "soon"}, "registration_cutoff_hours": {"value": 1.5}}), now));
+        assert!(
+            !registration_cutoff_passed(&past_start, now),
+            "a start with no cutoff hours is no cutoff"
+        );
+        assert!(
+            !registration_cutoff_passed(&json!({"registration_cutoff_hours": 48}), now),
+            "hours with no start is no cutoff"
+        );
+        assert!(!registration_cutoff_passed(
+            &json!({"starts_at": null, "registration_cutoff_hours": 48}),
+            now
+        ));
+        assert!(!registration_cutoff_passed(
+            &json!({"starts_at": 0, "registration_cutoff_hours": null}),
+            now
+        ));
+        assert!(!registration_cutoff_passed(
+            &json!({"starts_at": "soon", "registration_cutoff_hours": 48}),
+            now
+        ));
+        assert!(!registration_cutoff_passed(
+            &json!({"starts_at": 0, "registration_cutoff_hours": "two"}),
+            now
+        ));
+        assert!(!registration_cutoff_passed(
+            &json!({"starts_at": {"value": "soon"}, "registration_cutoff_hours": {"value": 1.5}}),
+            now
+        ));
     }
 
     #[test]
@@ -1414,13 +2287,17 @@ mod tests {
         // Cutoff 2 hours before a start of 100_000: the window shuts after 92_800.
         let event = json!({"starts_at": 100_000, "registration_cutoff_hours": 2});
         assert!(!registration_cutoff_passed(&event, 92_799));
-        assert!(!registration_cutoff_passed(&event, 92_800), "exactly at the cutoff is still open");
+        assert!(
+            !registration_cutoff_passed(&event, 92_800),
+            "exactly at the cutoff is still open"
+        );
         assert!(registration_cutoff_passed(&event, 92_801));
     }
 
     #[test]
     fn a_registration_cutoff_reads_a_value_object_or_a_bare_number() {
-        let wrapped = json!({"starts_at": {"value": 100_000}, "registration_cutoff_hours": {"value": 2}});
+        let wrapped =
+            json!({"starts_at": {"value": 100_000}, "registration_cutoff_hours": {"value": 2}});
         let bare = json!({"starts_at": 100_000, "registration_cutoff_hours": 2});
         let mixed = json!({"starts_at": {"value": 100_000}, "registration_cutoff_hours": 2});
         for event in [wrapped, bare, mixed] {
@@ -1444,14 +2321,27 @@ mod tests {
         // Payment.Initiate before Registration.Request is ever reached,
         // proving the refusal is the real domain rule.
         let client = scratch_db("hecks_host_web_test_registrations_zero_price").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         schedule_event(&client, &wasm_path, &config, "free-event", 0).await;
 
-        let body = json!({"event_slug": "free-event", "name": "Ada", "email": "ada@example.com"}).to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let body = json!({"event_slug": "free-event", "name": "Ada", "email": "ada@example.com"})
+            .to_string();
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 422);
         assert!(
             response["body"].as_str().unwrap().contains("positive"),
@@ -1462,13 +2352,23 @@ mod tests {
         // Registration.Request must never have been dispatched at all.
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
-        assert!(instances.keys().all(|k| !k.starts_with("CheckoutFixture::Registration#") && !k.starts_with("Payments::Payment#")));
+        assert!(instances
+            .keys()
+            .all(|k| !k.starts_with("CheckoutFixture::Registration#")
+                && !k.starts_with("Payments::Payment#")));
     }
 
     #[tokio::test]
-    async fn registrations_route_runs_the_whole_dispatch_chain_and_returns_a_real_mock_checkout_url() {
+    async fn registrations_route_runs_the_whole_dispatch_chain_and_returns_a_real_mock_checkout_url(
+    ) {
         let client = scratch_db("hecks_host_web_test_registrations_happy_path").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
@@ -1478,7 +2378,13 @@ mod tests {
         // a misconfiguration — the whole chain runs and returns a real
         // checkout URL, never a 500.
         let body = json!({"event_slug": "happy-event", "name": "Ada Lovelace", "email": "ada@example.com"}).to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
         let body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
         let reference = body["registration_id"].as_str().unwrap().to_string();
@@ -1494,10 +2400,22 @@ mod tests {
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let instances = read["instances"].as_object().unwrap();
-        let registration = instances.iter().find(|(k, _)| k.starts_with("CheckoutFixture::Registration#")).map(|(_, v)| v);
-        let payment = instances.iter().find(|(k, _)| k.starts_with("Payments::Payment#")).map(|(_, v)| v);
-        assert!(registration.is_some(), "Registration.Request should have committed for real: {instances:?}");
-        assert!(payment.is_some(), "Payment.Initiate should have committed for real: {instances:?}");
+        let registration = instances
+            .iter()
+            .find(|(k, _)| k.starts_with("CheckoutFixture::Registration#"))
+            .map(|(_, v)| v);
+        let payment = instances
+            .iter()
+            .find(|(k, _)| k.starts_with("Payments::Payment#"))
+            .map(|(_, v)| v);
+        assert!(
+            registration.is_some(),
+            "Registration.Request should have committed for real: {instances:?}"
+        );
+        assert!(
+            payment.is_some(),
+            "Payment.Initiate should have committed for real: {instances:?}"
+        );
 
         let registration = registration.unwrap();
         let payment = payment.unwrap();
@@ -1520,7 +2438,13 @@ mod tests {
     #[tokio::test]
     async fn registrations_route_redirects_to_the_caller_s_own_return_to_not_the_event_slug() {
         let client = scratch_db("hecks_host_web_test_registrations_return_to").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
@@ -1533,7 +2457,13 @@ mod tests {
             "return_to": "/sample-studio.html",
         })
         .to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
         let body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
         let reference = body["registration_id"].as_str().unwrap().to_string();
@@ -1550,7 +2480,13 @@ mod tests {
     #[tokio::test]
     async fn registrations_route_refuses_an_absolute_or_protocol_relative_return_to() {
         let client = scratch_db("hecks_host_web_test_registrations_return_to_unsafe").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
@@ -1564,7 +2500,13 @@ mod tests {
                 "return_to": unsafe_return_to,
             })
             .to_string();
-            let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+            let response = registrations_route(
+                &body,
+                &payments::test_platform(),
+                Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+                &crate::commerce_ir::fixture_payments(),
+            )
+            .await;
             assert_eq!(response["statusCode"], 200, "{response:?}");
             let body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
             // checkout_url is the /pay/<id>.html walkthrough page; return_to
@@ -1572,7 +2514,11 @@ mod tests {
             // it) so it shows up as "%252F".
             let checkout_url = body["checkout_url"].as_str().unwrap();
             let parsed = reqwest::Url::parse(checkout_url).unwrap();
-            let success_url = parsed.query_pairs().find(|(k, _)| k == "success_url").map(|(_, v)| v.into_owned()).unwrap_or_default();
+            let success_url = parsed
+                .query_pairs()
+                .find(|(k, _)| k == "success_url")
+                .map(|(_, v)| v.into_owned())
+                .unwrap_or_default();
             assert!(
                 success_url.ends_with("return_to=%2F"),
                 "an unsafe return_to ({unsafe_return_to:?}) must fall back to \"/\": {body:?}"
@@ -1586,17 +2532,33 @@ mod tests {
         // checkout_url, then a webhook signed against the same mock secret
         // webhook_route falls back to while STRIPE_WEBHOOK_SECRET is unset.
         let client = scratch_db("hecks_host_web_test_mock_full_loop").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         schedule_event(&client, &wasm_path, &config, "mock-loop-event", 4200).await;
 
         let body = json!({"event_slug": "mock-loop-event", "name": "Ada Lovelace", "email": "ada@example.com"}).to_string();
-        let response = registrations_route(&body, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = registrations_route(
+            &body,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
-        let response_body: Value = serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
-        let reference = response_body["registration_id"].as_str().unwrap().to_string();
+        let response_body: Value =
+            serde_json::from_str(response["body"].as_str().unwrap()).unwrap();
+        let reference = response_body["registration_id"]
+            .as_str()
+            .unwrap()
+            .to_string();
 
         let secret = MOCK_STRIPE_WEBHOOK_SECRET;
         let payload = json!({
@@ -1606,44 +2568,82 @@ mod tests {
         let now = now_secs();
         let header = sign_stripe_header(secret, now, &payload);
 
-        let response = webhook_route(&payload, &header, &payments::test_platform(), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = webhook_route(
+            &payload,
+            &header,
+            &payments::test_platform(),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
         let payment = &read["instances"][format!("Payments::Payment#{reference}")];
         assert_eq!(payment["status"], "succeeded");
-        assert_eq!(payment["transaction_id"]["value"], format!("cs_manual_{reference}"));
+        assert_eq!(
+            payment["transaction_id"]["value"],
+            format!("cs_manual_{reference}")
+        );
     }
 
     #[tokio::test]
     async fn webhook_route_rejects_a_bad_signature_before_touching_the_domain_at_all() {
         let client = scratch_db("hecks_host_web_test_webhook_bad_sig").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
 
-        let payload = json!({"type": "checkout.session.completed", "data": {"object": {}}}).to_string();
+        let payload =
+            json!({"type": "checkout.session.completed", "data": {"object": {}}}).to_string();
         let bad_header = "t=1700000000,v1=deadbeef";
 
-        let response = webhook_route(&payload, bad_header, &payments::test_platform_with_secret("whsec_test_bad_sig"), &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = webhook_route(
+            &payload,
+            bad_header,
+            &payments::test_platform_with_secret("whsec_test_bad_sig"),
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 400);
     }
 
     #[tokio::test]
     async fn webhook_route_settles_a_payment_on_checkout_session_completed() {
         let client = scratch_db("hecks_host_web_test_webhook_completed").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         schedule_event(&client, &wasm_path, &config, "webhook-event", 4200).await;
         let initiate = dispatch::handle(
-            &client, &wasm_path, "Payments::Payment.Initiate",
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            "Payments::Payment.Initiate",
             json!({
                 "reference": {"value": "REG-WEBHOOK-1"}, "processor": {"value": "stripe"},
                 "payment_type": {"value": "card"}, "amount": {"cents": 4200},
                 "client": {"name": "Ada Lovelace", "email": "ada@example.com"},
             }),
-            None, &config, &lambda_client::NeverInvoker,
-        ).await.unwrap();
+            None,
+        )
+        .await
+        .unwrap();
         assert!(initiate.accepted, "{:?}", initiate.result);
 
         let secret = "whsec_test_completed";
@@ -1654,7 +2654,14 @@ mod tests {
         let now = now_secs();
         let header = sign_stripe_header(secret, now, &payload);
 
-        let response = webhook_route(&payload, &header, &payments::test_platform_with_secret(secret), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = webhook_route(
+            &payload,
+            &header,
+            &payments::test_platform_with_secret(secret),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
@@ -1665,37 +2672,64 @@ mod tests {
         // A redelivered webhook (Stripe's delivery is at-least-once) for an
         // already-succeeded payment must still answer 200 — the refusal
         // underneath is a benign no-op, not surfaced as an error.
-        let redelivered = webhook_route(&payload, &header, &payments::test_platform_with_secret(secret), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let redelivered = webhook_route(
+            &payload,
+            &header,
+            &payments::test_platform_with_secret(secret),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(redelivered["statusCode"], 200, "a redelivered webhook must not surface the resulting refusal as an error: {redelivered:?}");
     }
 
     #[tokio::test]
     async fn webhook_route_declines_a_payment_on_checkout_session_expired() {
         let client = scratch_db("hecks_host_web_test_webhook_expired").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
         let config = checkout_config(1);
         let wasm_path = checkout_wasm_path();
 
         schedule_event(&client, &wasm_path, &config, "webhook-event-2", 4200).await;
         dispatch::handle(
-            &client, &wasm_path, "Payments::Payment.Initiate",
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            "Payments::Payment.Initiate",
             json!({
                 "reference": {"value": "REG-WEBHOOK-2"}, "processor": {"value": "stripe"},
                 "payment_type": {"value": "card"}, "amount": {"cents": 4200},
                 "client": {"name": "Ada Lovelace", "email": "ada@example.com"},
             }),
-            None, &config, &lambda_client::NeverInvoker,
-        ).await.unwrap().accepted.then_some(()).expect("initiate should succeed");
+            None,
+        )
+        .await
+        .unwrap()
+        .accepted
+        .then_some(())
+        .expect("initiate should succeed");
 
         let secret = "whsec_test_expired";
         let payload = json!({
             "type": "checkout.session.expired",
             "data": {"object": {"metadata": {"registration_id": "REG-WEBHOOK-2"}}},
-        }).to_string();
+        })
+        .to_string();
         let now = now_secs();
         let header = sign_stripe_header(secret, now, &payload);
 
-        let response = webhook_route(&payload, &header, &payments::test_platform_with_secret(secret), &client, &wasm_path, &config, &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = webhook_route(
+            &payload,
+            &header,
+            &payments::test_platform_with_secret(secret),
+            Host::new(&client, &wasm_path, &config, &lambda_client::NeverInvoker),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200, "{response:?}");
 
         let read = dispatch::read(&client, &wasm_path).await.unwrap();
@@ -1707,14 +2741,32 @@ mod tests {
     #[tokio::test]
     async fn webhook_route_ignores_an_event_type_it_does_not_handle_and_still_answers_200() {
         let client = scratch_db("hecks_host_web_test_webhook_unhandled_type").await;
-        provision_lineage(&*client.lock().await, "CheckoutFixture", 1, &["Event", "Registration", "Payment"]).await;
+        provision_lineage(
+            &*client.lock().await,
+            "CheckoutFixture",
+            1,
+            &["Event", "Registration", "Payment"],
+        )
+        .await;
 
         let secret = "whsec_test_unhandled";
         let payload = json!({"type": "charge.refunded", "data": {"object": {"metadata": {"registration_id": "whatever"}}}}).to_string();
         let now = now_secs();
         let header = sign_stripe_header(secret, now, &payload);
 
-        let response = webhook_route(&payload, &header, &payments::test_platform_with_secret(secret), &client, &checkout_wasm_path(), &checkout_config(1), &lambda_client::NeverInvoker, &crate::commerce_ir::fixture_payments()).await;
+        let response = webhook_route(
+            &payload,
+            &header,
+            &payments::test_platform_with_secret(secret),
+            Host::new(
+                &client,
+                &checkout_wasm_path(),
+                &checkout_config(1),
+                &lambda_client::NeverInvoker,
+            ),
+            &crate::commerce_ir::fixture_payments(),
+        )
+        .await;
         assert_eq!(response["statusCode"], 200);
     }
 }