@crowdedkingdoms/crowdyjs 18.11.0-dev.1 → 18.12.0-dev.1

package/dist/live-coding/browser-authoring-index.generated.js

@@ -4,7 +4,7 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
     "rustVersion": "1.97.1",
     "sdkVersion": "0.1.0",
     "abiVersion": 0,
-    "contentHash": "70df75c058b2550cfcb558ba28307b38689af8db7985f95fd83d38d42516f78b",
+    "contentHash": "58bdbf80b074a29748452ec5b5e26eb290f1cae7140f4ad4994c47c76a82a64d",
     "crates": [
         {
             "name": "alloc",
@@ -13,8 +13,8 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
         },
         {
             "name": "ckx-sdk",
-            "version": "0.10.0",
-            "sourceHash": "df1f3eabc835576f266a28d879419c4f7d0e871c063f2238097ebfa81b05796c"
+            "version": "0.11.0",
+            "sourceHash": "eedafccbba1298498d7b2d827e91eeeb219001ef8d4a17cd490c80b2df416022"
         },
         {
             "name": "core",
@@ -1337,6 +1337,13 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "signature": "pub const RECEIPT_TTL_MS: u64 = 10 * 60 * 1000;",
             "docs": "How long a receipt is kept."
         },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "RESERVED_FIELDS",
+            "kind": "const",
+            "signature": "pub const RESERVED_FIELDS: [&str; 4] = [\"v\", \"epoch\", \"seq\", \"kind\"];",
+            "docs": "The fields a kit message's header owns; a body may not use them (they sit side by side)."
+        },
         {
             "module": "ckx_sdk::kit",
             "name": "Receipts",
@@ -1407,6 +1414,13 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "signature": "pub const SNAPSHOT_METHOD: &str = \"snapshot\";",
             "docs": "The method every kit hub answers with a topic's snapshot."
         },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "ai",
+            "kind": "module",
+            "signature": "pub mod ai;",
+            "docs": ""
+        },
         {
             "module": "ckx_sdk::kit",
             "name": "args",
@@ -1414,6 +1428,13 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "signature": "pub fn args<T: DeserializeOwned>(call: &Call<'_>) -> Result<T>",
             "docs": "A call's arguments, refused with [`codes::BAD_REQUEST`] when they do not decode."
         },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "args_or_default",
+            "kind": "function",
+            "signature": "pub fn args_or_default<T: DeserializeOwned + Default>(call: &Call<'_>) -> Result<T>",
+            "docs": "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()`."
+        },
         {
             "module": "ckx_sdk::kit",
             "name": "codes",
@@ -1440,7 +1461,21 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "name": "message",
             "kind": "function",
             "signature": "pub fn message<T: Serialize + ?Sized>(ctx: &Ctx, kind: MessageKind, seq: u64, body: &T) -> Result<Vec<u8>>",
-            "docs": "Encodes one kit message from this instance. `body` must serialize as a struct or a map."
+            "docs": "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."
+        },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "play",
+            "kind": "module",
+            "signature": "pub mod play;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "presence",
+            "kind": "module",
+            "signature": "pub mod presence;",
+            "docs": ""
         },
         {
             "module": "ckx_sdk::kit",
@@ -1463,6 +1498,13 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "signature": "pub mod shard;",
             "docs": ""
         },
