@crowdedkingdoms/ckx-kit 0.4.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};
@@ -61,6 +63,7 @@ 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;
@@ -290,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>`.
@@ -382,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();
         }
@@ -441,6 +453,15 @@ 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();

package/crates/ckx-sdk/src/lib.rs

@@ -47,7 +47,8 @@
 //!
 //! [`kit`] is the game kit's half here: the protocol kit hubs speak to the kit clients
 //! (snapshots and deltas with sequence numbers, retry-safe actions, refusal codes), shard keys,
-//! a seeded random generator, and the realtime event registry.
+//! a seeded random generator, the realtime event registry, and the pieces games are made of
+//! (`kit::play`, `kit::sim`, `kit::ai`, and the soft economy in `kit::econ`).
 
 mod abi;
 pub mod cron;

package/dist/cli/src/new.js

@@ -24,6 +24,8 @@ exports.TEMPLATES = {
     arena: { dir: ['starters', 'arena'], sdk: 'ckx-sdk', about: 'classes and abilities in real time' },
     racing: { dir: ['starters', 'racing'], sdk: 'ckx-sdk', about: 'races with laps and a ghost, and ball games' },
     territory: { dir: ['starters', 'territory'], sdk: 'ckx-sdk', about: 'control points, and a shrinking circle' },
+    player: { dir: ['starters', 'player'], sdk: 'ckx-sdk', about: "a player's own hub: items, currency, crafting, quests (not a ledger)" },
+    market: { dir: ['starters', 'market'], sdk: 'ckx-sdk', about: 'vendors, an order book, trades between players (not a ledger)' },
 };
 const CRATE_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 function copyTree(from, to) {

package/kit.pin

@@ -1,9 +1,9 @@
 # The platform toolchain release this kit was copied from (sync-kit.sh in the platform's
 # repository). The paths in `copied` are byte-identical to it: change them there, never here.
-toolchain_version=v1.13.0
-toolchain_commit=4e6f1a7c9502d5d7171d75b6063acec97172239e
-sdk_commit=04d42bc77e24b6d84debc71eeee0efc687c0ee9a
-ckx_sdk_version=0.11.0
+toolchain_version=v1.15.0
+toolchain_commit=8447d24998210f5d00f94ec2ad8781bc0b4b6e0a
+sdk_commit=c682f9378d742b7420a3bf0b49309cc27fba85bb
+ckx_sdk_version=0.12.1
 crowdy_client_sdk_version=0.1.0
 rust_version=1.97.1
 copied=crates/ckx-sdk/src crates/crowdy-client-sdk/src tools/instrument/Cargo.toml tools/instrument/Cargo.lock tools/instrument/src checks/src/build/exec-source.ts checks/src/build/exec-source.spec.ts checks/src/build/rust-source-guard.ts checks/src/build/rust-source-guard.spec.ts checks/src/build/wasm-inspect.ts checks/src/build/wasm-inspect.spec.ts checks/src/build/client-capabilities.ts checks/src/build/client-capabilities.spec.ts checks/src/test-support/wasm-module.ts checks/compute-toolchain/host-catalog.json starters rust-toolchain.toml vendor.lock

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crowdedkingdoms/ckx-kit",
-  "version": "0.4.0-dev.1",
+  "version": "0.5.0-dev.1",
   "description": "Build, check and test Crowded Kingdoms ck-exec mods, hubs and spokes on your machine, as the platform builds them",
   "license": "MIT OR Apache-2.0",
   "homepage": "https://docs.crowdedkingdoms.com/exec/intro",

package/starters/arena/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/ckx.json

@@ -15,6 +15,8 @@
     "race": { "kind": "hub", "parent": "world", "crate": "racing", "wasm": "racing.wasm", "client": true, "calls": ["leaderboard"] },
     "ball": { "kind": "hub", "parent": "world", "crate": "racing", "wasm": "racing.wasm", "client": true },
     "territory": { "kind": "hub", "parent": "world", "crate": "territory", "wasm": "territory.wasm", "client": true, "scopes": ["world.read"] },
-    "zone": { "kind": "hub", "parent": "world", "crate": "territory", "wasm": "territory.wasm", "client": true, "scopes": ["world.read"] }
+    "zone": { "kind": "hub", "parent": "world", "crate": "territory", "wasm": "territory.wasm", "client": true, "scopes": ["world.read"] },
+    "player": { "kind": "hub", "parent": "world", "crate": "player", "wasm": "player.wasm", "client": true },
+    "market": { "kind": "hub", "parent": "world", "crate": "market", "wasm": "market.wasm", "client": true, "calls": ["player"] }
   }
 }

package/starters/deck/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/director/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/grid-mod/Cargo.toml

@@ -9,5 +9,5 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }

package/starters/instance/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/leaderboard/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.11.0"
+ckx-sdk = "0.12.1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"