@crowdedkingdoms/ckx-kit 0.1.1-dev.1 → 0.2.0-test.1

package/README.md

@@ -25,7 +25,7 @@ built by the platform from its source.
 ```bash
 npx @crowdedkingdoms/ckx-kit new mod my-mod
 cd my-mod
-cargo test                                  # your logic, natively
+cargo test                                  # natively, against a fake of the platform
 npx @crowdedkingdoms/ckx-kit build --mod    # the platform's build and checks
 ```
 
@@ -45,12 +45,36 @@ on the platform: Crowdy Studio, or `execModBuild` then `execModDeploy` (see
 `CKX_KIT_TARGET_DIR` shares one cargo target directory between crates, so their dependencies
 compile once.
 
+## Test
+
+`cargo test` runs your crate natively against `ckx_sdk::testing` (from `ckx-sdk` 0.9.0), which
+plays the platform. Every starter and template comes with tests written this way:
+
+```rust
+use ckx_sdk::prelude::*;
+use ckx_sdk::testing::{FakeGrid, TestHub};
+
+let grid = FakeGrid::new(7, ChunkPos::new(0, 0, 0), ChunkPos::new(3, 1, 3), 42);
+let mut m = TestHub::<GridMod>::mod_on("grid-mod", grid).unwrap();
+let hello: String = m.call_typed(Caller::Player(9), "visit", &()).unwrap();
+m.advance(60_000).unwrap(); // the test's clock: due timers run as the platform runs them
+m.restart().unwrap();       // from the hub's snapshot, its timers and watches included
+```
+
+`TestHub` and `TestSpoke` run a node as the platform does: calls from players, developers and
+other instances; timers; topics, presence, sessions and a mod's world events; snapshots and
+restarts. Each call is held to the platform's bounds (`ckx_sdk::limits`). A mod's `FakeGrid`
+answers its node API operations with the node API's rules and refusals, and the platform's mod
+rules apply: only players call it, its calls are refused, what it sends is dropped. For an app's
+own hubs and spokes, the test scripts what other types and the node API answer.
+
 ## What it does not check
 
-Fuel, memory and deadlines are measured only where the module runs: on the platform. Your
-crate's native `cargo test` runs your logic, not the platform's limits. The platform also rebuilds
-from your source, so its module's digest differs from yours (the build paths embedded in it
-differ); the checks and the CLIENT capability hash do not.
+Fuel, memory and deadlines are measured only where the module runs: on the platform. Native
+tests do not see the app's manifest either, so they hold an app's own types to no call policy
+and no node API scopes, and apply no node API rate limits. The platform also rebuilds from your
+source, so its module's digest differs from yours (the build paths embedded in it differ); the
+checks and the CLIENT capability hash do not.
 
 ## Versions
 

package/crates/ckx-sdk/Cargo.toml

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

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

