@crowdedkingdoms/ckx-kit 0.6.0-test.1 → 0.7.0-dev.1

package/crates/ckx-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ckx-sdk"
-version = "0.13.0-test.1"
+version = "0.14.0-dev.1"
 edition = "2024"
 description = "Write ck-exec hubs, spokes and mods for Crowded Kingdoms in Rust, compiled to wasm32-unknown-unknown"
 license = "MIT OR Apache-2.0"

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

@@ -73,7 +73,7 @@ pub mod prelude {
     pub use crate::cron::Cron;
     pub use crate::emit::{Spatial, actor_id};
     pub use crate::model::{Model, PropKind, Schema, Viewer, Visibility};
-    pub use crate::node::{AgeBracket, ChunkPos, GridPick, ReportReason, SafetyReport, VoxelWrite};
+    pub use crate::node::{AgeBracket, ChunkPos, ChunkVoxelState, GridPick, ReportReason, SafetyReport, VoxelWrite};
     pub use crate::{
         Call, CallError, Caller, Ctx, Error, Hub, Kind, Level, Presence, PresencePlayer, Result, Session, Spoke, Status, TopicMsg,
         WorldEvent, decode, encode,

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

@@ -1,7 +1,7 @@
 //! The platform's bounds on a node: what its sandbox and its checks hold every call, snapshot
 //! and module to. [`crate::testing`] applies the ones a native test can see.
 
-pub use crate::node::{MAX_CHUNK_STATE, MAX_VOXEL_STATE, MAX_VOXEL_WRITES};
+pub use crate::node::{CHUNK_GRID_BYTES, MAX_CHUNK_STATE, MAX_CHUNK_STATES, MAX_VOXEL_STATE, MAX_VOXEL_WRITE_BYTES, MAX_VOXEL_WRITES};
 pub use crate::rt::{MAX_TIMERS, MAX_WATCHES, MIN_TIMER_MS};
 
 /// The largest payload a node may send in one message, and the largest reply it may return. A
@@ -53,3 +53,17 @@ pub mod mods {
     /// The node API scopes every mod holds, each confined to its grid.
     pub const SCOPES: [&str; 3] = ["grids.read", "world.read", "world.write"];
 }
+
+/// What the game API's node API allows an app on each of its replicas. An app's own code and its
+/// players' mods draw on separate buckets, so no player's mod can spend the app's. Past it a call
+/// answers [`crate::Status::RateLimited`]; retry after a moment.
+pub mod node {
+    /// Units per second; a bucket holds two seconds' worth for a burst.
+    pub const READ_UNITS_PER_SEC: u32 = 200;
+    pub const WRITE_UNITS_PER_SEC: u32 = 50;
+    pub const BURST_SECONDS: u32 = 2;
+    /// Voxels one write unit pays for: a `set_voxels` of 4,096 voxels costs 64 units, and a
+    /// `set_chunk` costs one unit plus one per started 64 states. A chunk state costs one unit per
+    /// started 4 KiB, and any other call one unit.
+    pub const VOXELS_PER_WRITE_UNIT: usize = 64;
+}

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

@@ -27,10 +27,17 @@ use serde_json::{Value, json};
 
 use crate::{CallError, Ctx, Status};
 
-/// Voxel writes in one [`World::set_voxels`] call.
-pub const MAX_VOXEL_WRITES: usize = 16;
+/// Voxel writes in one [`World::set_voxels`] call: a whole 16×16×16 chunk's worth.
+pub const MAX_VOXEL_WRITES: usize = 4096;
+/// The voxel states of one [`World::set_voxels`] or [`World::set_chunk`] call together, so the
+/// call stays well under the platform's message limit once encoded.
+pub const MAX_VOXEL_WRITE_BYTES: usize = 2 << 20;
 /// A voxel's state bytes.
 pub const MAX_VOXEL_STATE: usize = 1024;
+/// A [`World::set_chunk`] grid: one type byte per voxel of the 16×16×16 chunk.
+pub const CHUNK_GRID_BYTES: usize = 4096;
+/// Voxel states stored with one [`World::set_chunk`].
+pub const MAX_CHUNK_STATES: usize = 4096;
 /// A chunk's state bytes ([`World::set_chunk_state`]).
 pub const MAX_CHUNK_STATE: usize = 65_536;
 /// A safety report's details, in characters as the game API counts them (UTF-16 units).
@@ -92,6 +99,15 @@ pub struct VoxelWrite {
     pub state: Option<Vec<u8>>,
 }
 
+/// One voxel's state stored with a [`World::set_chunk`]: the voxel, its type and its bytes.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChunkVoxelState {
+    /// `(x, y, z)` within the chunk.
+    pub voxel: (i16, i16, i16),
+    pub voxel_type: i16,
+    pub state: Option<Vec<u8>>,
+}
+
 /// A player's actor in the world, from live presence.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Actor {
@@ -270,6 +286,21 @@ fn bad_reply(op: &str, e: impl std::fmt::Display) -> CallError {
     CallError { status: Status::Internal, message: format!("unexpected {op} reply: {e}") }
 }
 
+/// Refuses a voxel state over [`MAX_VOXEL_STATE`], or states over [`MAX_VOXEL_WRITE_BYTES`] together.
+fn check_state_bytes<'a>(states: impl Iterator<Item = Option<&'a [u8]>>) -> Result<(), CallError> {
+    let mut total = 0usize;
+    for s in states.flatten() {
+        if s.len() > MAX_VOXEL_STATE {
+            return Err(bad_request(format!("a voxel's state is at most {MAX_VOXEL_STATE} bytes")));
+        }
+        total += s.len();
+    }
+    if total > MAX_VOXEL_WRITE_BYTES {
+        return Err(bad_request(format!("the voxel states of one call are at most {MAX_VOXEL_WRITE_BYTES} bytes together")));
+    }
+    Ok(())
+}
+
 fn bad_request(message: impl Into<String>) -> CallError {
     CallError { status: Status::BadRequest, message: message.into() }
 }