+        {
+            "module": "ckx_sdk::kit",
+            "name": "sim",
+            "kind": "module",
+            "signature": "pub mod sim;",
+            "docs": ""
+        },
         {
             "module": "ckx_sdk::kit",
             "name": "snapshot_topic",
@@ -1478,242 +1520,3357 @@ export const GENERATED_BROWSER_AUTHORING_INDEX = {
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "ALREADY_DONE",
-            "kind": "const",
-            "signature": "pub const ALREADY_DONE: &str = \"already_done\";",
-            "docs": "The action already ran; its reply was too large to keep ([`super::RECEIPT_REPLY_MAX`])."
+            "module": "ckx_sdk::kit::ai",
+            "name": "brain",
+            "kind": "module",
+            "signature": "pub mod brain;",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "BAD_REQUEST",
-            "kind": "const",
-            "signature": "pub const BAD_REQUEST: &str = \"bad_request\";",
+            "module": "ckx_sdk::kit::ai",
+            "name": "flow",
+            "kind": "module",
+            "signature": "pub mod flow;",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "CONFLICT",
-            "kind": "const",
-            "signature": "pub const CONFLICT: &str = \"conflict\";",
-            "docs": "The state does not allow it now."
+            "module": "ckx_sdk::kit::ai",
+            "name": "path",
+            "kind": "module",
+            "signature": "pub mod path;",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "COOLDOWN",
-            "kind": "const",
-            "signature": "pub const COOLDOWN: &str = \"cooldown\";",
-            "docs": "Too soon after the last time."
+            "module": "ckx_sdk::kit::ai",
+            "name": "steering",
+            "kind": "module",
+            "signature": "pub mod steering;",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "EMPTY",
-            "kind": "const",
-            "signature": "pub const EMPTY: &str = \"empty\";",
+            "module": "ckx_sdk::kit::ai",
+            "name": "turn",
+            "kind": "module",
+            "signature": "pub mod turn;",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "EXPIRED",
-            "kind": "const",
-            "signature": "pub const EXPIRED: &str = \"expired\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "AgentMemory",
+            "kind": "struct",
+            "signature": "pub struct AgentMemory { pub target: Option<(f32, f32)>, pub retarget_at_ms: u64, pub patrol_index: usize, pub pause_until_ms: u64, }",
+            "docs": "Per-agent mutable memory the tree reads/writes across ticks (serde-able into the hub's state)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "AgentMemory::patrol_index",
+            "kind": "field",
+            "signature": "pub patrol_index: usize",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "FINISHED",
-            "kind": "const",
-            "signature": "pub const FINISHED: &str = \"finished\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "AgentMemory::pause_until_ms",
+            "kind": "field",
+            "signature": "pub pause_until_ms: u64",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "FORBIDDEN",
-            "kind": "const",
-            "signature": "pub const FORBIDDEN: &str = \"forbidden\";",
-            "docs": "The caller may not do this."
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "AgentMemory::retarget_at_ms",
+            "kind": "field",
+            "signature": "pub retarget_at_ms: u64",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "FULL",
-            "kind": "const",
-            "signature": "pub const FULL: &str = \"full\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "AgentMemory::target",
+            "kind": "field",
+            "signature": "pub target: Option<(f32, f32)>",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "INSUFFICIENT",
-            "kind": "const",
-            "signature": "pub const INSUFFICIENT: &str = \"insufficient\";",
-            "docs": "Not enough of something the caller spends."
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Decision",
+            "kind": "enum",
+            "signature": "pub enum Decision { Idle, /// Move by this bounded step. Step(Vec2), /// Nothing matched / tree invalid — caller may fall back. None, }",
+            "docs": "What the agent decided to do this tick."
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "LIMIT",
-            "kind": "const",
-            "signature": "pub const LIMIT: &str = \"limit\";",
-            "docs": "A bound the hub keeps (how many, how large)."
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Decision::Idle",
+            "kind": "variant",
+            "signature": "Idle",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "NOT_FOUND",
-            "kind": "const",
-            "signature": "pub const NOT_FOUND: &str = \"not_found\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Decision::None",
+            "kind": "variant",
+            "signature": "None",
+            "docs": "Nothing matched / tree invalid — caller may fall back."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Decision::Step",
+            "kind": "variant",
+            "signature": "Step(Vec2)",
+            "docs": "Move by this bounded step."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception",
+            "kind": "struct",
+            "signature": "pub struct Perception { pub pos: Vec2, pub home: Vec2, /// Nearest player position, when one is visible. pub nearest_player: Option<Vec2>, /// Owner position (pets), when known. pub owner: Option<Vec2>, pub is_night: bool, pub speed: f32, pub dt: f32, pub now_ms: u64, /// Two uniform rolls in [0,1) for this tick (from the hub's seeded RNG). pub roll: (f32, f32), /// World half-extent for wander clamping. pub bounds: f32, }",
+            "docs": "Everything a tree evaluation may look at (the hub fills this in)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::bounds",
+            "kind": "field",
+            "signature": "pub bounds: f32",
+            "docs": "World half-extent for wander clamping."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::dt",
+            "kind": "field",
+            "signature": "pub dt: f32",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "NOT_MEMBER",
-            "kind": "const",
-            "signature": "pub const NOT_MEMBER: &str = \"not_member\";",
-            "docs": "The caller has not joined."
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::home",
+            "kind": "field",
+            "signature": "pub home: Vec2",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "NOT_READY",
-            "kind": "const",
-            "signature": "pub const NOT_READY: &str = \"not_ready\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::is_night",
+            "kind": "field",
+            "signature": "pub is_night: bool",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "NOT_YOUR_TURN",
-            "kind": "const",
-            "signature": "pub const NOT_YOUR_TURN: &str = \"not_your_turn\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::nearest_player",
+            "kind": "field",
+            "signature": "pub nearest_player: Option<Vec2>",
+            "docs": "Nearest player position, when one is visible."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::now_ms",
+            "kind": "field",
+            "signature": "pub now_ms: u64",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "OUT_OF_REACH",
-            "kind": "const",
-            "signature": "pub const OUT_OF_REACH: &str = \"out_of_reach\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::owner",
+            "kind": "field",
+            "signature": "pub owner: Option<Vec2>",
+            "docs": "Owner position (pets), when known."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::pos",
+            "kind": "field",
+            "signature": "pub pos: Vec2",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "RESERVED",
-            "kind": "const",
-            "signature": "pub const RESERVED: &str = \"reserved\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::roll",
+            "kind": "field",
+            "signature": "pub roll: (f32, f32)",
+            "docs": "Two uniform rolls in [0,1) for this tick (from the hub's seeded RNG)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "Perception::speed",
+            "kind": "field",
+            "signature": "pub speed: f32",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::codes",
-            "name": "STARTED",
-            "kind": "const",
-            "signature": "pub const STARTED: &str = \"started\";",
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "builtin_tree",
+            "kind": "function",
+            "signature": "pub fn builtin_tree(name: &str) -> Option<Value>",
+            "docs": "Canonical trees for the built-in behavior names a game's agent definitions use (`wander_passive`, `wander_hostile`, `chase_hostile`)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::brain",
+            "name": "evaluate",
+            "kind": "function",
+            "signature": "pub fn evaluate(tree: &Value, p: &Perception, memory: &mut AgentMemory) -> Decision",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField",
             "kind": "struct",
-            "signature": "pub struct Rng { state: u64, }",
-            "docs": ""
+            "signature": "pub struct FlowField { pub min_x: i32, pub min_z: i32, pub width: i32, pub height: i32, /// Distance to the nearest goal per cell; u32::MAX = unreachable/blocked. distances: Vec<u32>, }",
+            "docs": "A baked distance field over a bounded grid window. Serde-able so hubs can persist it, but rebuilding from the provider is usually cheaper than storing it durably."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::below",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::build",
             "kind": "method",
-            "signature": "pub fn below(&mut self, n: u64) -> u64",
-            "docs": "Uniform in `[0, n)`; 0 when `n` is 0."
+            "signature": "pub fn build( provider: &impl CostProvider, window: (i32, i32, i32, i32), // min_x, min_z, width, height goals: &[(i32, i32)], max_cells: usize, ) -> Self",
+            "docs": "Build the field inside the window from the goal cells outward, respecting the provider's blocked cells. Cost = uniform 1 per step (weighted providers still gate walkability; weighting the descent is deliberately v2). `max_cells` caps the BFS for fuel safety."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::chance",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::distance",
             "kind": "method",
-            "signature": "pub fn chance(&mut self, p: f64) -> bool",
-            "docs": "True with probability `p` (clamped to `[0, 1]`)."
+            "signature": "pub fn distance(&self, x: i32, z: i32) -> Option<u32>",
+            "docs": "Distance to the nearest goal (None outside the window or unreachable)."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::default",
-            "kind": "method",
-            "signature": "fn default() -> Self",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::height",
+            "kind": "field",
+            "signature": "pub height: i32",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::f64",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::min_x",
+            "kind": "field",
+            "signature": "pub min_x: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::min_z",
+            "kind": "field",
+            "signature": "pub min_z: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::step",
             "kind": "method",
-            "signature": "pub fn f64(&mut self) -> f64",
-            "docs": "Uniform in `[0, 1)`."
+            "signature": "pub fn step(&self, x: i32, z: i32) -> Option<(i32, i32)>",
+            "docs": "The descending step from (x, z): the 4-neighbor with the smallest distance, when strictly smaller than here. None at goals/unreachable."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::next_u64",
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::walk",
             "kind": "method",
-            "signature": "pub fn next_u64(&mut self) -> u64",
+            "signature": "pub fn walk(&self, mut x: i32, mut z: i32, max_steps: usize) -> Vec<(i32, i32)>",
+            "docs": "Follow the field from (x, z) for up to `max_steps`, returning the walked cells (excluding the start). Agents usually take 1 per tick; this helper powers tests and catch-up moves."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::flow",
+            "name": "FlowField::width",
+            "kind": "field",
+            "signature": "pub width: i32",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::pick",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "CostProvider",
+            "kind": "trait",
+            "signature": "pub trait CostProvider",
+            "docs": "Walkability/cost source. Implement over your world representation (obstacle grids, voxel columns, nav data in a hub's state)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "CostProvider::cost",
             "kind": "method",
-            "signature": "pub fn pick<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T>",
+            "signature": "fn cost(&self, x: i32, z: i32) -> Option<u32>;",
+            "docs": "Cost to ENTER (x, z); `None` = blocked. Uniform worlds return Some(1)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "GridProvider",
+            "kind": "struct",
+            "signature": "pub struct GridProvider<'a> { pub width: i32, pub height: i32, pub blocked: &'a dyn Fn(i32, i32) -> bool, }",
+            "docs": "A grid of booleans (true = blocked) — the simplest provider, also the test fixture."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "GridProvider::blocked",
+            "kind": "field",
+            "signature": "pub blocked: &'a dyn Fn(i32, i32) -> bool",
             "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::range",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "GridProvider::cost",
             "kind": "method",
-            "signature": "pub fn range(&mut self, lo: i64, hi: i64) -> i64",
-            "docs": "Uniform in `[lo, hi]`, both included; `lo` when `hi` is not above it."
+            "signature": "fn cost(&self, x: i32, z: i32) -> Option<u32>",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::seed_from",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "GridProvider::height",
+            "kind": "field",
+            "signature": "pub height: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "GridProvider::width",
+            "kind": "field",
+            "signature": "pub width: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathCache",
+            "kind": "struct",
+            "signature": "pub struct PathCache { generation: u64, entries: std::collections::BTreeMap<Route, (u64, Vec<(i32, i32)>)>, }",
+            "docs": "A generation-keyed path cache: repeated queries between the same cells reuse the stored path until the world changes (`invalidate()` on any voxel/tower edit bumps the generation and lazily discards entries)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathCache::get",
             "kind": "method",
-            "signature": "pub fn seed_from(text: &str) -> u64",
-            "docs": "A seed from text: a key, a name."
+            "signature": "pub fn get(&mut self, provider: &impl CostProvider, from: (i32, i32), to: (i32, i32), config: &PathConfig) -> Vec<(i32, i32)>",
+            "docs": "Cached path or compute-and-store via [`a_star`]."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::seeded",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathCache::invalidate",
             "kind": "method",
-            "signature": "pub fn seeded(seed: u64) -> Self",
-            "docs": "A generator seeded with `seed`; 0 counts as 1, which xorshift needs."
+            "signature": "pub fn invalidate(&mut self)",
+            "docs": "Drop every cached path (world changed)."
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::shuffle",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathCache::new",
             "kind": "method",
-            "signature": "pub fn shuffle<T>(&mut self, items: &mut [T])",
-            "docs": "Shuffles in place (Fisher-Yates)."
+            "signature": "pub fn new() -> Self",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::rng",
-            "name": "Rng::weighted",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathConfig",
+            "kind": "struct",
+            "signature": "pub struct PathConfig { /// Max nodes expanded before giving up (the fuel guard). ~4x the /// manhattan distance is plenty for sane worlds. pub max_expanded: usize, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathConfig::default",
             "kind": "method",
-            "signature": "pub fn weighted(&mut self, weights: &[u64]) -> Option<usize>",
-            "docs": "The index of one weight, chosen in proportion to the weights; `None` when they sum to nothing."
+            "signature": "fn default() -> Self",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::shard",
-            "name": "around",
-            "kind": "function",
-            "signature": "pub fn around(x: i64, z: i64, size: i64, radius: i64) -> Vec<String>",
-            "docs": "The keys of the shards within `radius` shards of the one holding `(x, z)`, its own first, then row by row."
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "PathConfig::max_expanded",
+            "kind": "field",
+            "signature": "pub max_expanded: usize",
+            "docs": "Max nodes expanded before giving up (the fuel guard). ~4x the manhattan distance is plenty for sane worlds."
         },
         {
-            "module": "ckx_sdk::kit::shard",
-            "name": "centre",
+            "module": "ckx_sdk::kit::ai::path",
+            "name": "a_star",
             "kind": "function",
-            "signature": "pub fn centre(x: i64, z: i64, size: i64) -> (i64, i64)",
-            "docs": "The shard's centre chunk for chunk `(x, z)`. `size` is at least 1."
+            "signature": "pub fn a_star(provider: &impl CostProvider, from: (i32, i32), to: (i32, i32), config: &PathConfig) -> Vec<(i32, i32)>",
+            "docs": "4-connected A*. Returns the path INCLUDING both endpoints, or empty when unreachable / budget-exhausted / endpoints blocked."
         },
         {
-            "module": "ckx_sdk::kit::shard",
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2",
+            "kind": "struct",
+            "signature": "pub struct Vec2 { pub x: f32, pub z: f32, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::clamped",
+            "kind": "method",
+            "signature": "pub fn clamped(self, max: f32) -> Vec2",
+            "docs": "Clamp this displacement to at most `max` length."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::dist",
+            "kind": "method",
+            "signature": "pub fn dist(&self, other: Vec2) -> f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::len",
+            "kind": "method",
+            "signature": "pub fn len(&self) -> f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::new",
+            "kind": "method",
+            "signature": "pub fn new(x: f32, z: f32) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::to",
+            "kind": "method",
+            "signature": "pub fn to(self, other: Vec2) -> Vec2",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::x",
+            "kind": "field",
+            "signature": "pub x: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::yaw",
+            "kind": "method",
+            "signature": "pub fn yaw(&self) -> f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "Vec2::z",
+            "kind": "field",
+            "signature": "pub z: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "arrive",
+            "kind": "function",
+            "signature": "pub fn arrive(pos: Vec2, target: Vec2, speed: f32, dt: f32, slow_radius: f32) -> Vec2",
+            "docs": "Seek that decelerates inside `slow_radius` (smooth stops)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "flee",
+            "kind": "function",
+            "signature": "pub fn flee(pos: Vec2, threat: Vec2, speed: f32, dt: f32) -> Vec2",
+            "docs": "Step directly away from `threat`."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "leash",
+            "kind": "function",
+            "signature": "pub fn leash(pos: Vec2, home: Vec2, leash_radius: f32, speed: f32, dt: f32) -> Option<Vec2>",
+            "docs": "Return-home pull when beyond `leash_radius`; `None` inside the leash."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "seek",
+            "kind": "function",
+            "signature": "pub fn seek(pos: Vec2, target: Vec2, speed: f32, dt: f32, stop_at: f32) -> Vec2",
+            "docs": "Step toward `target` at up to `speed*dt`, stopping within `stop_at`."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "separate",
+            "kind": "function",
+            "signature": "pub fn separate(pos: Vec2, neighbors: &[Vec2], min_dist: f32, speed: f32, dt: f32) -> Vec2",
+            "docs": "Push away from any neighbor closer than `min_dist` (crowd separation)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::steering",
+            "name": "wander_target",
+            "kind": "function",
+            "signature": "pub fn wander_target(anchor: Vec2, range: f32, roll_x: f32, roll_z: f32, bounds: f32) -> Vec2",
+            "docs": "A wander target picker: a point within `range` of `anchor`, clamped to `bounds` (half-extent box around origin). Pure — feed it your RNG rolls."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "Candidate",
+            "kind": "struct",
+            "signature": "pub struct Candidate { pub x: i32, pub z: i32, /// Movement cost spent to reach it. pub cost: u32, }",
+            "docs": "One candidate destination for a turn move."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "Candidate::cost",
+            "kind": "field",
+            "signature": "pub cost: u32",
+            "docs": "Movement cost spent to reach it."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "Candidate::x",
+            "kind": "field",
+            "signature": "pub x: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "Candidate::z",
+            "kind": "field",
+            "signature": "pub z: i32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "TurnMove",
+            "kind": "struct",
+            "signature": "pub struct TurnMove { pub to: (i32, i32), pub score: f32, }",
+            "docs": "The chosen move for a turn."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "TurnMove::score",
+            "kind": "field",
+            "signature": "pub score: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "TurnMove::to",
+            "kind": "field",
+            "signature": "pub to: (i32, i32)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "approach_scorer",
+            "kind": "function",
+            "signature": "pub fn approach_scorer(targets: Vec<(i32, i32)>) -> impl FnMut(&Candidate) -> f32",
+            "docs": "The classic melee-enemy heuristic: get adjacent to the closest target, preferring cells that minimize distance to ANY target. Returns a score function for [`best_move`]."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "best_move",
+            "kind": "function",
+            "signature": "pub fn best_move( provider: &impl CostProvider, from: (i32, i32), move_points: u32, max_expanded: usize, mut score: impl FnMut(&Candidate) -> f32, ) -> Option<TurnMove>",
+            "docs": "Pick the best reachable cell under `move_points` by `score` (higher wins; ties prefer cheaper movement, then stable coordinate order). Returns None only when even standing still is impossible (blocked origin)."
+        },
+        {
+            "module": "ckx_sdk::kit::ai::turn",
+            "name": "reachable",
+            "kind": "function",
+            "signature": "pub fn reachable(provider: &impl CostProvider, from: (i32, i32), move_points: u32, max_expanded: usize) -> Vec<Candidate>",
+            "docs": "Enumerate the cells reachable from `from` with at most `move_points` total entry cost (BFS/Dijkstra-lite over the provider, 4-connected), including standing still. Expansion stops at `max_expanded` cells."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "ALREADY_DONE",
+            "kind": "const",
+            "signature": "pub const ALREADY_DONE: &str = \"already_done\";",
+            "docs": "The action already ran; its reply was too large to keep ([`super::RECEIPT_REPLY_MAX`])."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "BAD_REQUEST",
+            "kind": "const",
+            "signature": "pub const BAD_REQUEST: &str = \"bad_request\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "CONFLICT",
+            "kind": "const",
+            "signature": "pub const CONFLICT: &str = \"conflict\";",
+            "docs": "The state does not allow it now."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "COOLDOWN",
+            "kind": "const",
+            "signature": "pub const COOLDOWN: &str = \"cooldown\";",
+            "docs": "Too soon after the last time."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "EMPTY",
+            "kind": "const",
+            "signature": "pub const EMPTY: &str = \"empty\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "EXPIRED",
+            "kind": "const",
+            "signature": "pub const EXPIRED: &str = \"expired\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "FINISHED",
+            "kind": "const",
+            "signature": "pub const FINISHED: &str = \"finished\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "FORBIDDEN",
+            "kind": "const",
+            "signature": "pub const FORBIDDEN: &str = \"forbidden\";",
+            "docs": "The caller may not do this."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "FULL",
+            "kind": "const",
+            "signature": "pub const FULL: &str = \"full\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "INSUFFICIENT",
+            "kind": "const",
+            "signature": "pub const INSUFFICIENT: &str = \"insufficient\";",
+            "docs": "Not enough of something the caller spends."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "LIMIT",
+            "kind": "const",
+            "signature": "pub const LIMIT: &str = \"limit\";",
+            "docs": "A bound the hub keeps (how many, how large)."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "NOT_FOUND",
+            "kind": "const",
+            "signature": "pub const NOT_FOUND: &str = \"not_found\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "NOT_MEMBER",
+            "kind": "const",
+            "signature": "pub const NOT_MEMBER: &str = \"not_member\";",
+            "docs": "The caller has not joined."
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "NOT_READY",
+            "kind": "const",
+            "signature": "pub const NOT_READY: &str = \"not_ready\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "NOT_YOUR_TURN",
+            "kind": "const",
+            "signature": "pub const NOT_YOUR_TURN: &str = \"not_your_turn\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "OUT_OF_REACH",
+            "kind": "const",
+            "signature": "pub const OUT_OF_REACH: &str = \"out_of_reach\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "RESERVED",
+            "kind": "const",
+            "signature": "pub const RESERVED: &str = \"reserved\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::codes",
+            "name": "STARTED",
+            "kind": "const",
+            "signature": "pub const STARTED: &str = \"started\";",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "abilities",
+            "kind": "module",
+            "signature": "pub mod abilities;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "cards",
+            "kind": "module",
+            "signature": "pub mod cards;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "combat",
+            "kind": "module",
+            "signature": "pub mod combat;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "movement",
+            "kind": "module",
+            "signature": "pub mod movement;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "score",
+            "kind": "module",
+            "signature": "pub mod score;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "timing",
+            "kind": "module",
+            "signature": "pub mod timing;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play",
+            "name": "turns",
+            "kind": "module",
+            "signature": "pub mod turns;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilityKind",
+            "kind": "enum",
+            "signature": "pub enum AbilityKind { /// Immediate hit on a target in range (hitscan). Instant { damage: i64 }, /// A stepped projectile along a direction; first actor within /// `hit_radius` takes the damage. Projectile { speed: f32, damage: i64, max_range: f32, hit_radius: f32 }, /// A delayed explosion at a target point; damage within `radius`, /// optionally scaled down linearly with distance. Aoe { radius: f32, damage: i64, delay_ms: u64, falloff: bool }, }",
+            "docs": "What a cast does once validated."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilityKind::Aoe",
+            "kind": "variant",
+            "signature": "Aoe { radius: f32, damage: i64, delay_ms: u64, falloff: bool }",
+            "docs": "A delayed explosion at a target point; damage within `radius`, optionally scaled down linearly with distance."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilityKind::Instant",
+            "kind": "variant",
+            "signature": "Instant { damage: i64 }",
+            "docs": "Immediate hit on a target in range (hitscan)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilityKind::Projectile",
+            "kind": "variant",
+            "signature": "Projectile { speed: f32, damage: i64, max_range: f32, hit_radius: f32 }",
+            "docs": "A stepped projectile along a direction; first actor within `hit_radius` takes the damage."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec",
+            "kind": "struct",
+            "signature": "pub struct AbilitySpec { pub ability_id: String, pub cooldown_ms: u64, pub resource_cost: i64, /// Max cast distance (target point / initial direction anchor). pub range: f32, pub kind: AbilityKind, }",
+            "docs": "One ability's rules (usually from the hub's config)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec::ability_id",
+            "kind": "field",
+            "signature": "pub ability_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec::cooldown_ms",
+            "kind": "field",
+            "signature": "pub cooldown_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec::kind",
+            "kind": "field",
+            "signature": "pub kind: AbilityKind",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec::range",
+            "kind": "field",
+            "signature": "pub range: f32",
+            "docs": "Max cast distance (target point / initial direction anchor)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "AbilitySpec::resource_cost",
+            "kind": "field",
+            "signature": "pub resource_cost: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook",
+            "kind": "struct",
+            "signature": "pub struct CasterBook { /// ability id -> earliest next cast (ms). pub ready_at: BTreeMap<String, u64>, pub resource: i64, pub resource_max: i64, /// Resource points regenerated per second. pub regen_per_sec: i64, pub last_regen_ms: u64, }",
+            "docs": "Per-caster server-held book: cooldown stamps + a regenerating resource pool. One book per user, kept in the hub's state."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::default",
+            "kind": "method",
+            "signature": "fn default() -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::last_regen_ms",
+            "kind": "field",
+            "signature": "pub last_regen_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::ready_at",
+            "kind": "field",
+            "signature": "pub ready_at: BTreeMap<String, u64>",
+            "docs": "ability id -> earliest next cast (ms)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::regen",
+            "kind": "method",
+            "signature": "pub fn regen(&mut self, now_ms: u64)",
+            "docs": "Apply resource regeneration up to `now_ms`."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::regen_per_sec",
+            "kind": "field",
+            "signature": "pub regen_per_sec: i64",
+            "docs": "Resource points regenerated per second."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::resource",
+            "kind": "field",
+            "signature": "pub resource: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "CasterBook::resource_max",
+            "kind": "field",
+            "signature": "pub resource_max: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe",
+            "kind": "struct",
+            "signature": "pub struct PendingAoe { pub ability_id: String, pub caster_id: String, pub x: f32, pub z: f32, pub radius: f32, pub damage: i64, pub falloff: bool, pub detonate_at_ms: u64, }",
+            "docs": "A delayed area effect awaiting detonation."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::ability_id",
+            "kind": "field",
+            "signature": "pub ability_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::caster_id",
+            "kind": "field",
+            "signature": "pub caster_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::damage",
+            "kind": "field",
+            "signature": "pub damage: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::detonate_at_ms",
+            "kind": "field",
+            "signature": "pub detonate_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::falloff",
+            "kind": "field",
+            "signature": "pub falloff: bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::from_cast",
+            "kind": "method",
+            "signature": "pub fn from_cast(spec: &AbilitySpec, caster_id: &str, cast: &ValidCast, now_ms: u64) -> Option<Self>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::radius",
+            "kind": "field",
+            "signature": "pub radius: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::ready",
+            "kind": "method",
+            "signature": "pub fn ready(&self, now_ms: u64) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::resolve",
+            "kind": "method",
+            "signature": "pub fn resolve(&self, victims: &[(String, (f32, f32))]) -> Vec<(String, i64)>",
+            "docs": "Damage per victim inside the radius (linear falloff to 25% at the edge when enabled). Victims = (id, position); the caster is exempt."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::x",
+            "kind": "field",
+            "signature": "pub x: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "PendingAoe::z",
+            "kind": "field",
+            "signature": "pub z: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile",
+            "kind": "struct",
+            "signature": "pub struct Projectile { pub ability_id: String, pub caster_id: String, pub x: f32, pub z: f32, pub dir: (f32, f32), pub speed: f32, pub damage: i64, pub hit_radius: f32, pub traveled: f32, pub max_range: f32, pub launched_at_ms: u64, }",
+            "docs": "A live projectile the hub steps each tick."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::ability_id",
+            "kind": "field",
+            "signature": "pub ability_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::caster_id",
+            "kind": "field",
+            "signature": "pub caster_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::damage",
+            "kind": "field",
+            "signature": "pub damage: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::dir",
+            "kind": "field",
+            "signature": "pub dir: (f32, f32)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::hit_radius",
+            "kind": "field",
+            "signature": "pub hit_radius: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::launch",
+            "kind": "method",
+            "signature": "pub fn launch(spec: &AbilitySpec, caster_id: &str, from: (f32, f32), cast: &ValidCast, now_ms: u64) -> Option<Self>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::launched_at_ms",
+            "kind": "field",
+            "signature": "pub launched_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::max_range",
+            "kind": "field",
+            "signature": "pub max_range: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::speed",
+            "kind": "field",
+            "signature": "pub speed: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::step",
+            "kind": "method",
+            "signature": "pub fn step( &mut self, dt_ms: u64, hit_test: &mut impl FnMut(f32, f32, f32) -> Option<String>, blocked: &mut impl FnMut(f32, f32) -> bool, ) -> ProjectileStep",
+            "docs": "Advance `dt_ms`, sub-stepping so tick-rate simulation cannot tunnel through targets (tolerance window = hit_radius per sub-step). `hit_test(x, z, radius)` returns a hit target (never the caster) or None; `blocked(x, z)` marks walls."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::traveled",
+            "kind": "field",
+            "signature": "pub traveled: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::x",
+            "kind": "field",
+            "signature": "pub x: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "Projectile::z",
+            "kind": "field",
+            "signature": "pub z: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ProjectileStep",
+            "kind": "enum",
+            "signature": "pub enum ProjectileStep { /// Still flying (new position recorded on the projectile). Flying, /// Hit `target_id` at the recorded position; despawn. Hit { target_id: String }, /// Ran out of range or was blocked; despawn. Expired, }",
+            "docs": "The outcome of one projectile step."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ProjectileStep::Expired",
+            "kind": "variant",
+            "signature": "Expired",
+            "docs": "Ran out of range or was blocked; despawn."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ProjectileStep::Flying",
+            "kind": "variant",
+            "signature": "Flying",
+            "docs": "Still flying (new position recorded on the projectile)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ProjectileStep::Hit",
+            "kind": "variant",
+            "signature": "Hit { target_id: String }",
+            "docs": "Hit `target_id` at the recorded position; despawn."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ValidCast",
+            "kind": "struct",
+            "signature": "pub struct ValidCast { pub ability_id: String, /// Normalized aim direction (projectiles). pub dir: (f32, f32), /// Clamped target point (instant/AoE). pub target: (f32, f32), }",
+            "docs": "A validated cast, ready for the hub to act on."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ValidCast::ability_id",
+            "kind": "field",
+            "signature": "pub ability_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ValidCast::dir",
+            "kind": "field",
+            "signature": "pub dir: (f32, f32)",
+            "docs": "Normalized aim direction (projectiles)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "ValidCast::target",
+            "kind": "field",
+            "signature": "pub target: (f32, f32)",
+            "docs": "Clamped target point (instant/AoE)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::abilities",
+            "name": "validate_cast",
+            "kind": "function",
+            "signature": "pub fn validate_cast( spec: &AbilitySpec, book: &mut CasterBook, caster_pos: (f32, f32), target: (f32, f32), now_ms: u64, ) -> Result<ValidCast, &'static str>",
+            "docs": "Validate a cast against the book: cooldown, resource, range. On success the cooldown is armed and the resource deducted (the cast is committed)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardId",
+            "kind": "type",
+            "signature": "pub type CardId = String;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable",
+            "kind": "struct",
+            "signature": "pub struct CardTable { pub draw: Pile, pub discard: Pile, pub hands: BTreeMap<String, Vec<CardId>>, /// Named public zones (battlefield, trick, melds, ...), in play order. pub zones: BTreeMap<String, Vec<(String, CardId)>>, pub seed: u64, }",
+            "docs": "The full table: draw pile, discard, per-actor hidden hands, and named public zones. Everything serde — one `CardTable` per match partition."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::clear_zone",
+            "kind": "method",
+            "signature": "pub fn clear_zone(&mut self, zone: &str) -> Vec<(String, CardId)>",
+            "docs": "Move every card in a zone to the discard (trick taken, turn over)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::deal",
+            "kind": "method",
+            "signature": "pub fn deal(&mut self, actors: &[String], count: usize)",
+            "docs": "Deal `count` cards to each actor (round-robin, deterministic order)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::discard",
+            "kind": "field",
+            "signature": "pub discard: Pile",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::draw",
+            "kind": "field",
+            "signature": "pub draw: Pile",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::draw_to_hand",
+            "kind": "method",
+            "signature": "pub fn draw_to_hand(&mut self, actor_id: &str) -> Option<CardId>",
+            "docs": "Draw one card into an actor's hidden hand. Recycles the discard (reshuffled with the table seed + draw count) when the deck empties."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::hand",
+            "kind": "method",
+            "signature": "pub fn hand(&self, actor_id: &str) -> &[CardId]",
+            "docs": "The caller's own hand (the ONLY read path for hidden cards)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::hand_sizes",
+            "kind": "method",
+            "signature": "pub fn hand_sizes(&self) -> BTreeMap<String, usize>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::hands",
+            "kind": "field",
+            "signature": "pub hands: BTreeMap<String, Vec<CardId>>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::new",
+            "kind": "method",
+            "signature": "pub fn new(catalog: impl IntoIterator<Item = CardId>, seed: u64) -> Self",
+            "docs": "Build a table from a card catalog and shuffle with the given seed."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::play",
+            "kind": "method",
+            "signature": "pub fn play(&mut self, actor_id: &str, card: &str, zone: &str) -> Result<(), &'static str>",
+            "docs": "Play (reveal) a card from a hand into a public zone. Fails when the caller does not hold the card — the legality floor every game gets."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::public_json",
+            "kind": "method",
+            "signature": "pub fn public_json(&self) -> Value",
+            "docs": "The public view (zones + counts, NEVER hidden cards) for model sync and spectator events."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::seed",
+            "kind": "field",
+            "signature": "pub seed: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "CardTable::zones",
+            "kind": "field",
+            "signature": "pub zones: BTreeMap<String, Vec<(String, CardId)>>",
+            "docs": "Named public zones (battlefield, trick, melds, ...), in play order."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile",
+            "kind": "struct",
+            "signature": "pub struct Pile { /// Top of the pile is the END of the vec (pop to draw). pub cards: Vec<CardId>, }",
+            "docs": "A pile with hidden order (draw deck / discard)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::cards",
+            "kind": "field",
+            "signature": "pub cards: Vec<CardId>",
+            "docs": "Top of the pile is the END of the vec (pop to draw)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::draw",
+            "kind": "method",
+            "signature": "pub fn draw(&mut self) -> Option<CardId>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::is_empty",
+            "kind": "method",
+            "signature": "pub fn is_empty(&self) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::len",
+            "kind": "method",
+            "signature": "pub fn len(&self) -> usize",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::put",
+            "kind": "method",
+            "signature": "pub fn put(&mut self, card: CardId)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "Pile::shuffle",
+            "kind": "method",
+            "signature": "pub fn shuffle(&mut self, rng: &mut Rng)",
+            "docs": "Seeded Fisher-Yates shuffle."
+        },
+        {
+            "module": "ckx_sdk::kit::play::cards",
+            "name": "standard_52",
+            "kind": "function",
+            "signature": "pub fn standard_52() -> Vec<CardId>",
+            "docs": "Build a standard 52-card catalog (\"AS\", \"2S\", ..., \"KC\") — handy for examples and tests; a real game builds its own from its hub's config."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant",
+            "kind": "struct",
+            "signature": "pub struct Combatant { pub health: Health, #[serde(default)] pub statuses: Vec<Status>, #[serde(default)] pub kills: u32, #[serde(default)] pub deaths: u32, }",
+            "docs": "Something that fights: health and the effects on it."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::afflict",
+            "kind": "method",
+            "signature": "pub fn afflict(&mut self, kind: &str, per_tick: i64, every_ms: u64, duration_ms: u64, source: Option<String>, now: u64)",
+            "docs": "Applies `kind` (replacing one of the same kind), first ticking `every_ms` from `now`."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::deaths",
+            "kind": "field",
+            "signature": "pub deaths: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::has",
+            "kind": "method",
+            "signature": "pub fn has(&self, kind: &str) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::health",
+            "kind": "field",
+            "signature": "pub health: Health",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::hit",
+            "kind": "method",
+            "signature": "pub fn hit(&mut self, amount: i64) -> DamageOutcome",
+            "docs": "Damage from `amount`; counts the death."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::kills",
+            "kind": "field",
+            "signature": "pub kills: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::new",
+            "kind": "method",
+            "signature": "pub fn new(max_hp: i64) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::statuses",
+            "kind": "field",
+            "signature": "pub statuses: Vec<Status>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Combatant::tick",
+            "kind": "method",
+            "signature": "pub fn tick(&mut self, now: u64) -> Vec<TickEffect>",
+            "docs": "Runs every tick due by `now`, drops expired effects, and returns what each did."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "ContactBook",
+            "kind": "struct",
+            "signature": "pub struct ContactBook { #[serde(default)] pub at: BTreeMap<String, u64>, }",
+            "docs": "A hostile's touch on a player, at most once per victim per cooldown."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "ContactBook::at",
+            "kind": "field",
+            "signature": "pub at: BTreeMap<String, u64>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "ContactBook::touch",
+            "kind": "method",
+            "signature": "pub fn touch(&mut self, victim: &str, victim_at: (f64, f64), attacker: (f64, f64), range: f64, cooldown_ms: u64, now: u64) -> bool",
+            "docs": "Whether the hostile at `attacker` touches the victim at `victim` (within `range`) now; when it does, the victim's cooldown starts."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Cooldowns",
+            "kind": "struct",
+            "signature": "pub struct Cooldowns { #[serde(default)] pub last: BTreeMap<String, u64>, }",
+            "docs": "Per-actor, per-action last-use times."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Cooldowns::last",
+            "kind": "field",
+            "signature": "pub last: BTreeMap<String, u64>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Cooldowns::prune",
+            "kind": "method",
+            "signature": "pub fn prune(&mut self, now: u64, older_than_ms: u64)",
+            "docs": "Forgets uses older than `older_than_ms`."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Cooldowns::remaining",
+            "kind": "method",
+            "signature": "pub fn remaining(&self, actor: &str, action: &str, cooldown_ms: u64, now: u64) -> u64",
+            "docs": "Milliseconds until `actor` may `action` again; 0 when it may now."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Cooldowns::take",
+            "kind": "method",
+            "signature": "pub fn take(&mut self, actor: &str, action: &str, cooldown_ms: u64, now: u64) -> bool",
+            "docs": "Whether `actor` may `action` at `now` with `cooldown_ms` between uses; when it may, the use is taken."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "DamageOutcome",
+            "kind": "struct",
+            "signature": "pub struct DamageOutcome { /// Health after it. pub health: i64, /// Damage actually taken (never more than the health it had). pub dealt: i64, pub killed: bool, }",
+            "docs": "What damage did."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "DamageOutcome::dealt",
+            "kind": "field",
+            "signature": "pub dealt: i64",
+            "docs": "Damage actually taken (never more than the health it had)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "DamageOutcome::health",
+            "kind": "field",
+            "signature": "pub health: i64",
+            "docs": "Health after it."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "DamageOutcome::killed",
+            "kind": "field",
+            "signature": "pub killed: bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health",
+            "kind": "struct",
+            "signature": "pub struct Health { pub current: i64, pub max: i64, }",
+            "docs": "Hit points with a maximum."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::alive",
+            "kind": "method",
+            "signature": "pub fn alive(&self) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::apply",
+            "kind": "method",
+            "signature": "pub fn apply(&mut self, amount: i64) -> DamageOutcome",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::current",
+            "kind": "field",
+            "signature": "pub current: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::heal",
+            "kind": "method",
+            "signature": "pub fn heal(&mut self, amount: i64) -> i64",
+            "docs": "Heals up to the maximum; a dead one stays dead. Returns what was healed."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::max",
+            "kind": "field",
+            "signature": "pub max: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::new",
+            "kind": "method",
+            "signature": "pub fn new(max: i64) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Health::revive",
+            "kind": "method",
+            "signature": "pub fn revive(&mut self)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "KillRecord",
+            "kind": "struct",
+            "signature": "pub struct KillRecord { pub killer: String, pub at_ms: u64, pub respawn_at_ms: u64, }",
+            "docs": "A kill: who did it, when, and when the victim comes back."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "KillRecord::at_ms",
+            "kind": "field",
+            "signature": "pub at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "KillRecord::killer",
+            "kind": "field",
+            "signature": "pub killer: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "KillRecord::respawn_at_ms",
+            "kind": "field",
+            "signature": "pub respawn_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "RespawnBook",
+            "kind": "struct",
+            "signature": "pub struct RespawnBook { #[serde(default)] pub kills: BTreeMap<String, KillRecord>, }",
+            "docs": "Kill credit and respawn timers, by victim id."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "RespawnBook::due",
+            "kind": "method",
+            "signature": "pub fn due(&mut self, now: u64) -> Vec<String>",
+            "docs": "Victims whose respawn came due, taken out of the book."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "RespawnBook::is_down",
+            "kind": "method",
+            "signature": "pub fn is_down(&self, victim: &str) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "RespawnBook::kills",
+            "kind": "field",
+            "signature": "pub kills: BTreeMap<String, KillRecord>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "RespawnBook::record_kill",
+            "kind": "method",
+            "signature": "pub fn record_kill(&mut self, victim: &str, killer: &str, now: u64, respawn_ms: u64)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status",
+            "kind": "struct",
+            "signature": "pub struct Status { pub kind: String, pub until_ms: u64, pub per_tick: i64, pub every_ms: u64, pub next_ms: u64, /// Who applied it, for kill credit. #[serde(default)] pub source: Option<String>, }",
+            "docs": "A status effect: `per_tick` damage (negative heals) every `every_ms` until `until_ms`."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::every_ms",
+            "kind": "field",
+            "signature": "pub every_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::kind",
+            "kind": "field",
+            "signature": "pub kind: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::next_ms",
+            "kind": "field",
+            "signature": "pub next_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::per_tick",
+            "kind": "field",
+            "signature": "pub per_tick: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::source",
+            "kind": "field",
+            "signature": "pub source: Option<String>",
+            "docs": "Who applied it, for kill credit."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "Status::until_ms",
+            "kind": "field",
+            "signature": "pub until_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "TickEffect",
+            "kind": "struct",
+            "signature": "pub struct TickEffect { pub kind: String, pub outcome: DamageOutcome, pub source: Option<String>, }",
+            "docs": "What a status tick did to a combatant."
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "TickEffect::kind",
+            "kind": "field",
+            "signature": "pub kind: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "TickEffect::outcome",
+            "kind": "field",
+            "signature": "pub outcome: DamageOutcome",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "TickEffect::source",
+            "kind": "field",
+            "signature": "pub source: Option<String>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::combat",
+            "name": "in_reach",
+            "kind": "function",
+            "signature": "pub fn in_reach(attacker: (f64, f64), target: (f64, f64), range: f64) -> bool",
+            "docs": "Whether `target` is within `range` chunks of `attacker` on the ground."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules",
+            "kind": "struct",
+            "signature": "pub struct Rules { /// Units a second. pub max_speed: f64, /// A move this far or more at once is refused. pub teleport: f64, /// `(min_x, min_z, max_x, max_z)`, when there are any. pub bounds: Option<(f64, f64, f64, f64)>, /// Slack on `max_speed` for jitter in the reports' timing (1.25 lets a report be 25% fast). pub grace: f64, }",
+            "docs": "What a player's movement may do, in the hub's own units."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules::bounds",
+            "kind": "field",
+            "signature": "pub bounds: Option<(f64, f64, f64, f64)>",
+            "docs": "`(min_x, min_z, max_x, max_z)`, when there are any."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules::default",
+            "kind": "method",
+            "signature": "fn default() -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules::grace",
+            "kind": "field",
+            "signature": "pub grace: f64",
+            "docs": "Slack on `max_speed` for jitter in the reports' timing (1.25 lets a report be 25% fast)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules::max_speed",
+            "kind": "field",
+            "signature": "pub max_speed: f64",
+            "docs": "Units a second."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Rules::teleport",
+            "kind": "field",
+            "signature": "pub teleport: f64",
+            "docs": "A move this far or more at once is refused."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "STRIKE_WINDOW_MS",
+            "kind": "const",
+            "signature": "pub const STRIKE_WINDOW_MS: u64 = 10_000;",
+            "docs": "How long strikes are remembered after the last one."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Verdict",
+            "kind": "struct",
+            "signature": "pub struct Verdict { pub at: (f64, f64), pub violation: Option<Violation>, }",
+            "docs": "The position the hub keeps for a report, and what was wrong with it."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Verdict::at",
+            "kind": "field",
+            "signature": "pub at: (f64, f64)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Verdict::violation",
+            "kind": "field",
+            "signature": "pub violation: Option<Violation>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Violation",
+            "kind": "struct",
+            "signature": "pub struct Violation { pub kind: ViolationKind, pub detail: String, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Violation::detail",
+            "kind": "field",
+            "signature": "pub detail: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Violation::kind",
+            "kind": "field",
+            "signature": "pub kind: ViolationKind",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "ViolationKind",
+            "kind": "enum",
+            "signature": "pub enum ViolationKind { Speed, Teleport, Bounds, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "ViolationKind::Bounds",
+            "kind": "variant",
+            "signature": "Bounds",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "ViolationKind::Speed",
+            "kind": "variant",
+            "signature": "Speed",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "ViolationKind::Teleport",
+            "kind": "variant",
+            "signature": "Teleport",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "ViolationKind::as_str",
+            "kind": "method",
+            "signature": "pub fn as_str(self) -> &'static str",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden",
+            "kind": "struct",
+            "signature": "pub struct Warden { /// The position kept, and when. pub last: Option<(f64, f64, u64)>, pub strikes: u32, pub last_strike_ms: u64, }",
+            "docs": "One player's movement as the hub last accepted it."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::at",
+            "kind": "method",
+            "signature": "pub fn at(at: (f64, f64), now: u64) -> Self",
+            "docs": "A warden that starts from `at`: a spawn, a respawn, a place the hub moved the player to."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::check",
+            "kind": "method",
+            "signature": "pub fn check(&mut self, rules: &Rules, claimed: (f64, f64), now: u64) -> Verdict",
+            "docs": "Checks a reported position and keeps the one the rules allow."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::last",
+            "kind": "field",
+            "signature": "pub last: Option<(f64, f64, u64)>",
+            "docs": "The position kept, and when."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::last_strike_ms",
+            "kind": "field",
+            "signature": "pub last_strike_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::place",
+            "kind": "method",
+            "signature": "pub fn place(&mut self, at: (f64, f64), now: u64)",
+            "docs": "Moves the player where the hub says, with no check."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::position",
+            "kind": "method",
+            "signature": "pub fn position(&self) -> Option<(f64, f64)>",
+            "docs": "The position kept."
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::strikes",
+            "kind": "field",
+            "signature": "pub strikes: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::movement",
+            "name": "Warden::strikes",
+            "kind": "method",
+            "signature": "pub fn strikes(&self, now: u64) -> u32",
+            "docs": "Strikes in the current window."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "MatchSummary",
+            "kind": "struct",
+            "signature": "pub struct MatchSummary { pub winner_id: Option<String>, pub standings: Vec<Standing>, pub rounds_played: u32, pub decided_by: String, }",
+            "docs": "The published result of a decided match."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "MatchSummary::decided_by",
+            "kind": "field",
+            "signature": "pub decided_by: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "MatchSummary::rounds_played",
+            "kind": "field",
+            "signature": "pub rounds_played: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "MatchSummary::standings",
+            "kind": "field",
+            "signature": "pub standings: Vec<Standing>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "MatchSummary::winner_id",
+            "kind": "field",
+            "signature": "pub winner_id: Option<String>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook",
+            "kind": "struct",
+            "signature": "pub struct ScoreBook { pub scores: BTreeMap<String, i64>, /// Actors still in the running (forfeits/eliminations remove). pub active: Vec<String>, pub decided: Option<MatchSummary>, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::active",
+            "kind": "field",
+            "signature": "pub active: Vec<String>",
+            "docs": "Actors still in the running (forfeits/eliminations remove)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::award",
+            "kind": "method",
+            "signature": "pub fn award(&mut self, actor_id: &str, points: i64) -> i64",
+            "docs": "Add points (the hub calls this from validated moves only)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::decided",
+            "kind": "field",
+            "signature": "pub decided: Option<MatchSummary>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::eliminate",
+            "kind": "method",
+            "signature": "pub fn eliminate(&mut self, actor_id: &str)",
+            "docs": "Remove an actor from contention (death/forfeit/disconnect)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::evaluate",
+            "kind": "method",
+            "signature": "pub fn evaluate(&mut self, condition: &WinCondition, rounds_played: u32, now_ms: u64) -> Option<&MatchSummary>",
+            "docs": "Evaluate the condition; the first decision sticks (idempotent after)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::new",
+            "kind": "method",
+            "signature": "pub fn new(actors: impl IntoIterator<Item = String>) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::score",
+            "kind": "method",
+            "signature": "pub fn score(&self, actor_id: &str) -> i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::scores",
+            "kind": "field",
+            "signature": "pub scores: BTreeMap<String, i64>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "ScoreBook::standings",
+            "kind": "method",
+            "signature": "pub fn standings(&self) -> Vec<Standing>",
+            "docs": "Standings ordered by score desc (stable; rank is 1-based, ties share the earlier rank's position order but distinct ranks — simple v1)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "Standing",
+            "kind": "struct",
+            "signature": "pub struct Standing { pub actor_id: String, pub score: i64, pub rank: u32, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "Standing::actor_id",
+            "kind": "field",
+            "signature": "pub actor_id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "Standing::rank",
+            "kind": "field",
+            "signature": "pub rank: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "Standing::score",
+            "kind": "field",
+            "signature": "pub score: i64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "WinCondition",
+            "kind": "enum",
+            "signature": "pub enum WinCondition { /// First to reach `target` points. ScoreReached { target: i64 }, /// Highest score when round `final_round` completes. BestOfRounds { final_round: u32 }, /// Last active participant standing (driven by forfeits/eliminations). LastStanding, /// Survive until the timer: highest score at `ends_at_ms`. TimeLimit { ends_at_ms: u64 }, }",
+            "docs": "When is the match decided?"
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "WinCondition::BestOfRounds",
+            "kind": "variant",
+            "signature": "BestOfRounds { final_round: u32 }",
+            "docs": "Highest score when round `final_round` completes."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "WinCondition::LastStanding",
+            "kind": "variant",
+            "signature": "LastStanding",
+            "docs": "Last active participant standing (driven by forfeits/eliminations)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "WinCondition::ScoreReached",
+            "kind": "variant",
+            "signature": "ScoreReached { target: i64 }",
+            "docs": "First to reach `target` points."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "WinCondition::TimeLimit",
+            "kind": "variant",
+            "signature": "TimeLimit { ends_at_ms: u64 }",
+            "docs": "Survive until the timer: highest score at `ends_at_ms`."
+        },
+        {
+            "module": "ckx_sdk::kit::play::score",
+            "name": "summary_json",
+            "kind": "function",
+            "signature": "pub fn summary_json(summary: &MatchSummary) -> Value",
+            "docs": "The summary as the JSON shape clients/events consume."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Course",
+            "kind": "struct",
+            "signature": "pub struct Course { pub gates: Vec<Gate>, pub laps: u32, }",
+            "docs": "A course: ordered gates; a lap = passing every gate in order (gate 0 is the start/finish line)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Course::gates",
+            "kind": "field",
+            "signature": "pub gates: Vec<Gate>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Course::laps",
+            "kind": "field",
+            "signature": "pub laps: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GHOST_MAX_FRAMES",
+            "kind": "const",
+            "signature": "pub const GHOST_MAX_FRAMES: usize = 600;",
+            "docs": "Ghost tracks are capped so a long run cannot blow the state budget."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Gate",
+            "kind": "struct",
+            "signature": "pub struct Gate { pub x: f32, pub z: f32, pub radius: f32, }",
+            "docs": "One ordered gate on a course."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Gate::radius",
+            "kind": "field",
+            "signature": "pub radius: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Gate::x",
+            "kind": "field",
+            "signature": "pub x: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "Gate::z",
+            "kind": "field",
+            "signature": "pub z: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack",
+            "kind": "struct",
+            "signature": "pub struct GhostTrack { pub frames: Vec<(u32, f32, f32, f32, f32)>, pub started_at_ms: u64, }",
+            "docs": "A compact recorded pose track: (offset ms, x, y, z, yaw). Sampled at the recorder's cadence, replayed with linear interpolation."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack::duration_ms",
+            "kind": "method",
+            "signature": "pub fn duration_ms(&self) -> u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack::frame_at",
+            "kind": "method",
+            "signature": "pub fn frame_at(&self, offset_ms: u32) -> Option<(f32, f32, f32, f32)>",
+            "docs": "Interpolated pose at `offset_ms` into the replay (clamped to ends)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack::frames",
+            "kind": "field",
+            "signature": "pub frames: Vec<(u32, f32, f32, f32, f32)>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack::record",
+            "kind": "method",
+            "signature": "pub fn record(&mut self, now_ms: u64, x: f32, y: f32, z: f32, yaw: f32)",
+            "docs": "Record one frame (call per sample while the run is live)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "GhostTrack::started_at_ms",
+            "kind": "field",
+            "signature": "pub started_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer",
+            "kind": "struct",
+            "signature": "pub struct RunTimer { pub next_gate: usize, pub lap: u32, pub started_at_ms: u64, pub lap_started_at_ms: u64, pub splits_ms: Vec<u64>, pub best_lap_ms: u64, pub finished: bool, pub total_ms: u64, }",
+            "docs": "One racer's live run state."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::best_lap_ms",
+            "kind": "field",
+            "signature": "pub best_lap_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::feed",
+            "kind": "method",
+            "signature": "pub fn feed(&mut self, course: &Course, pos: (f32, f32), now_ms: u64) -> Vec<TimingEvent>",
+            "docs": "Feed one pose sample; returns the timing events it produced. The run starts when the racer first touches gate 0."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::finished",
+            "kind": "field",
+            "signature": "pub finished: bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::lap",
+            "kind": "field",
+            "signature": "pub lap: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::lap_started_at_ms",
+            "kind": "field",
+            "signature": "pub lap_started_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::next_gate",
+            "kind": "field",
+            "signature": "pub next_gate: usize",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::splits_ms",
+            "kind": "field",
+            "signature": "pub splits_ms: Vec<u64>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::started_at_ms",
+            "kind": "field",
+            "signature": "pub started_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "RunTimer::total_ms",
+            "kind": "field",
+            "signature": "pub total_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "TimingEvent",
+            "kind": "enum",
+            "signature": "pub enum TimingEvent { Started { at_ms: u64 }, Checkpoint { gate: usize, split_ms: u64 }, LapCompleted { lap: u32, lap_ms: u64, best: bool }, Finished { total_ms: u64, best_lap_ms: u64 }, }",
+            "docs": "Events produced by feeding poses through a run timer."
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "TimingEvent::Checkpoint",
+            "kind": "variant",
+            "signature": "Checkpoint { gate: usize, split_ms: u64 }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "TimingEvent::Finished",
+            "kind": "variant",
+            "signature": "Finished { total_ms: u64, best_lap_ms: u64 }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "TimingEvent::LapCompleted",
+            "kind": "variant",
+            "signature": "LapCompleted { lap: u32, lap_ms: u64, best: bool }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::timing",
+            "name": "TimingEvent::Started",
+            "kind": "variant",
+            "signature": "Started { at_ms: u64 }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound",
+            "kind": "struct",
+            "signature": "pub struct RevealRound { pub expected: Vec<String>, pub submissions: Vec<(String, serde_json::Value)>, pub deadline_ms: u64, }",
+            "docs": "Collects one hidden submission per actor, then resolves when everyone (or the deadline) is in. Submissions stay in the hub until the reveal."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::complete",
+            "kind": "method",
+            "signature": "pub fn complete(&self) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::deadline_ms",
+            "kind": "field",
+            "signature": "pub deadline_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::expected",
+            "kind": "field",
+            "signature": "pub expected: Vec<String>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::new",
+            "kind": "method",
+            "signature": "pub fn new(expected: Vec<String>, now_ms: u64, window_ms: u64) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::ready",
+            "kind": "method",
+            "signature": "pub fn ready(&self, now_ms: u64) -> bool",
+            "docs": "Ready to reveal: everyone submitted, or the window closed."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::reveal",
+            "kind": "method",
+            "signature": "pub fn reveal(self) -> Vec<(String, serde_json::Value)>",
+            "docs": "Consume and return all submissions (the reveal)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::submissions",
+            "kind": "field",
+            "signature": "pub submissions: Vec<(String, serde_json::Value)>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "RevealRound::submit",
+            "kind": "method",
+            "signature": "pub fn submit(&mut self, actor_id: &str, payload: serde_json::Value) -> Result<(), &'static str>",
+            "docs": "Record a submission. Duplicates and strangers are rejected."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TimeoutPolicy",
+            "kind": "enum",
+            "signature": "pub enum TimeoutPolicy { /// The actor's turn is skipped (turn passes on). #[default] Skip, /// The actor forfeits and is removed from the order. Forfeit, /// Nothing happens automatically (a human host decides). Wait, }",
+            "docs": "What happens when a turn timer expires."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TimeoutPolicy::Forfeit",
+            "kind": "variant",
+            "signature": "Forfeit",
+            "docs": "The actor forfeits and is removed from the order."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TimeoutPolicy::Skip",
+            "kind": "variant",
+            "signature": "Skip",
+            "docs": "The actor's turn is skipped (turn passes on)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TimeoutPolicy::Wait",
+            "kind": "variant",
+            "signature": "Wait",
+            "docs": "Nothing happens automatically (a human host decides)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnActor",
+            "kind": "struct",
+            "signature": "pub struct TurnActor { /// Stable id (a player id, a unit's id, ...). pub id: String, /// Higher acts first; ties keep insertion order (stable sort). pub initiative: i64, /// Forfeited/dead actors stay recorded but are skipped. pub active: bool, }",
+            "docs": "One participant in the order."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnActor::active",
+            "kind": "field",
+            "signature": "pub active: bool",
+            "docs": "Forfeited/dead actors stay recorded but are skipped."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnActor::id",
+            "kind": "field",
+            "signature": "pub id: String",
+            "docs": "Stable id (a player id, a unit's id, ...)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnActor::initiative",
+            "kind": "field",
+            "signature": "pub initiative: i64",
+            "docs": "Higher acts first; ties keep insertion order (stable sort)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent",
+            "kind": "enum",
+            "signature": "pub enum TurnEvent { TurnStarted { actor_id: String, round: u32, turn_in_round: u32, }, RoundStarted { round: u32, }, ActorSkipped { actor_id: String, }, ActorForfeited { actor_id: String, }, /// One (or zero) active actors remain. OrderExhausted, }",
+            "docs": "An event the hub should announce (turn changed, round advanced, ...)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent::ActorForfeited",
+            "kind": "variant",
+            "signature": "ActorForfeited { actor_id: String, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent::ActorSkipped",
+            "kind": "variant",
+            "signature": "ActorSkipped { actor_id: String, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent::OrderExhausted",
+            "kind": "variant",
+            "signature": "OrderExhausted",
+            "docs": "One (or zero) active actors remain."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent::RoundStarted",
+            "kind": "variant",
+            "signature": "RoundStarted { round: u32, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnEvent::TurnStarted",
+            "kind": "variant",
+            "signature": "TurnStarted { actor_id: String, round: u32, turn_in_round: u32, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder",
+            "kind": "struct",
+            "signature": "pub struct TurnOrder { pub actors: Vec<TurnActor>, /// Index into `actors` of the current turn holder. pub current: usize, pub round: u32, pub turn_in_round: u32, /// Current turn deadline (0 = no timer). pub deadline_ms: u64, pub turn_duration_ms: u64, pub timeout_policy: TimeoutPolicy, started: bool, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::active_count",
+            "kind": "method",
+            "signature": "pub fn active_count(&self) -> usize",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::actors",
+            "kind": "field",
+            "signature": "pub actors: Vec<TurnActor>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::advance",
+            "kind": "method",
+            "signature": "pub fn advance(&mut self, now_ms: u64) -> Vec<TurnEvent>",
+            "docs": "Advance to the next active actor (call when the current turn ends)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::current",
+            "kind": "field",
+            "signature": "pub current: usize",
+            "docs": "Index into `actors` of the current turn holder."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::current_actor",
+            "kind": "method",
+            "signature": "pub fn current_actor(&self) -> Option<&TurnActor>",
+            "docs": "The current turn holder (None before start / after exhaustion)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::deadline_ms",
+            "kind": "field",
+            "signature": "pub deadline_ms: u64",
+            "docs": "Current turn deadline (0 = no timer)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::forfeit",
+            "kind": "method",
+            "signature": "pub fn forfeit(&mut self, actor_id: &str, now_ms: u64) -> Vec<TurnEvent>",
+            "docs": "Remove an actor from the running order (death, rage-quit). Advances the turn when it was theirs."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::new",
+            "kind": "method",
+            "signature": "pub fn new(actors: impl IntoIterator<Item = (String, i64)>, turn_duration_ms: u64, timeout_policy: TimeoutPolicy) -> Self",
+            "docs": "Build an order from (id, initiative) pairs; sorts by initiative descending (stable — ties keep the given order)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::remaining_ms",
+            "kind": "method",
+            "signature": "pub fn remaining_ms(&self, now_ms: u64) -> Option<u64>",
+            "docs": "Milliseconds left on the current turn (None = no timer / not started)."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::round",
+            "kind": "field",
+            "signature": "pub round: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::start",
+            "kind": "method",
+            "signature": "pub fn start(&mut self, now_ms: u64) -> Vec<TurnEvent>",
+            "docs": "Begin round 1, turn 1. Returns the announce events."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::tick",
+            "kind": "method",
+            "signature": "pub fn tick(&mut self, now_ms: u64) -> Vec<TurnEvent>",
+            "docs": "Apply the timeout policy if the current turn's deadline passed."
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::timeout_policy",
+            "kind": "field",
+            "signature": "pub timeout_policy: TimeoutPolicy",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::turn_duration_ms",
+            "kind": "field",
+            "signature": "pub turn_duration_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::play::turns",
+            "name": "TurnOrder::turn_in_round",
+            "kind": "field",
+            "signature": "pub turn_in_round: u32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "CHUNK_BLOCKS",
+            "kind": "const",
+            "signature": "pub const CHUNK_BLOCKS: f64 = 16.0;",
+            "docs": "Blocks in a chunk's edge, for the engine pose's world coordinates."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "POSE_BYTES",
+            "kind": "const",
+            "signature": "pub const POSE_BYTES: usize = 48;",
+            "docs": "The engine pose's length."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen",
+            "kind": "struct",
+            "signature": "pub struct Seen { pub player: u64, pub uuid: String, pub x: f64, pub y: f64, pub z: f64, /// Placed from the actor's state, not its chunk's centre. pub precise: bool, }",
+            "docs": "One player near the place, as last seen."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::player",
+            "kind": "field",
+            "signature": "pub player: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::precise",
+            "kind": "field",
+            "signature": "pub precise: bool",
+            "docs": "Placed from the actor's state, not its chunk's centre."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::uuid",
+            "kind": "field",
+            "signature": "pub uuid: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::x",
+            "kind": "field",
+            "signature": "pub x: f64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::y",
+            "kind": "field",
+            "signature": "pub y: f64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Seen::z",
+            "kind": "field",
+            "signature": "pub z: f64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Track",
+            "kind": "struct",
+            "signature": "pub struct Track { pub x: f64, pub z: f64, pub at: u64, /// Chunks a second between the last two scans; 0 for the first. pub speed: f64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Track::at",
+            "kind": "field",
+            "signature": "pub at: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Track::speed",
+            "kind": "field",
+            "signature": "pub speed: f64",
+            "docs": "Chunks a second between the last two scans; 0 for the first."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Track::x",
+            "kind": "field",
+            "signature": "pub x: f64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Track::z",
+            "kind": "field",
+            "signature": "pub z: f64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Tracker",
+            "kind": "struct",
+            "signature": "pub struct Tracker { #[serde(default)] pub last: BTreeMap<u64, Track>, }",
+            "docs": "Players' recent positions and speeds, from one scan to the next."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Tracker::last",
+            "kind": "field",
+            "signature": "pub last: BTreeMap<u64, Track>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Tracker::position",
+            "kind": "method",
+            "signature": "pub fn position(&self, player: u64) -> Option<(f64, f64)>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "Tracker::update",
+            "kind": "method",
+            "signature": "pub fn update(&mut self, seen: &[Seen], now: u64) -> BTreeMap<u64, f64>",
+            "docs": "Takes a scan at `now`; players not in it are forgotten. Returns each player's speed."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "ground_distance",
+            "kind": "function",
+            "signature": "pub fn ground_distance(a: (f64, f64), b: (f64, f64)) -> f64",
+            "docs": "Distance on the ground (x and z), in chunks."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "nearby",
+            "kind": "function",
+            "signature": "pub fn nearby(ctx: &Ctx, center: ChunkPos, radius: u8) -> Result<Vec<Seen>, CallError>",
+            "docs": "The players within `radius` chunks (at most 3 across, 1 up and down) of `center`."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "players_among",
+            "kind": "function",
+            "signature": "pub fn players_among(actors: &[Actor]) -> Vec<Seen>",
+            "docs": "Every player among `actors`, once each (the first actor a player has)."
+        },
+        {
+            "module": "ckx_sdk::kit::presence",
+            "name": "position_of",
+            "kind": "function",
+            "signature": "pub fn position_of(actor: &Actor) -> (f64, f64, f64, bool)",
+            "docs": "Where an actor is, in chunks, and whether that came from its state."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng",
+            "kind": "struct",
+            "signature": "pub struct Rng { state: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::below",
+            "kind": "method",
+            "signature": "pub fn below(&mut self, n: u64) -> u64",
+            "docs": "Uniform in `[0, n)`; 0 when `n` is 0."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::chance",
+            "kind": "method",
+            "signature": "pub fn chance(&mut self, p: f64) -> bool",
+            "docs": "True with probability `p` (clamped to `[0, 1]`)."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::default",
+            "kind": "method",
+            "signature": "fn default() -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::f32",
+            "kind": "method",
+            "signature": "pub fn f32(&mut self) -> f32",
+            "docs": "Uniform in `[0, 1)`, single precision."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::f64",
+            "kind": "method",
+            "signature": "pub fn f64(&mut self) -> f64",
+            "docs": "Uniform in `[0, 1)`."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::next_u64",
+            "kind": "method",
+            "signature": "pub fn next_u64(&mut self) -> u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::pick",
+            "kind": "method",
+            "signature": "pub fn pick<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::range",
+            "kind": "method",
+            "signature": "pub fn range(&mut self, lo: i64, hi: i64) -> i64",
+            "docs": "Uniform in `[lo, hi]`, both included; `lo` when `hi` is not above it."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::range_i64",
+            "kind": "method",
+            "signature": "pub fn range_i64(&mut self, lo: i64, hi: i64) -> i64",
+            "docs": "Uniform in `[lo, hi]`, both included: [`Rng::range`]."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::seed_from",
+            "kind": "method",
+            "signature": "pub fn seed_from(text: &str) -> u64",
+            "docs": "A seed from text: a key, a name."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::seeded",
+            "kind": "method",
+            "signature": "pub fn seeded(seed: u64) -> Self",
+            "docs": "A generator seeded with `seed`; 0 counts as 1, which xorshift needs."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::shuffle",
+            "kind": "method",
+            "signature": "pub fn shuffle<T>(&mut self, items: &mut [T])",
+            "docs": "Shuffles in place (Fisher-Yates)."
+        },
+        {
+            "module": "ckx_sdk::kit::rng",
+            "name": "Rng::weighted",
+            "kind": "method",
+            "signature": "pub fn weighted(&mut self, weights: &[u64]) -> Option<usize>",
+            "docs": "The index of one weight, chosen in proportion to the weights; `None` when they sum to nothing."
+        },
+        {
+            "module": "ckx_sdk::kit::shard",
+            "name": "around",
+            "kind": "function",
+            "signature": "pub fn around(x: i64, z: i64, size: i64, radius: i64) -> Vec<String>",
+            "docs": "The keys of the shards within `radius` shards of the one holding `(x, z)`, its own first, then row by row."
+        },
+        {
+            "module": "ckx_sdk::kit::shard",
+            "name": "centre",
+            "kind": "function",
+            "signature": "pub fn centre(x: i64, z: i64, size: i64) -> (i64, i64)",
+            "docs": "The shard's centre chunk for chunk `(x, z)`. `size` is at least 1."
+        },
+        {
+            "module": "ckx_sdk::kit::shard",
             "name": "key",
             "kind": "function",
-            "signature": "pub fn key(x: i64, z: i64, size: i64) -> String",
-            "docs": "The key of the shard that holds chunk `(x, z)`."
+            "signature": "pub fn key(x: i64, z: i64, size: i64) -> String",
+            "docs": "The key of the shard that holds chunk `(x, z)`."
+        },
+        {
+            "module": "ckx_sdk::kit::shard",
+            "name": "parse",
+            "kind": "function",
+            "signature": "pub fn parse(key: &str) -> Option<(i64, i64)>",
+            "docs": "The centre chunk a key names, or `None` when it is not `\"<x>,<z>\"`."
+        },
+        {
+            "module": "ckx_sdk::kit::sim",
+            "name": "daycycle",
+            "kind": "module",
+            "signature": "pub mod daycycle;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim",
+            "name": "nodes",
+            "kind": "module",
+            "signature": "pub mod nodes;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim",
+            "name": "waves",
+            "kind": "module",
+            "signature": "pub mod waves;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim",
+            "name": "weather",
+            "kind": "module",
+            "signature": "pub mod weather;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim",
+            "name": "zones",
+            "kind": "module",
+            "signature": "pub mod zones;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DEFAULT_DAY_LENGTH_MS",
+            "kind": "const",
+            "signature": "pub const DEFAULT_DAY_LENGTH_MS: u64 = 1_200_000;",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle",
+            "kind": "struct",
+            "signature": "pub struct DayCycle { pub day_length_ms: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::day_index",
+            "kind": "method",
+            "signature": "pub fn day_index(&self, now_ms: u64) -> u64",
+            "docs": "Day number since epoch (season math, daily resets)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::day_length_ms",
+            "kind": "field",
+            "signature": "pub day_length_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::default",
+            "kind": "method",
+            "signature": "fn default() -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::is_night",
+            "kind": "method",
+            "signature": "pub fn is_night(&self, now_ms: u64) -> bool",
+            "docs": "Night when sin(phase*TAU) dips below -0.05."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::new",
+            "kind": "method",
+            "signature": "pub fn new(day_length_ms: u64) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::phase",
+            "kind": "method",
+            "signature": "pub fn phase(&self, now_ms: u64) -> f32",
+            "docs": "Phase in [0, 1): 0 = day start, 0.5 = day/night boundary region."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::daycycle",
+            "name": "DayCycle::sun",
+            "kind": "method",
+            "signature": "pub fn sun(&self, now_ms: u64) -> f32",
+            "docs": "Sun height in [-1, 1] (drive lighting / spawn weights)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "HarvestOutcome",
+            "kind": "struct",
+            "signature": "pub struct HarvestOutcome { pub harvested: bool, pub depleted: bool, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "HarvestOutcome::depleted",
+            "kind": "field",
+            "signature": "pub depleted: bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "HarvestOutcome::harvested",
+            "kind": "field",
+            "signature": "pub harvested: bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "Node",
+            "kind": "struct",
+            "signature": "pub struct Node { pub phase: NodePhase, /// Remaining harvests before depletion (0 = infinite until depleted /// explicitly). pub charges: u32, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "Node::charges",
+            "kind": "field",
+            "signature": "pub charges: u32",
+            "docs": "Remaining harvests before depletion (0 = infinite until depleted explicitly)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "Node::phase",
+            "kind": "field",
+            "signature": "pub phase: NodePhase",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePhase",
+            "kind": "enum",
+            "signature": "pub enum NodePhase { #[default] Ready, /// Depleted; respawns at the embedded time. Respawning { at_ms: u64 }, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePhase::Ready",
+            "kind": "variant",
+            "signature": "Ready",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePhase::Respawning",
+            "kind": "variant",
+            "signature": "Respawning { at_ms: u64 }",
+            "docs": "Depleted; respawns at the embedded time."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool",
+            "kind": "struct",
+            "signature": "pub struct NodePool { pub nodes: BTreeMap<String, Node>, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool::ensure",
+            "kind": "method",
+            "signature": "pub fn ensure(&mut self, id: &str, charges: u32) -> &mut Node",
+            "docs": "Register a node (idempotent; keeps existing state)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool::harvest",
+            "kind": "method",
+            "signature": "pub fn harvest(&mut self, id: &str, now_ms: u64, respawn_ms: u64) -> HarvestOutcome",
+            "docs": "Attempt a harvest. Depletes when charges run out."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool::is_ready",
+            "kind": "method",
+            "signature": "pub fn is_ready(&self, id: &str) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool::nodes",
+            "kind": "field",
+            "signature": "pub nodes: BTreeMap<String, Node>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::nodes",
+            "name": "NodePool::tick",
+            "kind": "method",
+            "signature": "pub fn tick(&mut self, now_ms: u64, recharge: u32) -> Vec<String>",
+            "docs": "Tick respawns: returns ids that just came back (re-arm charges)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveDef",
+            "kind": "struct",
+            "signature": "pub struct WaveDef { /// Entries: (unit id, count). pub units: Vec<(String, u32)>, /// Delay after the previous wave clears (or starts, for timed mode). pub delay_ms: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveDef::delay_ms",
+            "kind": "field",
+            "signature": "pub delay_ms: u64",
+            "docs": "Delay after the previous wave clears (or starts, for timed mode)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveDef::units",
+            "kind": "field",
+            "signature": "pub units: Vec<(String, u32)>",
+            "docs": "Entries: (unit id, count)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveEvent",
+            "kind": "enum",
+            "signature": "pub enum WaveEvent { /// Spawn this wave's units now. Start(usize), Finished, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveEvent::Finished",
+            "kind": "variant",
+            "signature": "Finished",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveEvent::Start",
+            "kind": "variant",
+            "signature": "Start(usize)",
+            "docs": "Spawn this wave's units now."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WavePhase",
+            "kind": "enum",
+            "signature": "pub enum WavePhase { /// Before wave `next` starts; starts at the embedded time. Countdown { next: usize, starts_at_ms: u64 }, /// Wave `index` is live. Active { index: usize }, /// All waves done. Complete, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WavePhase::Active",
+            "kind": "variant",
+            "signature": "Active { index: usize }",
+            "docs": "Wave `index` is live."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WavePhase::Complete",
+            "kind": "variant",
+            "signature": "Complete",
+            "docs": "All waves done."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WavePhase::Countdown",
+            "kind": "variant",
+            "signature": "Countdown { next: usize, starts_at_ms: u64 }",
+            "docs": "Before wave `next` starts; starts at the embedded time."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveSchedule",
+            "kind": "struct",
+            "signature": "pub struct WaveSchedule { pub phase: WavePhase, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveSchedule::default",
+            "kind": "method",
+            "signature": "fn default() -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveSchedule::phase",
+            "kind": "field",
+            "signature": "pub phase: WavePhase",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveSchedule::start",
+            "kind": "method",
+            "signature": "pub fn start(waves: &[WaveDef], now_ms: u64) -> Self",
+            "docs": "Arm the schedule from wave 0 with the first delay."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::waves",
+            "name": "WaveSchedule::step",
+            "kind": "method",
+            "signature": "pub fn step(&mut self, waves: &[WaveDef], now_ms: u64, active_cleared: bool) -> Option<WaveEvent>",
+            "docs": "Advance. `active_cleared` = the live wave's units are all dead."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "EVENT_WEATHER",
+            "kind": "const",
+            "signature": "pub const EVENT_WEATHER: u16 = 90;",
+            "docs": "The platform-reserved server-event type for weather/season transitions."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "Transition",
+            "kind": "struct",
+            "signature": "pub struct Transition { pub from: String, pub to: String, pub until_ms: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "Transition::from",
+            "kind": "field",
+            "signature": "pub from: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "Transition::to",
+            "kind": "field",
+            "signature": "pub to: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "Transition::until_ms",
+            "kind": "field",
+            "signature": "pub until_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherKind",
+            "kind": "struct",
+            "signature": "pub struct WeatherKind { pub id: String, /// Relative pick weight (0 disables). pub weight: u32, pub min_ms: u64, pub max_ms: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherKind::id",
+            "kind": "field",
+            "signature": "pub id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherKind::max_ms",
+            "kind": "field",
+            "signature": "pub max_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherKind::min_ms",
+            "kind": "field",
+            "signature": "pub min_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherKind::weight",
+            "kind": "field",
+            "signature": "pub weight: u32",
+            "docs": "Relative pick weight (0 disables)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherState",
+            "kind": "struct",
+            "signature": "pub struct WeatherState { pub current: String, pub since_ms: u64, pub until_ms: u64, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherState::current",
+            "kind": "field",
+            "signature": "pub current: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherState::since_ms",
+            "kind": "field",
+            "signature": "pub since_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "WeatherState::until_ms",
+            "kind": "field",
+            "signature": "pub until_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "default_kinds",
+            "kind": "function",
+            "signature": "pub fn default_kinds() -> Vec<WeatherKind>",
+            "docs": ""
         },
         {
-            "module": "ckx_sdk::kit::shard",
-            "name": "parse",
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "emit_transition",
             "kind": "function",
-            "signature": "pub fn parse(key: &str) -> Option<(i64, i64)>",
-            "docs": "The centre chunk a key names, or `None` when it is not `\"<x>,<z>\"`."
+            "signature": "pub fn emit_transition(ctx: &Ctx, at: ChunkPos, distance: u8, actor: &[u8; 32], state: &WeatherState, now_ms: u64) -> Result<()>",
+            "docs": "Sends a transition as a type-90 server event to the players within `distance` chunks of `at`, from the hub's `actor`."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "front_json",
+            "kind": "function",
+            "signature": "pub fn front_json(state: &WeatherState, now_ms: u64) -> Value",
+            "docs": "The client-facing JSON for a front (both the event body and `forecast`)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::weather",
+            "name": "step",
+            "kind": "function",
+            "signature": "pub fn step(state: &mut WeatherState, kinds: &[WeatherKind], now_ms: u64, rng: &mut Rng) -> Option<Transition>",
+            "docs": "Advance the front. Returns the transition when the front changed (emit it to clients), `None` while the current front holds."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkPhase",
+            "kind": "struct",
+            "signature": "pub struct ShrinkPhase { /// The radius this phase shrinks TO. pub radius: f32, /// How long the zone HOLDS before shrinking (the warning window). pub hold_ms: u64, /// How long the shrink itself takes (radius interpolates linearly). pub shrink_ms: u64, }",
+            "docs": "One phase of a shrinking-zone schedule."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkPhase::hold_ms",
+            "kind": "field",
+            "signature": "pub hold_ms: u64",
+            "docs": "How long the zone HOLDS before shrinking (the warning window)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkPhase::radius",
+            "kind": "field",
+            "signature": "pub radius: f32",
+            "docs": "The radius this phase shrinks TO."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkPhase::shrink_ms",
+            "kind": "field",
+            "signature": "pub shrink_ms: u64",
+            "docs": "How long the shrink itself takes (radius interpolates linearly)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone",
+            "kind": "struct",
+            "signature": "pub struct ShrinkingZone { pub center: (f32, f32), pub initial_radius: f32, pub phases: Vec<ShrinkPhase>, pub started_at_ms: u64, /// Last phase-progress marker events were emitted for (phase, stage). announced: Vec<(usize, u8)>, }",
+            "docs": "A battle-royale circle: fixed center, radius stepping down a schedule. Pure clock math — feed it `now_ms`, read `radius()` and drain events."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::center",
+            "kind": "field",
+            "signature": "pub center: (f32, f32)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::contains",
+            "kind": "method",
+            "signature": "pub fn contains(&self, pos: (f32, f32), now_ms: u64) -> bool",
+            "docs": "Is a position inside the live circle?"
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::done",
+            "kind": "method",
+            "signature": "pub fn done(&self, now_ms: u64) -> bool",
+            "docs": "Every phase fully settled?"
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::initial_radius",
+            "kind": "field",
+            "signature": "pub initial_radius: f32",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::phases",
+            "kind": "field",
+            "signature": "pub phases: Vec<ShrinkPhase>",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::poll",
+            "kind": "method",
+            "signature": "pub fn poll(&mut self, now_ms: u64) -> Vec<ZoneEvent>",
+            "docs": "Advance the announcer: returns the events newly due at `now_ms` (warning at hold start, shrinking at shrink start, settled at end, final once after the last phase)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::radius",
+            "kind": "method",
+            "signature": "pub fn radius(&self, now_ms: u64) -> f32",
+            "docs": "The circle's radius at `now_ms` (linear interpolation during shrinks)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::start",
+            "kind": "method",
+            "signature": "pub fn start(center: (f32, f32), initial_radius: f32, phases: Vec<ShrinkPhase>, now_ms: u64) -> Self",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ShrinkingZone::started_at_ms",
+            "kind": "field",
+            "signature": "pub started_at_ms: u64",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone",
+            "kind": "struct",
+            "signature": "pub struct Zone { pub id: String, pub rule: String, pub min: (f32, f32, f32), pub max: (f32, f32, f32), }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone::contains",
+            "kind": "method",
+            "signature": "pub fn contains(&self, pos: (f32, f32, f32)) -> bool",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone::id",
+            "kind": "field",
+            "signature": "pub id: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone::max",
+            "kind": "field",
+            "signature": "pub max: (f32, f32, f32)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone::min",
+            "kind": "field",
+            "signature": "pub min: (f32, f32, f32)",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "Zone::rule",
+            "kind": "field",
+            "signature": "pub rule: String",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneEvent",
+            "kind": "enum",
+            "signature": "pub enum ZoneEvent { /// A hold began: the zone will start shrinking to `to_radius` at `at_ms`. Warning { phase: usize, to_radius: f32, shrink_starts_at_ms: u64 }, /// The shrink began. Shrinking { phase: usize, to_radius: f32 }, /// The phase's target radius was reached. Settled { phase: usize, radius: f32 }, /// Every phase is done (the final circle). Final { radius: f32 }, }",
+            "docs": "Announcements a shrinking zone produces as time advances."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneEvent::Final",
+            "kind": "variant",
+            "signature": "Final { radius: f32 }",
+            "docs": "Every phase is done (the final circle)."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneEvent::Settled",
+            "kind": "variant",
+            "signature": "Settled { phase: usize, radius: f32 }",
+            "docs": "The phase's target radius was reached."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneEvent::Shrinking",
+            "kind": "variant",
+            "signature": "Shrinking { phase: usize, to_radius: f32 }",
+            "docs": "The shrink began."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneEvent::Warning",
+            "kind": "variant",
+            "signature": "Warning { phase: usize, to_radius: f32, shrink_starts_at_ms: u64 }",
+            "docs": "A hold began: the zone will start shrinking to `to_radius` at `at_ms`."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneSet",
+            "kind": "struct",
+            "signature": "pub struct ZoneSet { pub zones: Vec<Zone>, }",
+            "docs": ""
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneSet::at",
+            "kind": "method",
+            "signature": "pub fn at(&self, pos: (f32, f32, f32)) -> Vec<&Zone>",
+            "docs": "All zones containing the position."
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneSet::has_rule",
+            "kind": "method",
+            "signature": "pub fn has_rule(&self, pos: (f32, f32, f32), rule: &str) -> bool",
+            "docs": "Does any zone with this rule cover the position?"
+        },
+        {
+            "module": "ckx_sdk::kit::sim::zones",
+            "name": "ZoneSet::zones",
+            "kind": "field",
+            "signature": "pub zones: Vec<Zone>",
+            "docs": ""
         },
         {
             "module": "ckx_sdk::kit::wire",