@@ -1,5 +1,6 @@
-//! Host imports (see `docs/GUEST-ABI.md`). Outside wasm32 they are stubs so node logic that
-//! makes no calls can be unit tested natively.
+//! Host imports: what the sandbox gives a module. Outside wasm32 they reach the host a native
+//! test puts on its thread ([`crate::testing`]); without one, logs go to stderr, the clock is
+//! the system's and nothing else answers.
 
 #[cfg(target_arch = "wasm32")]
 mod host {
@@ -24,11 +25,6 @@ pub fn emit(inject: &[u8]) -> u32 {
     unsafe { host::emit(inject.as_ptr() as u32, inject.len() as u32) }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn emit(_inject: &[u8]) -> u32 {
-    0
-}
-
 #[cfg(target_arch = "wasm32")]
 pub fn wake_at(at_ms: u64) {
     unsafe { host::wake_at(at_ms) }
@@ -45,17 +41,6 @@ pub fn persist_now() {
     unsafe { host::persist_now() }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub fn wake_at(_at_ms: u64) {}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn watch(_req: &[u8], _on: bool) -> u64 {
-    0
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn persist_now() {}
-
 #[cfg(target_arch = "wasm32")]
 pub fn log(level: u32, msg: &str) {
     unsafe { host::log(level, msg.as_ptr() as u32, msg.len() as u32) }
@@ -86,30 +71,124 @@ pub fn node(op: &str, payload: &[u8], deadline_ms: u32) -> u64 {
     unsafe { host::node(op.as_ptr() as u32, op.len() as u32, payload.as_ptr() as u32, payload.len() as u32, deadline_ms) }
 }
 
+/// The host a native build calls instead of the sandbox. Imports that return a result answer
+/// `[status][payload]`, as the sandbox writes it into the module's memory.
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) mod native {
+    use std::cell::RefCell;
+
+    /// Each import answers as it does with no host unless the host says otherwise.
+    pub(crate) trait Host {
+        fn log(&mut self, level: u32, msg: &str) {
+            eprintln!("[ckx level {level}] {msg}");
+        }
+        fn now_ms(&mut self) -> u64 {
+            super::system_ms()
+        }
+        fn call(&mut self, _req: &[u8], _deadline_ms: u32) -> Vec<u8> {
+            Vec::new()
+        }
+        fn send(&mut self, _req: &[u8]) -> u32 {
+            8
+        }
+        fn publish(&mut self, _topic: &str, _payload: &[u8]) {}
+        fn node(&mut self, _op: &str, _payload: &[u8], _deadline_ms: u32) -> Vec<u8> {
+            Vec::new()
+        }
+        fn wake_at(&mut self, _at_ms: u64) {}
+        fn watch(&mut self, _req: &[u8], _on: bool) -> Vec<u8> {
+            Vec::new()
+        }
+        fn persist_now(&mut self) {}
+        fn emit(&mut self, _inject: &[u8]) -> u32 {
+            0
+        }
+    }
+
+    thread_local! {
+        static HOST: RefCell<Option<Box<dyn Host>>> = const { RefCell::new(None) };
+        /// The result the last import returned, which `rt::import_result` takes at once.
+        static RESULT: RefCell<Option<Vec<u8>>> = const { RefCell::new(None) };
+    }
+
+    /// Puts `host` on this thread (or takes it off) and returns the one it replaces.
+    pub(crate) fn install(host: Option<Box<dyn Host>>) -> Option<Box<dyn Host>> {
+        HOST.with(|h| std::mem::replace(&mut *h.borrow_mut(), host))
+    }
+
+    pub(crate) fn with<R>(f: impl FnOnce(&mut (dyn Host + 'static)) -> R) -> Option<R> {
+        HOST.with(|h| h.borrow_mut().as_deref_mut().map(f))
+    }
+
+    /// Keeps an import's result for `rt::import_result`: 0 is no reply, as from the sandbox.
+    pub(crate) fn result(buf: Option<Vec<u8>>) -> u64 {
+        match buf {
+            Some(b) if !b.is_empty() => {
+                RESULT.with(|r| *r.borrow_mut() = Some(b));
+                1
+            }
+            _ => 0,
+        }
+    }
+
+    pub(crate) fn take_result() -> Option<Vec<u8>> {
+        RESULT.with(|r| r.borrow_mut().take())
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn emit(inject: &[u8]) -> u32 {
+    native::with(|h| h.emit(inject)).unwrap_or(0)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn wake_at(at_ms: u64) {
+    native::with(|h| h.wake_at(at_ms));
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn watch(req: &[u8], on: bool) -> u64 {
+    native::result(native::with(|h| h.watch(req, on)))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn persist_now() {
+    native::with(|h| h.persist_now());
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn system_ms() -> u64 {
+    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0)
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn log(level: u32, msg: &str) {
-    eprintln!("[ckx level {level}] {msg}");
+    if native::with(|h| h.log(level, msg)).is_none() {
+        eprintln!("[ckx level {level}] {msg}");
+    }
 }
 
 #[cfg(not(target_arch = "wasm32"))]
 pub fn now_ms() -> u64 {
-    std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0)
+    native::with(|h| h.now_ms()).unwrap_or_else(system_ms)
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub fn call(_req: &[u8], _deadline_ms: u32) -> u64 {
-    0
+pub fn call(req: &[u8], deadline_ms: u32) -> u64 {
+    native::result(native::with(|h| h.call(req, deadline_ms)))
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub fn send(_req: &[u8]) -> u32 {
-    8
+pub fn send(req: &[u8]) -> u32 {
+    native::with(|h| h.send(req)).unwrap_or(8)
 }
 
 #[cfg(not(target_arch = "wasm32"))]
-pub fn publish(_topic: &str, _payload: &[u8]) {}
+pub fn publish(topic: &str, payload: &[u8]) {
+    native::with(|h| h.publish(topic, payload));
+}
 
 #[cfg(not(target_arch = "wasm32"))]
-pub fn node(_op: &str, _payload: &[u8], _deadline_ms: u32) -> u64 {
-    0
+pub fn node(op: &str, payload: &[u8], deadline_ms: u32) -> u64 {
+    native::result(native::with(|h| h.node(op, payload, deadline_ms)))
 }

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

@@ -505,7 +505,7 @@ mod tests {
         format!("{y:04}-{mo:02}-{d:02}T{:02}:{:02}:{:02}.{:03}Z", s / 3600, s / 60 % 60, s % 60, ms % 1000)
     }
 
-    // Generated from legacy's cron-parser 4.9.0 (cks-game-api's `computeNextRunAt`) with TZ=UTC:
+    // Generated from cron-parser 4.9.0, the legacy automations' scheduler, with TZ=UTC:
     // each expression, the instant it is asked from, and its next occurrences in order.
     const GOLDEN: &[(&str, &str, &[&str])] = &[
         ("* * * * *", "2026-09-26T12:00:00.000Z", &["2026-09-26T12:01:00.000Z", "2026-09-26T12:02:00.000Z", "2026-09-26T12:03:00.000Z"]),

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

@@ -40,14 +40,21 @@
 //! the app ([`Hub::on_presence`], root hub only) and players' connections subscribing to them
 //! ([`Hub::on_session`]). A timer can follow a cron schedule, the legacy automations' syntax:
 //! see [`cron`] and [`Ctx::timer_cron`].
+//!
+//! Nodes are unit tested natively with `cargo test`: `testing` runs one against a fake of the
+//! platform (calls, timers, events, snapshots, the node API, a mod's grid). [`limits`] has the
+//! platform's bounds.
 
 mod abi;
 pub mod cron;
 pub mod emit;
+pub mod limits;
 pub mod model;
 pub mod node;
 #[doc(hidden)]
 pub mod rt;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod testing;
 
 use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
@@ -260,6 +267,25 @@ impl Status {
         }
     }
 
+    /// The wire status code: [`Status::from_u8`] reversed.
+    pub fn as_u8(self) -> u8 {
+        match self {
+            Status::Ok => 0,
+            Status::AppError => 1,
+            Status::Busy => 2,
+            Status::Moved => 3,
+            Status::NotFound => 4,
+            Status::DeadlineExceeded => 5,
+            Status::Denied => 6,
+            Status::RateLimited => 7,
+            Status::Unavailable => 8,
+            Status::Internal => 9,
+            Status::Trapped => 10,
+            Status::BadRequest => 11,
+            Status::Unknown(other) => other,
+        }
+    }
+
     pub fn is_retryable(self) -> bool {
         matches!(self, Status::Busy | Status::Moved | Status::Unavailable | Status::RateLimited)
     }

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

@@ -0,0 +1,52 @@
+//! The platform's bounds on a node: what its sandbox and its checks hold every call, snapshot
+//! and module to. [`crate::testing`] applies the ones a native test can see.
+
+pub use crate::node::{MAX_CHUNK_STATE, MAX_VOXEL_STATE, MAX_VOXEL_WRITES};
+pub use crate::rt::{MAX_TIMERS, MAX_WATCHES, MIN_TIMER_MS};
+
+/// The largest payload a node may send in one message, and the largest reply it may return. A
+/// larger reply is answered `Internal`.
+pub const MAX_PAYLOAD: usize = 4 << 20;
+/// What one call into a node may send on, in all: messages (calls, sends, publishes, emits,
+/// node API requests, subscriptions) and bytes of their payloads. Past either, calls and node
+/// API requests answer `Busy` and publishes are dropped.
+pub const OUT_MSGS_PER_CALL: u32 = 16_384;
+pub const OUT_BYTES_PER_CALL: u64 = 32 << 20;
+/// Log lines one call may write (the rest are dropped), and the bytes of a line that are kept.
+pub const LOGS_PER_CALL: u32 = 32;
+pub const MAX_LOG_BYTES: usize = 4 << 10;
+/// The largest realtime inject a node may emit: a spatial event's header and its payload.
+pub const MAX_EMIT_BYTES: usize = 70 + crate::emit::MAX_PAYLOAD;
+/// The largest snapshot a hub may persist. A larger one fails to save, and the last one stands.
+pub const MAX_SNAPSHOT_BYTES: usize = 8 << 20;
+/// The largest module an app's node type may deploy.
+pub const ARTIFACT_MAX_BYTES: usize = 16 << 20;
+
+/// What a manifest may ask for a node type, and what it gets when it asks for nothing.
+pub mod manifest {
+    pub const MEMORY_DEFAULT_MB: u32 = 64;
+    pub const MEMORY_MAX_MB: u32 = 512;
+    pub const FUEL_DEFAULT: u64 = 50_000_000;
+    pub const FUEL_MAX: u64 = 1_000_000_000;
+    pub const DEADLINE_DEFAULT_MS: u32 = 2_000;
+    pub const DEADLINE_MAX_MS: u32 = 10_000;
+}
+
+/// What the platform gives every mod, in place of a manifest's limits.
+pub mod mods {
+    /// A mod is the hub `("mod:<name>", "<grid id>")`.
+    pub const TYPE_PREFIX: &str = "mod:";
+    pub const MEMORY_MB: u32 = 32;
+    pub const FUEL_PER_CALL: u64 = 20_000_000;
+    pub const DEADLINE_MS: u32 = 2_000;
+    /// Handler calls per second, per mod instance.
+    pub const RATE_PER_SEC: u32 = 20;
+    pub const ARTIFACT_MAX_BYTES: usize = 4 << 20;
+    /// Mods one grid may run, and one owner may hold.
+    pub const PER_GRID_MAX: usize = 8;
+    pub const PER_OWNER_MAX: usize = 64;
+    /// World events in one `$world` call, at most.
+    pub const WORLD_BATCH_MAX: usize = 512;
+    /// The node API scopes every mod holds, each confined to its grid.
+    pub const SCOPES: [&str; 3] = ["grids.read", "world.read", "world.write"];
+}

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

@@ -1,4 +1,4 @@
-//! Typed state for a hub (HS-27): what the legacy game models kept in the database, kept in the
+//! Typed state for a hub: what the legacy game models kept in the database, kept in the
 //! hub instead. Containers of declared types hold typed properties with defaults, edges relate
 //! them, and each property's visibility decides what a player may read.
 //!

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

@@ -76,12 +76,12 @@ pub struct Voxel {
     pub updated_at: Option<String>,
 }
 
-/// One voxel to write: `voxel` is its position within `chunk`. The node API refuses a position
-/// outside the range below (since ck-api v2.29.0).
+/// One voxel to write: `voxel` is its position within `chunk`.
 #[derive(Debug, Clone, PartialEq)]
 pub struct VoxelWrite {
     pub chunk: ChunkPos,
-    /// `(x, y, z)` within the chunk: 0 to 15 on each axis.
+    /// `(x, y, z)` within the chunk. Positions are the app's to define; an app on the 16×16×16
+    /// dense grid keeps to 0 to 15 on each axis.
     pub voxel: (i16, i16, i16),
     /// What a type means is up to the app.
     pub voxel_type: i16,
@@ -193,21 +193,10 @@ fn bad_request(message: impl Into<String>) -> CallError {
 
 fn op<R: DeserializeOwned>(ctx: &Ctx, name: &str, body: Value) -> Result<R, CallError> {
     let body = serde_json::to_vec(&body).map_err(|e| bad_request(e.to_string()))?;
-    let bytes = send(ctx, name, &body)?;
+    let bytes = ctx.node(name, &body)?;
     serde_json::from_slice(&bytes).map_err(|e| bad_reply(name, e))
 }
 
-#[cfg(not(test))]
-fn send(ctx: &Ctx, name: &str, body: &[u8]) -> Result<Vec<u8>, CallError> {
-    ctx.node(name, body)
-}
-
-/// Unit tests stand in for the game API.
-#[cfg(test)]
-fn send(_ctx: &Ctx, name: &str, body: &[u8]) -> Result<Vec<u8>, CallError> {
-    tests::NODE.with(|n| n.borrow_mut().answer(name, body))
-}
-
 fn b64(bytes: &[u8]) -> String {
     B64.encode(bytes)
 }
@@ -693,46 +682,54 @@ impl Access<'_> {
 mod tests {
     use std::cell::RefCell;
     use std::collections::VecDeque;
+    use std::rc::Rc;
 
     use super::*;
     use crate::Kind;
+    use crate::abi::native::{self, Host};
 
     /// The game API as the tests stand it in: every operation sent, with its body, and the
     /// replies to give, in order.
     #[derive(Default)]
-    pub(super) struct FakeNode {
+    struct FakeNode {
         sent: Vec<(String, Value)>,
         replies: VecDeque<Value>,
     }
 
-    impl FakeNode {
-        pub(super) fn answer(&mut self, name: &str, body: &[u8]) -> Result<Vec<u8>, CallError> {
-            self.sent.push((name.to_owned(), serde_json::from_slice(body).expect("a JSON body")));
-            Ok(serde_json::to_vec(&self.replies.pop_front().expect("a reply for every operation")).unwrap())
+    struct Shared(Rc<RefCell<FakeNode>>);
+
+    impl Host for Shared {
+        fn node(&mut self, op: &str, payload: &[u8], _deadline_ms: u32) -> Vec<u8> {
+            let mut n = self.0.borrow_mut();
+            n.sent.push((op.to_owned(), serde_json::from_slice(payload).expect("a JSON body")));
+            let reply = n.replies.pop_front().expect("a reply for every operation");
+            [&[0][..], &serde_json::to_vec(&reply).unwrap()].concat()
         }
     }
 
-    thread_local! {
-        pub(super) static NODE: RefCell<FakeNode> = RefCell::default();
+    /// Runs `f` against the game API `node` stands in for.
+    fn with_node<T>(node: FakeNode, f: impl FnOnce(&Ctx) -> T) -> (T, FakeNode) {
+        let node = Rc::new(RefCell::new(node));
+        native::install(Some(Box::new(Shared(node.clone()))));
+        let ctx = Ctx { app: 7, instance: 1, epoch: 1, version: 1, kind: Kind::Hub, node_type: "t".into(), key: String::new() };
+        let out = f(&ctx);
+        native::install(None);
+        (out, Rc::try_unwrap(node).ok().expect("the host is gone").into_inner())
     }
 
     /// Runs `f`, the game API answering its one operation with `reply`: what `f` returned, and
     /// the operation and body it sent.
     fn exchange<T>(reply: Value, f: impl FnOnce(&Ctx) -> T) -> (T, String, Value) {
-        NODE.with(|n| *n.borrow_mut() = FakeNode { sent: Vec::new(), replies: VecDeque::from([reply]) });
-        let ctx = Ctx { app: 7, instance: 1, epoch: 1, version: 1, kind: Kind::Hub, node_type: "t".into(), key: String::new() };
-        let out = f(&ctx);
-        let (name, body) = NODE.with(|n| n.borrow_mut().sent.pop()).expect("one operation sent");
+        let (out, mut node) = with_node(FakeNode { sent: Vec::new(), replies: VecDeque::from([reply]) }, f);
+        let (name, body) = node.sent.pop().expect("one operation sent");
         (out, name, body)
     }
 
     /// `f` is refused before anything is sent.
     fn refused_here<T: std::fmt::Debug>(f: impl FnOnce(&Ctx) -> Result<T, CallError>) -> CallError {
-        NODE.with(|n| *n.borrow_mut() = FakeNode::default());
-        let ctx = Ctx { app: 7, instance: 1, epoch: 1, version: 1, kind: Kind::Hub, node_type: "t".into(), key: String::new() };
-        let e = f(&ctx).expect_err("refused");
-        assert!(NODE.with(|n| n.borrow().sent.is_empty()), "nothing sent");
-        e
+        let (out, node) = with_node(FakeNode::default(), f);
+        assert!(node.sent.is_empty(), "nothing sent");
+        out.expect_err("refused")
     }
 
     fn pos(x: i64, y: i64, z: i64) -> Value {

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

@@ -1,6 +1,7 @@
 //! Glue between the exports the macros generate and the developer's node type.
 
 use std::alloc::{Layout, alloc as raw_alloc, dealloc};
+#[cfg(target_arch = "wasm32")]
 use std::cell::UnsafeCell;
 use std::collections::{BTreeMap, BTreeSet};
 
@@ -25,10 +26,13 @@ const ENVELOPE: &[u8] = b"\xc1ckx2";
 
 /// A guest is single threaded; the host never calls in while a call is running, except
 /// `ckx_alloc`, which touches none of these.
+#[cfg(target_arch = "wasm32")]
 struct GuestCell<T>(UnsafeCell<T>);
 
+#[cfg(target_arch = "wasm32")]
 unsafe impl<T> Sync for GuestCell<T> {}
 
+#[cfg(target_arch = "wasm32")]
 impl<T> GuestCell<T> {
     const fn new(v: T) -> Self {
         Self(UnsafeCell::new(v))
@@ -40,6 +44,42 @@ impl<T> GuestCell<T> {
     }
 }
 
+/// Natively each thread is a guest of its own, so tests on parallel threads run a node each.
+#[cfg(not(target_arch = "wasm32"))]
+struct GuestCell<T: 'static>(fn() -> T);
+
+#[cfg(not(target_arch = "wasm32"))]
+thread_local! {
+    static GUEST: std::cell::RefCell<std::collections::HashMap<usize, Box<dyn std::any::Any>>> = Default::default();
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: 'static> GuestCell<T> {
+    const fn new(init: fn() -> T) -> Self {
+        Self(init)
+    }
+
+    #[allow(clippy::mut_from_ref)]
+    fn get(&self) -> &mut T {
+        let key = self as *const Self as usize;
+        GUEST.with(|cells| {
+            let mut cells = cells.borrow_mut();
+            let cell = cells.entry(key).or_insert_with(|| Box::new((self.0)()));
+            let ptr: *mut T = cell.downcast_mut::<T>().expect("one type per cell");
+            unsafe { &mut *ptr }
+        })
+    }
+}
+
+macro_rules! guest_static {
+    ($name:ident: $t:ty = $init:expr) => {
+        #[cfg(target_arch = "wasm32")]
+        static $name: GuestCell<$t> = GuestCell::new($init);
+        #[cfg(not(target_arch = "wasm32"))]
+        static $name: GuestCell<$t> = GuestCell::new(|| $init);
+    };
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 struct Timer {
     /// Unix milliseconds.
@@ -83,7 +123,7 @@ impl Platform {
     }
 }
 
-static PLATFORM: GuestCell<Platform> = GuestCell::new(Platform { timers: BTreeMap::new(), watches: BTreeSet::new(), wake: 0 });
+guest_static!(PLATFORM: Platform = Platform { timers: BTreeMap::new(), watches: BTreeSet::new(), wake: 0 });
 
 fn wrap(p: &Platform, state: &[u8]) -> Result<Vec<u8>> {
     let head = encode(p)?;
@@ -217,6 +257,17 @@ fn parse_topic(b: &[u8]) -> Result<TopicMsg<'_>> {
     Ok(TopicMsg { node_type, key, topic, payload: &b[at + 1 + tplen..] })
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Hub> HubNode<T> {
+    pub(crate) fn hub(&self) -> &T {
+        &self.0
+    }
+
+    pub(crate) fn hub_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
 impl<T: Hub> HubNode<T> {
     fn platform_call(&mut self, ctx: &Ctx, call: Call<'_>) -> Result<Vec<u8>> {
         use ckx_platform::*;
@@ -253,8 +304,8 @@ impl<T: Hub> HubNode<T> {
     }
 }
 
-/// Reserved method names, as `ckx_proto::platform` defines them.
-mod ckx_platform {
+/// The platform's reserved method names: its events.
+pub(crate) mod ckx_platform {
     pub const TIMER: &str = "$timer";
     pub const TOPIC: &str = "$topic";
     pub const PRESENCE: &str = "$presence";
@@ -307,6 +358,17 @@ impl<T: Hub> Node for HubNode<T> {
 
 pub struct SpokeNode<T: Spoke>(T);
 
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Spoke> SpokeNode<T> {
+    pub(crate) fn spoke(&self) -> &T {
+        &self.0
+    }
+
+    pub(crate) fn spoke_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}
+
 impl<T: Spoke> Node for SpokeNode<T> {
     fn init(ctx: &Ctx, _seed: &[u8], _snapshot: Option<(&[u8], u64)>) -> Result<Self> {
         Ok(Self(T::start(ctx)?))
@@ -326,8 +388,8 @@ impl<T: Spoke> Node for SpokeNode<T> {
     fn evict(&mut self, _ctx: &Ctx) {}
 }
 
-static NODE: GuestCell<Option<(Ctx, Box<dyn DynNode>)>> = GuestCell::new(None);
-static OUT: GuestCell<Vec<u8>> = GuestCell::new(Vec::new());
+guest_static!(NODE: Option<(Ctx, Box<dyn DynNode>)> = None);
+guest_static!(OUT: Vec<u8> = Vec::new());
 
 fn layout(len: u32) -> Layout {
     Layout::from_size_align(len as usize, 1).expect("valid layout")
@@ -383,17 +445,26 @@ fn respond(result: Result<Vec<u8>>) -> u64 {
 
 /// Unpacks a result the host returned from an import.
 pub(crate) fn import_result(packed: u64) -> Result<Vec<u8>, CallError> {
-    let (ptr, len) = ((packed >> 32) as u32, packed as u32);
-    if len == 0 {
+    let Some(buf) = imported(packed) else {
         return Err(CallError { status: Status::Internal, message: "no reply from the host".into() });
-    }
-    let buf = take(ptr, len);
+    };
     match Status::from_u8(buf[0]) {
         Status::Ok => Ok(buf[1..].to_vec()),
         status => Err(CallError { status, message: String::from_utf8_lossy(&buf[1..]).into_owned() }),
     }
 }
 
+#[cfg(target_arch = "wasm32")]
+fn imported(packed: u64) -> Option<Vec<u8>> {
+    let (ptr, len) = ((packed >> 32) as u32, packed as u32);
+    (len != 0).then(|| take(ptr, len))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn imported(packed: u64) -> Option<Vec<u8>> {
+    if packed == 0 { None } else { abi::native::take_result().filter(|b| !b.is_empty()) }
+}
+
 fn parse_ctx(b: &[u8]) -> Result<Ctx> {
     let bad = || Error::new("malformed instance context");
     let u64_at = |at: usize| -> Result<u64> { Ok(u64::from_le_bytes(b.get(at..at + 8).ok_or_else(bad)?.try_into().unwrap())) };