@@ -481,17 +512,17 @@ impl World<'_> {
         Ok(r.voxels.into_iter().map(Voxel::from).collect())
     }
 
-    /// Writes up to [`MAX_VOXEL_WRITES`] voxels in one transaction, as the app, and shows them
-    /// to nearby players. Returns the voxel update ids. Scope `world.write`.
+    /// Writes up to [`MAX_VOXEL_WRITES`] voxels in one transaction, as the app, and shows each
+    /// to nearby players as a voxel update. Their states may hold [`MAX_VOXEL_WRITE_BYTES`]
+    /// together. Returns the voxel update ids. A call costs one write per started 64 voxels
+    /// ([`crate::limits::node`]). Scope `world.write`.
     pub fn set_voxels(&self, writes: &[VoxelWrite]) -> Result<Vec<u64>, CallError> {
         if writes.is_empty() || writes.len() > MAX_VOXEL_WRITES {
             return Err(bad_request(format!("write 1 to {MAX_VOXEL_WRITES} voxels per call")));
         }
+        check_state_bytes(writes.iter().map(|w| w.state.as_deref()))?;
         let mut list = Vec::with_capacity(writes.len());
         for w in writes {
-            if w.state.as_ref().is_some_and(|s| s.len() > MAX_VOXEL_STATE) {
-                return Err(bad_request(format!("a voxel's state is at most {MAX_VOXEL_STATE} bytes")));
-            }
             list.push(json!({
                 "chunk": w.chunk.json(),
                 "voxel": { "x": w.voxel.0, "y": w.voxel.1, "z": w.voxel.2 },
@@ -508,6 +539,39 @@ impl World<'_> {
         r.voxel_update_ids.iter().map(|id| id.parse().map_err(|e| bad_reply("world.set_voxels", e))).collect()
     }
 
+    /// Replaces the chunk at `chunk` with `grid` (one type byte per voxel, index
+    /// `x + y*16 + z*256`) and `states`, and drops every voxel written into it before, so it
+    /// reads back exactly as written; its own state blob ([`World::set_chunk_state`]) is kept.
+    /// Nearby players are told once to read the chunk again rather than sent a voxel update per
+    /// voxel, so this is the cheap way to change most of a chunk; the grid's mods hear it as
+    /// `voxels`. A call costs one write plus one per started 64 states ([`crate::limits::node`]).
+    /// Scope `world.write`; a mod may set chunks only inside its grid, where its owner may edit.
+    pub fn set_chunk(&self, chunk: ChunkPos, grid: &[u8], states: &[ChunkVoxelState]) -> Result<(), CallError> {
+        if grid.len() != CHUNK_GRID_BYTES {
+            return Err(bad_request(format!("a chunk grid is {CHUNK_GRID_BYTES} bytes, one per voxel")));
+        }
+        if states.len() > MAX_CHUNK_STATES {
+            return Err(bad_request(format!("at most {MAX_CHUNK_STATES} voxel states per chunk")));
+        }
+        check_state_bytes(states.iter().map(|s| s.state.as_deref()))?;
+        let list: Vec<Value> = states
+            .iter()
+            .map(|s| {
+                json!({
+                    "voxel": { "x": s.voxel.0, "y": s.voxel.1, "z": s.voxel.2 },
+                    "voxelType": s.voxel_type,
+                    "stateBase64": s.state.as_deref().map(b64),
+                })
+            })
+            .collect();
+        let mut body = json!({ "chunk": chunk.json(), "gridBase64": b64(grid) });
+        if !list.is_empty() {
+            body["states"] = Value::Array(list);
+        }
+        let _: Value = op(self.0, "world.set_chunk", body)?;
+        Ok(())
+    }
+
     /// Replaces the chunk's own state blob, the one [`Chunk::chunk_state`] reads (at most
     /// [`MAX_CHUNK_STATE`] bytes; `None` clears it). Scope `world.write`.
     pub fn set_chunk_state(&self, chunk: ChunkPos, state: Option<&[u8]>) -> Result<(), CallError> {
@@ -1042,6 +1106,50 @@ mod tests {
         assert_eq!(refused_here(|c| c.world().set_voxels(&[big])).status, Status::BadRequest);
     }
 
+    #[test]
+    fn a_whole_chunk_of_voxels_fits_one_set_voxels_and_the_states_share_a_cap() {
+        let at = |i: usize| VoxelWrite {
+            chunk: ChunkPos::new(0, 0, 0),
+            voxel: ((i % 16) as i16, (i / 16 % 16) as i16, (i / 256) as i16),
+            voxel_type: 1,
+            state: None,
+        };
+        let all: Vec<VoxelWrite> = (0..MAX_VOXEL_WRITES).map(at).collect();
+        let ids: Vec<String> = (0..MAX_VOXEL_WRITES).map(|i| i.to_string()).collect();
+        let (got, _, _) = exchange(json!({ "voxelUpdateIds": ids }), |c| c.world().set_voxels(&all));
+        assert_eq!(got.unwrap().len(), MAX_VOXEL_WRITES);
+        let one_more: Vec<VoxelWrite> = (0..=MAX_VOXEL_WRITES).map(at).collect();
+        assert_eq!(refused_here(|c| c.world().set_voxels(&one_more)).status, Status::BadRequest);
+        // 2,049 states of 1,024 bytes pass the shared 2 MiB.
+        let heavy: Vec<VoxelWrite> = (0..2049).map(|i| VoxelWrite { state: Some(vec![0; MAX_VOXEL_STATE]), ..at(i) }).collect();
+        assert_eq!(refused_here(|c| c.world().set_voxels(&heavy)).status, Status::BadRequest);
+    }
+
+    #[test]
+    fn set_chunk_sends_the_grid_and_its_states() {
+        let grid = vec![3u8; CHUNK_GRID_BYTES];
+        let states = vec![ChunkVoxelState { voxel: (1, 2, 3), voxel_type: -4, state: Some(vec![9]) }];
+        let (got, name, body) = exchange(json!({ "updatedAt": "t" }), |c| c.world().set_chunk(ChunkPos::new(7, 0, -2), &grid, &states));
+        got.unwrap();
+        assert_eq!(name, "world.set_chunk");
+        assert_eq!(body["chunk"], pos(7, 0, -2));
+        assert_eq!(B64.decode(body["gridBase64"].as_str().unwrap()).unwrap(), grid);
+        assert_eq!(body["states"], json!([{ "voxel": { "x": 1, "y": 2, "z": 3 }, "voxelType": -4, "stateBase64": "CQ==" }]));
+        let (_, _, bare) = exchange(json!({ "updatedAt": "t" }), |c| c.world().set_chunk(ChunkPos::default(), &grid, &[]));
+        assert!(bare.get("states").is_none(), "no states, no list");
+    }
+
+    #[test]
+    fn set_chunk_refuses_a_wrong_grid_or_too_many_states_before_sending() {
+        let short = vec![0u8; CHUNK_GRID_BYTES - 1];
+        assert_eq!(refused_here(|c| c.world().set_chunk(ChunkPos::default(), &short, &[])).status, Status::BadRequest);
+        let grid = vec![0u8; CHUNK_GRID_BYTES];
+        let many = vec![ChunkVoxelState { voxel: (0, 0, 0), voxel_type: 1, state: None }; MAX_CHUNK_STATES + 1];
+        assert_eq!(refused_here(|c| c.world().set_chunk(ChunkPos::default(), &grid, &many)).status, Status::BadRequest);
+        let big = vec![ChunkVoxelState { voxel: (0, 0, 0), voxel_type: 1, state: Some(vec![0; MAX_VOXEL_STATE + 1]) }];
+        assert_eq!(refused_here(|c| c.world().set_chunk(ChunkPos::default(), &grid, &big)).status, Status::BadRequest);
+    }
+
     #[test]
     fn a_chunk_state_is_set_or_cleared_within_its_cap() {
         let (got, name, body) = exchange(json!({ "updatedAt": "2026-10-09T12:00:00.000Z" }), |c| {

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

@@ -847,11 +847,19 @@ pub fn player_payload(player: u64) -> crate::Result<Vec<u8>> {
 // ---- the node API, as it serves a mod ----
 
 /// The node API operations a mod may call.
-const MOD_OPS: [&str; 7] =
-    ["world.chunk", "world.voxels", "world.actors", "world.actors_radius", "world.set_voxels", "grids.get", "grids.check_permission"];
+const MOD_OPS: [&str; 8] = [
+    "world.chunk",
+    "world.voxels",
+    "world.actors",
+    "world.actors_radius",
+    "world.set_voxels",
+    "world.set_chunk",
+    "grids.get",
+    "grids.check_permission",
+];
 
 /// Each node API operation and the scope it needs.
-const OP_SCOPES: [(&str, &str); 29] = [
+const OP_SCOPES: [(&str, &str); 30] = [
     ("players.get", "players.read"),
     ("players.features", "players.read"),
     ("players.check_permission", "players.read"),
@@ -864,6 +872,7 @@ const OP_SCOPES: [(&str, &str); 29] = [
     ("world.actors", "world.read"),
     ("world.actors_radius", "world.read"),
     ("world.set_voxels", "world.write"),
+    ("world.set_chunk", "world.write"),
     ("world.set_chunk_state", "world.write"),
     ("grids.get", "grids.read"),
     ("grids.check_permission", "grids.read"),
@@ -998,10 +1007,11 @@ struct FakeChunk {
 
 /// A mod's grid as the node API serves it to the mod: the box, its owner, the chunks and
 /// voxels in it, the actors there and its permissions, under the node API's rules for mods.
-/// A mod calls seven operations (`world.chunk`, `world.voxels`, `world.actors`,
-/// `world.actors_radius`, `world.set_voxels`, `grids.get`, `grids.check_permission`), only
-/// inside its grid; writes voxels only where its owner may edit them; and is refused
-/// everything once its owner no longer owns the grid. A refusal reads as the game API's.
+/// A mod calls eight operations (`world.chunk`, `world.voxels`, `world.actors`,
+/// `world.actors_radius`, `world.set_voxels`, `world.set_chunk`, `grids.get`,
+/// `grids.check_permission`), only inside its grid; writes voxels and chunks only where its
+/// owner may edit them; and is refused everything once its owner no longer owns the grid. A
+/// refusal reads as the game API's.
 #[derive(Debug, Clone)]
 pub struct FakeGrid {
     id: u64,
@@ -1223,6 +1233,11 @@ impl FakeGrid {
             return Err(refusal(403, &format!("the capability lacks scope {scope}")));
         }
         let writes = if op == "world.set_voxels" { voxel_writes(body)? } else { Vec::new() };
+        let (states, grid) = if op == "world.set_chunk" {
+            (chunk_states(body)?, base64_bytes(body.get("gridBase64"), "gridBase64", crate::node::CHUNK_GRID_BYTES)?)
+        } else {
+            (Vec::new(), None)
+        };
         if op == "world.set_chunk_state" {
             base64_bytes(body.get("stateBase64"), "stateBase64", crate::node::MAX_CHUNK_STATE)?;
         }
@@ -1289,6 +1304,49 @@ impl FakeGrid {
                 }
                 Ok(json!({ "voxelUpdateIds": ids }))
             }
+            "world.set_chunk" => {
+                let at = chunk_pos(body.get("chunk"), "chunk")?;
+                self.inside(at, 0, 0)?;
+                if self.closed.contains(&key(at)) {
+                    return Err(refusal(
+                        403,
+                        &format!(
+                            "the mod's owner may not edit voxels at chunk ({}, {}, {}): the most specific grid there does not grant them 'update_voxel_data'",
+                            at.x, at.y, at.z
+                        ),
+                    ));
+                }
+                let grid = grid.ok_or_else(|| {
+                    refusal(400, &format!("gridBase64 must hold the chunk's {} voxel bytes", crate::node::CHUNK_GRID_BYTES))
+                })?;
+                if grid.len() != crate::node::CHUNK_GRID_BYTES {
+                    return Err(refusal(400, &format!("a chunk grid is {} bytes, one per voxel", crate::node::CHUNK_GRID_BYTES)));
+                }
+                let next_id = self.next_update;
+                let chunk = self.chunks.entry(key(at)).or_default();
+                let (id, chunk_state) = match &chunk.stored {
+                    Some(c) => (c.id, c.chunk_state.clone()),
+                    None => (next_id, None),
+                };
+                if chunk.stored.is_none() {
+                    self.next_update += 1;
+                }
+                chunk.stored = Some(Chunk { id, at, voxels: Some(grid), chunk_state });
+                chunk.edits.clear();
+                for s in states {
+                    let voxel = Voxel {
+                        x: s.voxel.0,
+                        y: s.voxel.1,
+                        z: s.voxel.2,
+                        voxel_type: s.voxel_type,
+                        state: s.state,
+                        created_by: Some("0".to_owned()),
+                        updated_at: Some(rfc3339(now)),
+                    };
+                    chunk.edits.insert((voxel.y, voxel.x, voxel.z), voxel);
+                }
+                Ok(json!({ "updatedAt": rfc3339(now) }))
+            }
             "grids.get" => {
                 self.own_grid(body)?;
                 Ok(json!({ "grid": self.grid_json() }))
@@ -1331,6 +1389,32 @@ fn voxel_writes(body: &Value) -> Result<Vec<Write>, CallError> {
         .collect()
 }
 
+struct StateWrite {
+    voxel: (i16, i16, i16),
+    voxel_type: i16,
+    state: Option<Vec<u8>>,
+}
+
+fn chunk_states(body: &Value) -> Result<Vec<StateWrite>, CallError> {
+    let max = crate::node::MAX_CHUNK_STATES;
+    let list = match body.get("states") {
+        None | Some(Value::Null) => return Ok(Vec::new()),
+        Some(Value::Array(l)) if l.len() <= max => l,
+        Some(_) => return Err(refusal(400, &format!("states must list at most {max} voxel states"))),
+    };
+    let axis = |v: &Value, i: usize, k: &str| int_in(v.get(k), &format!("states[{i}].voxel.{k}"), i16::MIN.into(), i16::MAX.into());
+    list.iter()
+        .enumerate()
+        .map(|(i, s)| {
+            let v = s.get("voxel").unwrap_or(&Value::Null);
+            let voxel = (axis(v, i, "x")? as i16, axis(v, i, "y")? as i16, axis(v, i, "z")? as i16);
+            let voxel_type = int_in(s.get("voxelType"), &format!("states[{i}].voxelType"), i16::MIN.into(), i16::MAX.into())? as i16;
+            let state = base64_bytes(s.get("stateBase64"), &format!("states[{i}].stateBase64"), crate::node::MAX_VOXEL_STATE)?;
+            Ok(StateWrite { voxel, voxel_type, state })
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/crates/crowdy-client-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crowdy-client-sdk"
-version = "0.1.0-test.1"
+version = "0.1.0-dev.1"
 edition = "2021"
 description = "Guest SDK for the CLIENT half of a ck-exec mod: browser WASM (ck ABI v0 + the client host calls)."
 license = "MIT OR Apache-2.0"

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.16.0
-toolchain_commit=9423aa5f66b5480f2aa19110b6888d3e04c4534d
-sdk_commit=27d5774d7b9d3b3c28928ad1a4d27902ac5130e1
-ckx_sdk_version=0.13.0
+toolchain_version=v1.17.0
+toolchain_commit=a3c5049209c6633e0f65480eafe3be4a40530a32
+sdk_commit=cc5b85b2adfc1214bf8e61a24f3d0ac7e0cedc6d
+ckx_sdk_version=0.14.0
 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.6.0-test.1",
+  "version": "0.7.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.13.0"
+ckx-sdk = "0.14.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/deck/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.13.0"
+ckx-sdk = "0.14.0"
 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.13.0"
+ckx-sdk = "0.14.0"
 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.13.0"
+ckx-sdk = "0.14.0"
 serde = { version = "1", features = ["derive"] }

package/starters/instance/Cargo.toml

@@ -9,6 +9,6 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-ckx-sdk = "0.13.0"
+ckx-sdk = "0.14.0"
 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.13.0"
+ckx-sdk = "0.14.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

package/starters/market/Cargo.toml

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

package/starters/matchmaker/Cargo.toml

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

package/starters/minigame/Cargo.toml

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

package/starters/npc-mobs/Cargo.toml

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

package/starters/player/Cargo.toml

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

package/starters/racing/Cargo.toml

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

package/starters/session/Cargo.toml

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

package/starters/tactics/Cargo.toml

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

package/starters/territory/Cargo.toml

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

package/starters/world-tick/Cargo.toml

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