@crowdedkingdoms/ckx-kit 0.3.0-dev.1 → 0.5.0-dev.1

package/crates/ckx-sdk/src/kit/econ/progression.rs

@@ -0,0 +1,254 @@
+//! Levels from experience ([`Levels`], [`Progress`]); achievements and quests that count what a
+//! player did ([`AchievementDef`], [`QuestDef`], [`Record`]).
+//!
+//! What a player did reaches the record as counters (`wins`, `kill:wolf`, `crafted:plank`).
+//! A hub that decided it reports it; a counter a game lets the client report itself (a
+//! tutorial step) is for things worth nothing.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use serde::{Deserialize, Serialize};
+
+use super::holdings::Bundle;
+use crate::Result;
+use crate::kit::{codes, error};
+
+/// Experience to go from level `n` to `n + 1` is `base * growth^(n - 1)`, up to `max`.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct Levels {
+    pub base: u64,
+    pub growth: f64,
+    pub max: u32,
+}
+
+impl Default for Levels {
+    fn default() -> Self {
+        Self { base: 100, growth: 1.5, max: 50 }
+    }
+}
+
+impl Levels {
+    /// What level `level` takes to finish; `None` at the top.
+    pub fn to_next(&self, level: u32) -> Option<u64> {
+        if level >= self.max {
+            return None;
+        }
+        let need = self.base as f64 * self.growth.max(1.0).powi(level.saturating_sub(1) as i32);
+        Some(need.min(u64::MAX as f64).round().max(1.0) as u64)
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+#[serde(default)]
+pub struct Progress {
+    pub level: u32,
+    /// Toward the next level.
+    pub xp: u64,
+    pub total_xp: u64,
+}
+
+impl Default for Progress {
+    fn default() -> Self {
+        Self { level: 1, xp: 0, total_xp: 0 }
+    }
+}
+
+impl Progress {
+    /// Adds experience; answers how many levels it gained.
+    pub fn gain(&mut self, levels: &Levels, xp: u64) -> u32 {
+        self.total_xp = self.total_xp.saturating_add(xp);
+        self.xp = self.xp.saturating_add(xp);
+        let mut gained = 0;
+        while let Some(need) = levels.to_next(self.level) {
+            if self.xp < need {
+                break;
+            }
+            self.xp -= need;
+            self.level += 1;
+            gained += 1;
+        }
+        if levels.to_next(self.level).is_none() {
+            self.xp = 0;
+        }
+        gained
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct AchievementDef {
+    pub id: String,
+    pub counter: String,
+    pub target: u64,
+    #[serde(default)]
+    pub reward: Bundle,
+    #[serde(default)]
+    pub xp: u64,
+    /// Not shown until unlocked.
+    #[serde(default)]
+    pub hidden: bool,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Objective {
+    pub counter: String,
+    pub target: u64,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct QuestDef {
+    pub id: String,
+    pub objectives: Vec<Objective>,
+    #[serde(default)]
+    pub reward: Bundle,
+    #[serde(default)]
+    pub xp: u64,
+    /// Quests done first.
+    #[serde(default)]
+    pub requires: Vec<String>,
+    #[serde(default)]
+    pub level: u32,
+    /// A first-session tutorial: taken on as the player starts.
+    #[serde(default)]
+    pub tutorial: bool,
+}
+
+/// What a player did and what it earned them.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(default)]
+pub struct Record {
+    pub counters: BTreeMap<String, u64>,
+    /// Achievement to when it unlocked.
+    pub unlocked: BTreeMap<String, u64>,
+    /// Quest taken on, to each objective's count since.
+    pub active: BTreeMap<String, Vec<u64>>,
+    /// Done, waiting for its reward to be claimed.
+    pub complete: BTreeSet<String>,
+    /// Claimed, to when.
+    pub done: BTreeMap<String, u64>,
+}
+
+/// What one count changed.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(default)]
+pub struct Unlocks {
+    pub achievements: Vec<String>,
+    pub quests: Vec<String>,
+}
+
+impl Record {
+    /// Counts `n` of `counter`: the achievements it unlocks and the quests it completes.
+    pub fn count(&mut self, achievements: &[AchievementDef], quests: &[QuestDef], counter: &str, n: u64, now: u64) -> Unlocks {
+        let mut out = Unlocks::default();
+        let total = self.counters.entry(counter.to_owned()).or_insert(0);
+        *total = total.saturating_add(n);
+        let total = *total;
+        for a in achievements.iter().filter(|a| a.counter == counter && total >= a.target) {
+            if !self.unlocked.contains_key(&a.id) {
+                self.unlocked.insert(a.id.clone(), now);
+                out.achievements.push(a.id.clone());
+            }
+        }
+        for q in quests {
+            let Some(counts) = self.active.get_mut(&q.id) else { continue };
+            for (i, o) in q.objectives.iter().enumerate() {
+                if o.counter == counter
+                    && let Some(c) = counts.get_mut(i)
+                {
+                    *c = (*c).saturating_add(n).min(o.target);
+                }
+            }
+            if q.objectives.iter().zip(counts.iter()).all(|(o, c)| *c >= o.target) {
+                self.active.remove(&q.id);
+                self.complete.insert(q.id.clone());
+                out.quests.push(q.id.clone());
+            }
+        }
+        out
+    }
+
+    /// Takes on quest `q`: `conflict` when it is taken, done or waits for another, `forbidden`
+    /// below its level.
+    pub fn accept(&mut self, q: &QuestDef, level: u32) -> Result<()> {
+        if self.active.contains_key(&q.id) || self.complete.contains(&q.id) || self.done.contains_key(&q.id) {
+            return Err(error(codes::CONFLICT, format!("`{}` is taken or done", q.id)));
+        }
+        if let Some(missing) = q.requires.iter().find(|r| !self.done.contains_key(*r)) {
+            return Err(error(codes::CONFLICT, format!("`{}` comes after `{missing}`", q.id)));
+        }
+        if level < q.level {
+            return Err(error(codes::FORBIDDEN, format!("`{}` needs level {}", q.id, q.level)));
+        }
+        self.active.insert(q.id.clone(), vec![0; q.objectives.len()]);
+        Ok(())
+    }
+
+    /// Claims quest `id`'s reward: `not_ready` until it is complete.
+    pub fn claim(&mut self, id: &str, now: u64) -> Result<()> {
+        if !self.complete.remove(id) {
+            return Err(error(codes::NOT_READY, format!("`{id}` is not complete")));
+        }
+        self.done.insert(id.to_owned(), now);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn experience_levels_up_along_the_curve_and_stops_at_the_top() {
+        let levels = Levels { base: 100, growth: 2.0, max: 3 };
+        let mut p = Progress::default();
+        assert_eq!(p.gain(&levels, 250), 1);
+        assert_eq!((p.level, p.xp), (2, 150));
+        assert_eq!(levels.to_next(2), Some(200));
+        assert_eq!(p.gain(&levels, 1_000), 1);
+        assert_eq!((p.level, p.xp, p.total_xp), (3, 0, 1_250), "the top keeps no progress");
+    }
+
+    #[test]
+    fn counts_unlock_achievements_once_and_complete_quests_taken_on() {
+        let achievements = vec![AchievementDef {
+            id: "lumberjack".into(),
+            counter: "chop".into(),
+            target: 3,
+            reward: Bundle::default(),
+            xp: 0,
+            hidden: false,
+        }];
+        let quests = vec![
+            QuestDef {
+                id: "first".into(),
+                objectives: vec![Objective { counter: "chop".into(), target: 2 }],
+                reward: Bundle::coins("gold", 5),
+                xp: 10,
+                requires: vec![],
+                level: 0,
+                tutorial: true,
+            },
+            QuestDef {
+                id: "second".into(),
+                objectives: vec![Objective { counter: "chop".into(), target: 1 }],
+                reward: Bundle::default(),
+                xp: 0,
+                requires: vec!["first".into()],
+                level: 0,
+                tutorial: false,
+            },
+        ];
+        let mut r = Record::default();
+        r.count(&achievements, &quests, "chop", 1, 0);
+        r.accept(&quests[0], 1).unwrap();
+        assert!(r.accept(&quests[1], 1).is_err(), "after the first");
+        assert_eq!(r.count(&achievements, &quests, "chop", 1, 1).quests, Vec::<String>::new(), "counts from when it was taken on");
+        let u = r.count(&achievements, &quests, "chop", 5, 2);
+        assert_eq!((u.achievements, u.quests), (vec!["lumberjack".to_string()], vec!["first".to_string()]));
+        assert!(r.count(&achievements, &quests, "chop", 1, 3).achievements.is_empty(), "unlocked once");
+        assert!(r.claim("second", 4).is_err());
+        r.claim("first", 4).unwrap();
+        assert!(r.claim("first", 5).is_err(), "claimed once");
+        r.accept(&quests[1], 1).unwrap();
+    }
+}

package/crates/ckx-sdk/src/kit/econ/recipes.rs

@@ -0,0 +1,65 @@
+//! Crafting: a recipe takes its inputs (items, and currency for a fee) and gives its outputs,
+//! all together or not at all.
+
+use serde::{Deserialize, Serialize};
+
+use super::holdings::{Bundle, Holdings};
+use super::items::Catalog;
+use crate::Result;
+use crate::kit::{codes, error};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Recipe {
+    pub id: String,
+    pub inputs: Bundle,
+    pub outputs: Bundle,
+    /// The level a player needs; 0 for none.
+    #[serde(default)]
+    pub level: u32,
+}
+
+/// The most crafts one call makes.
+pub const CRAFT_MAX: u64 = 100;
+
+/// Crafts `recipe` `times` times into `holdings`; answers what it made. `insufficient` without
+/// the inputs, `full` without room for the outputs (the inputs' room counts, since they go
+/// first), `forbidden` below the recipe's level.
+pub fn craft(holdings: &mut Holdings, catalog: &Catalog, recipe: &Recipe, times: u64, level: u32) -> Result<Bundle> {
+    if times == 0 || times > CRAFT_MAX {
+        return Err(error(codes::BAD_REQUEST, format!("1 to {CRAFT_MAX} at a time")));
+    }
+    if level < recipe.level {
+        return Err(error(codes::FORBIDDEN, format!("`{}` needs level {}", recipe.id, recipe.level)));
+    }
+    let made = recipe.outputs.times(times)?;
+    holdings.swap(catalog, &recipe.inputs.times(times)?, &made)?;
+    Ok(made)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::kit::econ::items::ItemDef;
+
+    #[test]
+    fn a_craft_takes_its_inputs_and_gives_its_outputs_or_nothing() {
+        let c = Catalog::from(vec![
+            ItemDef { id: "wood".into(), max_stack: 20, tradable: true, name: String::new() },
+            ItemDef { id: "plank".into(), max_stack: 20, tradable: true, name: String::new() },
+        ]);
+        let plank = Recipe {
+            id: "plank".into(),
+            inputs: Bundle::item("wood", 2).plus(&Bundle::coins("gold", 1)).unwrap(),
+            outputs: Bundle::item("plank", 1),
+            level: 0,
+        };
+        let mut h = Holdings::new(2);
+        h.give(&c, &Bundle::item("wood", 5).plus(&Bundle::coins("gold", 2)).unwrap()).unwrap();
+        assert_eq!(craft(&mut h, &c, &plank, 2, 1).unwrap(), Bundle::item("plank", 2));
+        assert_eq!((h.inventory.count("wood"), h.inventory.count("plank"), h.wallet.balance("gold")), (1, 2, 0));
+        let before = h.clone();
+        assert!(craft(&mut h, &c, &plank, 1, 1).is_err(), "out of wood and gold");
+        assert_eq!(h, before);
+        assert!(craft(&mut h, &c, &Recipe { level: 3, ..plank.clone() }, 1, 2).is_err());
+    }
+}

package/crates/ckx-sdk/src/kit/econ/vendor.rs

@@ -0,0 +1,116 @@
+//! Vendors: offers at fixed prices, each with stock that restocks and a limit per player.
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+
+use super::holdings::Bundle;
+use crate::Result;
+use crate::kit::{codes, error};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Offer {
+    pub item: String,
+    /// What one costs.
+    pub price: Bundle,
+    /// How many a restock puts on the shelf; none for no limit.
+    #[serde(default)]
+    pub stock: Option<u64>,
+    /// How many one player may buy between restocks; none for no limit.
+    #[serde(default)]
+    pub per_player: Option<u64>,
+    /// What the vendor pays for one; none when it does not buy them.
+    #[serde(default)]
+    pub buys_for: Option<Bundle>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub struct Vendor {
+    pub id: String,
+    pub offers: Vec<Offer>,
+    /// When it restocks (cron), or never.
+    #[serde(default)]
+    pub restock: Option<String>,
+}
+
+/// A vendor's shelf and who bought what since the last restock.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(default)]
+pub struct Shelf {
+    pub stock: BTreeMap<String, u64>,
+    /// `"<player>:<item>"` to how many.
+    pub bought: BTreeMap<String, u64>,
+    pub restocked_at: u64,
+}
+
+impl Vendor {
+    pub fn offer(&self, item: &str) -> Result<&Offer> {
+        self.offers.iter().find(|o| o.item == item).ok_or_else(|| error(codes::NOT_FOUND, format!("`{}` sells no `{item}`", self.id)))
+    }
+}
+
+impl Shelf {
+    pub fn restock(&mut self, vendor: &Vendor, now: u64) {
+        self.stock = vendor.offers.iter().filter_map(|o| o.stock.map(|s| (o.item.clone(), s))).collect();
+        self.bought.clear();
+        self.restocked_at = now;
+    }
+
+    /// Whether `player` may buy `count` of `offer` now: `insufficient` (stock), `limit`.
+    pub fn check(&self, offer: &Offer, player: u64, count: u64) -> Result<()> {
+        if count == 0 {
+            return Err(error(codes::BAD_REQUEST, "buy at least one"));
+        }
+        if offer.stock.is_some() && self.stock.get(&offer.item).copied().unwrap_or(0) < count {
+            return Err(error(codes::INSUFFICIENT, format!("not {count} {} in stock", offer.item)));
+        }
+        if let Some(cap) = offer.per_player
+            && self.bought.get(&format!("{player}:{}", offer.item)).copied().unwrap_or(0) + count > cap
+        {
+            return Err(error(codes::LIMIT, format!("{cap} {} a player until the restock", offer.item)));
+        }
+        Ok(())
+    }
+
+    /// Records a sale `check` allowed.
+    pub fn sold(&mut self, offer: &Offer, player: u64, count: u64) {
+        if offer.stock.is_some()
+            && let Some(s) = self.stock.get_mut(&offer.item)
+        {
+            *s = s.saturating_sub(count);
+        }
+        *self.bought.entry(format!("{player}:{}", offer.item)).or_insert(0) += count;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stock_and_a_per_player_limit_hold_until_the_restock() {
+        let v = Vendor {
+            id: "smith".into(),
+            offers: vec![Offer {
+                item: "sword".into(),
+                price: Bundle::coins("gold", 50),
+                stock: Some(2),
+                per_player: Some(1),
+                buys_for: None,
+            }],
+            restock: None,
+        };
+        let mut shelf = Shelf::default();
+        shelf.restock(&v, 1);
+        let o = v.offer("sword").unwrap();
+        shelf.check(o, 1, 1).unwrap();
+        shelf.sold(o, 1, 1);
+        assert!(shelf.check(o, 1, 1).is_err(), "one a player");
+        shelf.check(o, 2, 1).unwrap();
+        shelf.sold(o, 2, 1);
+        assert!(shelf.check(o, 3, 1).is_err(), "sold out");
+        shelf.restock(&v, 2);
+        shelf.check(o, 1, 1).unwrap();
+        assert!(v.offer("shield").is_err());
+    }
+}

package/crates/ckx-sdk/src/kit/econ/wallet.rs

@@ -0,0 +1,67 @@
+//! Soft currencies: balances that never go below zero.
+
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::Result;
+use crate::kit::{codes, error};
+
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+pub struct Wallet {
+    pub balances: BTreeMap<String, i64>,
+}
+
+impl Wallet {
+    pub fn balance(&self, currency: &str) -> i64 {
+        self.balances.get(currency).copied().unwrap_or(0)
+    }
+
+    /// Adds `amount`; answers the balance. `bad_request` for a negative amount, `limit` past
+    /// the largest balance.
+    pub fn credit(&mut self, currency: &str, amount: i64) -> Result<i64> {
+        if amount < 0 {
+            return Err(error(codes::BAD_REQUEST, "an amount is not negative"));
+        }
+        let now = self.balance(currency).checked_add(amount).ok_or_else(|| error(codes::LIMIT, format!("{currency} would overflow")))?;
+        if now > 0 {
+            self.balances.insert(currency.to_owned(), now);
+        }
+        Ok(now)
+    }
+
+    /// Takes `amount`; answers the balance. `insufficient` when there is not that much.
+    pub fn debit(&mut self, currency: &str, amount: i64) -> Result<i64> {
+        if amount < 0 {
+            return Err(error(codes::BAD_REQUEST, "an amount is not negative"));
+        }
+        let have = self.balance(currency);
+        if have < amount {
+            return Err(error(codes::INSUFFICIENT, format!("not {amount} {currency}")));
+        }
+        let now = have - amount;
+        if now == 0 {
+            self.balances.remove(currency);
+        } else {
+            self.balances.insert(currency.to_owned(), now);
+        }
+        Ok(now)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_balance_never_goes_below_zero() {
+        let mut w = Wallet::default();
+        assert_eq!(w.credit("gold", 30).unwrap(), 30);
+        assert!(w.debit("gold", 31).is_err());
+        assert_eq!(w.debit("gold", 30).unwrap(), 0);
+        assert!(w.balances.is_empty(), "an empty balance is not kept");
+        assert!(w.credit("gold", -1).is_err());
+        w.credit("gold", i64::MAX).unwrap();
+        assert!(w.credit("gold", 1).is_err(), "no overflow");
+    }
+}

package/crates/ckx-sdk/src/kit/mod.rs

@@ -28,7 +28,9 @@
 //! answer instead of running twice.
 //!
 //! A refusal's message starts with a code, `kit:<code>: <text>` ([`error`], [`error_code`]),
-//! which clients branch on without reading prose. [`codes`] has the common ones.
+//! which clients branch on without reading prose. [`codes`] has the common ones. One of them,
+//! [`codes::UNAVAILABLE`], says the call needed another hub that did not answer: receipts never
+//! keep it, so the call runs again when it is sent again with its `action_id`.
 //!
 //! ```ignore
 //! use ckx_sdk::kit::{self, MessageKind, Publisher, Receipts};
@@ -60,8 +62,13 @@ use serde::{Deserialize, Serialize};
 use crate::model::{Model, Published, Schema, Viewer};
 use crate::{Call, Caller, Ctx, Error, Result, decode, encode};
 
+pub mod ai;
+pub mod econ;
+pub mod play;
+pub mod presence;
 pub mod rng;
 pub mod shard;
+pub mod sim;
 pub mod wire;
 
 pub use rng::Rng;
@@ -131,8 +138,19 @@ struct Outgoing<'a, T: ?Sized> {
     body: &'a T,
 }
 
-/// Encodes one kit message from this instance. `body` must serialize as a struct or a map.
+/// The fields a kit message's header owns; a body may not use them (they sit side by side).
+pub const RESERVED_FIELDS: [&str; 4] = ["v", "epoch", "seq", "kind"];
+
+/// Encodes one kit message from this instance. `body` must serialize as a struct or a map, and
+/// none of its fields may be one of [`RESERVED_FIELDS`]: a debug build (`cargo test`) refuses a
+/// body that uses one, which would leave a client two `kind`s to choose from.
 pub fn message<T: Serialize + ?Sized>(ctx: &Ctx, kind: MessageKind, seq: u64, body: &T) -> Result<Vec<u8>> {
+    #[cfg(debug_assertions)]
+    if let Ok(fields) = decode::<BTreeMap<String, serde::de::IgnoredAny>>(&encode(body)?)
+        && let Some(taken) = RESERVED_FIELDS.iter().find(|f| fields.contains_key(**f))
+    {
+        return Err(Error::new(format!("a kit message's body may not have a field `{taken}`: the header owns it")));
+    }
     let header = Header { v: PROTOCOL, epoch: ctx.epoch, seq, kind };
     encode(&Outgoing { header, body })
 }
@@ -237,6 +255,15 @@ pub fn args<T: DeserializeOwned>(call: &Call<'_>) -> Result<T> {
     decode(call.payload).map_err(|Error(e)| error(codes::BAD_REQUEST, format!("`{}`: {e}", call.method)))
 }
 
+/// A call's arguments when it may send none: an empty payload or a nil (what a client sends for
+/// no arguments) is `T::default()`.
+pub fn args_or_default<T: DeserializeOwned + Default>(call: &Call<'_>) -> Result<T> {
+    match call.payload {
+        [] | [0xc0] => Ok(T::default()),
+        _ => args(call),
+    }
+}
+
 // ---- refusals ----
 
 /// The refusal codes kit hubs share. A hub may add its own: lowercase letters, digits and `_`.
@@ -266,6 +293,9 @@ pub mod codes {
     pub const INSUFFICIENT: &str = "insufficient";
     /// The action already ran; its reply was too large to keep ([`super::RECEIPT_REPLY_MAX`]).
     pub const ALREADY_DONE: &str = "already_done";
+    /// Another hub this call needs did not answer in time, so the call did not finish: send it
+    /// again with the same `action_id`. Receipts never keep it.
+    pub const UNAVAILABLE: &str = "unavailable";
 }
 
 /// A refusal with a code: its message is `kit:<code>: <text>`.
@@ -358,9 +388,15 @@ impl Receipts {
         })
     }
 
-    /// Keeps what `caller` got for `action_id`; nothing without an action id.
+    /// Keeps what `caller` got for `action_id`; nothing without an action id, and nothing for a
+    /// refusal coded [`codes::UNAVAILABLE`], which says the action did not finish.
     pub fn record(&mut self, caller: Caller, action_id: Option<&str>, result: &Result<Vec<u8>>, now: u64) {
         let (Some(who), Some(id)) = (caller_key(caller), action_id) else { return };
+        if let Err(Error(message)) = result
+            && error_code(message).is_some_and(|(c, _)| c == codes::UNAVAILABLE)
+        {
+            return;
+        }
         while self.kept.front().is_some_and(|r| now.saturating_sub(r.at) >= RECEIPT_TTL_MS) || self.kept.len() >= RECEIPTS_MAX {
             self.kept.pop_front();
         }
@@ -417,6 +453,22 @@ mod tests {
         assert!(message(&ctx(), MessageKind::Event, 1, &vec![1u8]).is_err(), "a body is a struct or a map");
     }
 
+    #[test]
+    fn a_refusal_coded_unavailable_is_not_a_receipt() {
+        let mut r = Receipts::new();
+        r.record(Caller::Player(1), Some("a1"), &Err(error(codes::UNAVAILABLE, "the player's hub did not answer")), 0);
+        assert!(r.replay(Caller::Player(1), Some("a1"), 1).is_none(), "sent again, it runs again");
+        r.record(Caller::Player(1), Some("a1"), &Err(error(codes::INSUFFICIENT, "not enough gold")), 2);
+        assert!(r.replay(Caller::Player(1), Some("a1"), 3).is_some(), "a refusal that ran is kept");
+    }
+
+    #[test]
+    fn a_body_may_not_use_a_field_the_header_owns() {
+        let e = message(&ctx(), MessageKind::Event, 1, &serde_json::json!({ "type": "timing", "kind": "lap" })).unwrap_err();
+        assert!(e.0.contains("`kind`"), "{}", e.0);
+        assert!(message(&ctx(), MessageKind::Event, 1, &serde_json::json!({ "type": "timing", "stage": "lap" })).is_ok());
+    }
+
     #[test]
     fn each_topic_counts_its_own_messages_and_a_snapshot_reply_names_the_last() {
         let mut p = Publisher::new();
@@ -480,6 +532,23 @@ mod tests {
         assert!(Receipts::action_id(&encode(&Act { points: 1, action_id: &long }).unwrap()).is_err());
     }
 
+    #[test]
+    fn no_arguments_are_the_defaults_and_bad_ones_are_a_bad_request() {
+        #[derive(Deserialize, Default, Debug, PartialEq)]
+        #[serde(default)]
+        struct Open {
+            seed: Option<u64>,
+        }
+        let call = |payload: &'static [u8]| Call { caller: Caller::Player(1), method: "open", payload };
+        assert_eq!(args_or_default::<Open>(&call(&[])).unwrap(), Open::default());
+        assert_eq!(args_or_default::<Open>(&call(&[0xc0])).unwrap(), Open::default());
+        let given = encode(&serde_json::json!({ "seed": 4 })).unwrap();
+        let c = Call { caller: Caller::Player(1), method: "open", payload: &given };
+        assert_eq!(args_or_default::<Open>(&c).unwrap(), Open { seed: Some(4) });
+        let Error(e) = args_or_default::<Open>(&call(&[0x05])).unwrap_err();
+        assert_eq!(error_code(&e).map(|c| c.0), Some(codes::BAD_REQUEST));
+    }
+
     #[test]
     fn a_collection_snapshot_holds_every_public_view() {
         let schema = Schema::new()