@crowdedkingdoms/ckx-kit 0.0.0-stage → 0.1.1-dev.1

package/starters/world-tick/src/lib.rs

@@ -0,0 +1,346 @@
+//! The world's clock, weather and resource nodes, advanced on a timer while the app runs, and
+//! the liveops events its developers schedule. It is the root hub, so it hears players enter
+//! and leave the app, and other hubs watch its `world` topic: the NPC engine's mobs grow bolder
+//! at night and under an event's `aggro` modifier. Replaces the `world-engine` and
+//! `liveops-scheduler` templates.
+//!
+//! Endpoints: `state` (anyone), `harvest { node }` (players), and for the app's developers
+//! `schedule { name, start_ms, end_ms, modifiers }` and `cancel { name }`. The spawn seed, if
+//! any, is a JSON [`Config`].
+
+use std::collections::BTreeMap;
+
+use ckx_sdk::prelude::*;
+
+pub const TICK_MS: u64 = 1_000;
+/// The longest step the clock takes at once, so a world that was stopped resumes where it was.
+const MAX_STEP_MS: u64 = 5_000;
+const HARVEST_COOLDOWN_MS: u64 = 500;
+/// Ticks between `world` pushes when nothing notable changed, so clients keep the clock.
+const PUBLISH_EVERY: u64 = 30;
+const MAX_EVENTS: usize = 64;
+const MAX_MODIFIERS: usize = 16;
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct Config {
+    /// Real milliseconds in one game day.
+    pub day_ms: u64,
+    pub nodes: u32,
+    /// What a full resource node holds.
+    pub node_amount: u32,
+    /// How long an emptied node takes to grow back.
+    pub regrow_ms: u64,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self { day_ms: 20 * 60 * 1000, nodes: 12, node_amount: 5, regrow_ms: 60_000 }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Weather {
+    #[default]
+    Clear,
+    Rain,
+    Storm,
+    Fog,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Node {
+    pub id: u32,
+    pub amount: u32,
+    /// When it grows back, in Unix milliseconds; set while it is empty.
+    pub regrow_at: Option<u64>,
+}
+
+/// A liveops event: between `start_ms` and `end_ms` (Unix milliseconds) its modifiers apply.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Event {
+    pub name: String,
+    pub start_ms: u64,
+    pub end_ms: u64,
+    #[serde(default)]
+    pub modifiers: BTreeMap<String, f64>,
+}
+
+/// What the `world` topic carries.
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct Conditions {
+    /// 0 at midnight, 0.5 at noon.
+    pub time_of_day: f64,
+    pub night: bool,
+    pub weather: Weather,
+    /// The active events' modifiers; where events overlap they multiply.
+    pub modifiers: BTreeMap<String, f64>,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+pub struct View {
+    pub conditions: Conditions,
+    pub clock_ms: u64,
+    pub nodes: Vec<Node>,
+    pub events: Vec<Event>,
+    pub online: u32,
+}
+
+#[derive(Deserialize)]
+struct Harvest {
+    node: u32,
+}
+
+#[derive(Deserialize)]
+struct Cancel {
+    name: String,
+}
+
+#[derive(Serialize, Deserialize, Default)]
+pub struct World {
+    pub config: Config,
+    /// Game time since the world began, advanced only while it runs.
+    pub clock_ms: u64,
+    pub last_tick: u64,
+    pub ticks: u64,
+    pub weather: Weather,
+    /// The game time the weather next changes.
+    pub weather_until: u64,
+    pub rng: u64,
+    pub nodes: Vec<Node>,
+    pub events: BTreeMap<String, Event>,
+    pub online: u32,
+    /// Each player's last harvest, for the cooldown.
+    pub harvested: BTreeMap<u64, u64>,
+    pub published: Option<Conditions>,
+}
+
+impl World {
+    pub fn new(config: Config, now: u64) -> Self {
+        let nodes = (0..config.nodes).map(|id| Node { id, amount: config.node_amount, regrow_at: None }).collect();
+        Self { rng: now | 1, last_tick: now, nodes, config, ..Default::default() }
+    }
+
+    fn next_rand(&mut self) -> u64 {
+        let mut x = self.rng;
+        x ^= x << 13;
+        x ^= x >> 7;
+        x ^= x << 17;
+        self.rng = x;
+        x
+    }
+
+    /// Advances the world to `now` (Unix milliseconds).
+    pub fn tick(&mut self, now: u64) {
+        self.ticks += 1;
+        self.clock_ms += now.saturating_sub(self.last_tick).min(MAX_STEP_MS);
+        self.last_tick = now;
+        if self.clock_ms >= self.weather_until {
+            self.weather = match self.next_rand() % 10 {
+                0..=5 => Weather::Clear,
+                6 | 7 => Weather::Rain,
+                8 => Weather::Storm,
+                _ => Weather::Fog,
+            };
+            let hour = (self.config.day_ms / 24).max(1);
+            self.weather_until = self.clock_ms + hour * (2 + self.next_rand() % 5);
+        }
+        let amount = self.config.node_amount;
+        for n in &mut self.nodes {
+            if n.regrow_at.is_some_and(|at| now >= at) {
+                n.amount = amount;
+                n.regrow_at = None;
+            }
+        }
+        self.harvested.retain(|_, at| now.saturating_sub(*at) < 60_000);
+        self.events.retain(|_, e| e.end_ms > now);
+    }
+
+    pub fn conditions(&self, now: u64) -> Conditions {
+        let day = self.config.day_ms.max(1);
+        let time_of_day = (self.clock_ms % day) as f64 / day as f64;
+        let mut modifiers = BTreeMap::new();
+        for e in self.events.values().filter(|e| e.start_ms <= now && now < e.end_ms) {
+            for (k, v) in &e.modifiers {
+                *modifiers.entry(k.clone()).or_insert(1.0) *= v;
+            }
+        }
+        Conditions { time_of_day, night: !(0.25..0.75).contains(&time_of_day), weather: self.weather, modifiers }
+    }
+
+    pub fn harvest(&mut self, player: u64, node: u32, now: u64) -> Result<u32> {
+        if self.harvested.get(&player).is_some_and(|at| now < at + HARVEST_COOLDOWN_MS) {
+            return Err(Error::new("harvesting too fast"));
+        }
+        let regrow_at = now + self.config.regrow_ms;
+        let n = self.nodes.iter_mut().find(|n| n.id == node).ok_or_else(|| Error::new(format!("no resource node {node}")))?;
+        if n.amount == 0 {
+            return Err(Error::new("that node is empty; it grows back"));
+        }
+        n.amount -= 1;
+        if n.amount == 0 {
+            n.regrow_at = Some(regrow_at);
+        }
+        self.harvested.insert(player, now);
+        Ok(n.amount)
+    }
+
+    pub fn schedule(&mut self, event: Event, now: u64) -> Result<()> {
+        if event.name.is_empty() || event.name.len() > 64 {
+            return Err(Error::new("an event name is 1-64 characters"));
+        }
+        if event.end_ms <= event.start_ms || event.end_ms <= now {
+            return Err(Error::new("an event ends after it starts, and in the future"));
+        }
+        if event.modifiers.len() > MAX_MODIFIERS || event.modifiers.values().any(|v| !v.is_finite() || *v <= 0.0 || *v > 100.0) {
+            return Err(Error::new(format!("at most {MAX_MODIFIERS} modifiers, each above 0 and at most 100")));
+        }
+        if !self.events.contains_key(&event.name) && self.events.len() >= MAX_EVENTS {
+            return Err(Error::new(format!("at most {MAX_EVENTS} events are scheduled at once")));
+        }
+        self.events.insert(event.name.clone(), event);
+        Ok(())
+    }
+
+    pub fn view(&self, now: u64) -> View {
+        View {
+            conditions: self.conditions(now),
+            clock_ms: self.clock_ms,
+            nodes: self.nodes.clone(),
+            events: self.events.values().cloned().collect(),
+            online: self.online,
+        }
+    }
+}
+
+impl Hub for World {
+    fn spawn(ctx: &Ctx, seed: &[u8]) -> Result<Self> {
+        let config = if seed.is_empty() {
+            Config::default()
+        } else {
+            serde_json::from_slice(seed).map_err(|e| Error::new(format!("seed is not a JSON config: {e}")))?
+        };
+        ctx.timer_every("tick", TICK_MS)?;
+        Ok(Self::new(config, ctx.now_ms()))
+    }
+
+    fn load(_ctx: &Ctx, snapshot: &[u8], _from_version: u64) -> Result<Self> {
+        decode(snapshot)
+    }
+
+    fn persist(&mut self, _ctx: &Ctx) -> Result<Vec<u8>> {
+        encode(self)
+    }
+
+    fn handle(&mut self, ctx: &Ctx, call: Call<'_>) -> Result<Vec<u8>> {
+        let now = ctx.now_ms();
+        match call.method {
+            "state" => encode(&self.view(now)),
+            "harvest" => {
+                let player = call.player()?;
+                let req: Harvest = call.decode()?;
+                encode(&self.harvest(player, req.node, now)?)
+            }
+            "schedule" => {
+                call.developer()?;
+                self.schedule(call.decode()?, now)?;
+                ctx.persist_now();
+                encode(&true)
+            }
+            "cancel" => {
+                call.developer()?;
+                let req: Cancel = call.decode()?;
+                encode(&self.events.remove(&req.name).is_some())
+            }
+            other => Err(Error::unknown_method(other)),
+        }
+    }
+
+    fn on_timer(&mut self, ctx: &Ctx, timer: &str) -> Result<()> {
+        if timer != "tick" {
+            return Ok(());
+        }
+        let now = ctx.now_ms();
+        self.tick(now);
+        let c = self.conditions(now);
+        let notable = self.published.as_ref().is_none_or(|p| p.night != c.night || p.weather != c.weather || p.modifiers != c.modifiers);
+        if notable || self.ticks.is_multiple_of(PUBLISH_EVERY) {
+            ctx.publish("world", &encode(&c)?);
+            self.published = Some(c);
+        }
+        Ok(())
+    }
+
+    fn on_presence(&mut self, _ctx: &Ctx, presence: &Presence) -> Result<()> {
+        self.online = presence.count;
+        Ok(())
+    }
+}
+
+ckx_sdk::export_hub!(World);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn world() -> World {
+        World::new(Config { day_ms: 24_000, nodes: 2, node_amount: 2, regrow_ms: 1_000 }, 1_000)
+    }
+
+    #[test]
+    fn the_clock_steps_at_most_five_seconds_so_a_stopped_world_resumes() {
+        let mut w = world();
+        w.tick(2_000);
+        assert_eq!(w.clock_ms, 1_000);
+        w.tick(1_000_000);
+        assert_eq!(w.clock_ms, 1_000 + MAX_STEP_MS);
+    }
+
+    #[test]
+    fn night_is_the_first_and_last_quarter_of_the_day() {
+        let mut w = world();
+        assert!(w.conditions(0).night);
+        w.clock_ms = 12_000;
+        assert!(!w.conditions(0).night);
+        w.clock_ms = 20_000;
+        assert!(w.conditions(0).night);
+    }
+
+    #[test]
+    fn a_node_empties_cools_down_and_grows_back() {
+        let mut w = world();
+        assert_eq!(w.harvest(7, 0, 10_000).unwrap(), 1);
+        assert!(w.harvest(7, 0, 10_100).is_err(), "cooldown");
+        assert_eq!(w.harvest(7, 0, 10_600).unwrap(), 0);
+        assert!(w.harvest(8, 0, 10_700).is_err(), "empty");
+        assert!(w.harvest(8, 9, 10_700).is_err(), "no such node");
+        w.tick(11_700);
+        assert_eq!(w.nodes[0].amount, 2);
+    }
+
+    #[test]
+    fn events_are_bounded_active_in_their_window_and_multiply() {
+        let mut w = world();
+        let ev = |name: &str, start, end, aggro| Event {
+            name: name.into(),
+            start_ms: start,
+            end_ms: end,
+            modifiers: BTreeMap::from([("aggro".to_string(), aggro)]),
+        };
+        w.schedule(ev("a", 100, 5_000, 2.0), 0).unwrap();
+        w.schedule(ev("b", 200, 5_000, 1.5), 0).unwrap();
+        assert!(w.schedule(ev("c", 300, 200, 1.0), 0).is_err(), "ends before it starts");
+        assert!(w.schedule(ev("d", 300, 400, 0.0), 0).is_err(), "modifier out of range");
+        assert_eq!(w.conditions(50).modifiers.get("aggro"), None);
+        assert_eq!(w.conditions(250).modifiers.get("aggro"), Some(&3.0));
+        w.tick(6_000);
+        assert!(w.events.is_empty(), "ended events are dropped");
+    }
+
+    #[test]
+    fn a_seed_is_a_json_config_with_defaults() {
+        let c: Config = serde_json::from_slice(br#"{"nodes": 3}"#).unwrap();
+        assert_eq!((c.nodes, c.node_amount), (3, Config::default().node_amount));
+    }
+}

package/templates/client/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "client-half"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+# How often visitors' browsers call tick (clamped 16–1000 ms).
+# 1000 = HUD/text. 50 = physics minigames (pool). 16 = shooters, if a tick stays cheap.
+[package.metadata.crowdy]
+tick_interval_ms = 1000
+
+[dependencies]
+crowdy-client-sdk = "0.1.0"
+serde_json = "1"

package/templates/client/src/lib.rs

@@ -0,0 +1,31 @@
+use crowdy_client_sdk as crowdy;
+
+fn init() {
+    // Runs once in each visitor's browser, after they consent to this CLIENT half
+    // (or trust you) and while they stand in this grid.
+    crowdy::log(1, "ready");
+}
+
+fn tick(_dt_ms: u32) {
+    // Every tick_interval_ms (Cargo.toml). The state blob lasts as long as the page's worker.
+    let ticks = u32::from_le_bytes(crowdy::state_get().try_into().unwrap_or([0; 4])).wrapping_add(1);
+    crowdy::state_set(&ticks.to_le_bytes());
+    // Host calls cross the page's broker as the visiting player, inside this grid: the HUD and
+    // overlay, chunk and actor reads, voxel writes, spatial and channel sends, grid events.
+    // Type "crowdy::api::" for the rest. The page's DOM and tokens are never reachable.
+    let _ = crowdy::api::hud_set(serde_json::json!({ "text": format!("Ticks here: {ticks}") }));
+    //
+    // Mouse (holodeck canvas only; Studio chrome is omitted). Drain every tick:
+    //   let data = crowdy::api::pointer_clicks().unwrap_or(serde_json::json!({}));
+    // data["clicks"] = [{ "t": "down"|"up", "button": 0, "atMs", "heldMs", "nx", "ny" }]
+}
+
+fn invoke(payload: &[u8]) -> Vec<u8> {
+    payload.to_vec()
+}
+
+fn event(_payload: &[u8]) {
+    // Grid events from the other CLIENT halves on this page (crowdy::api::emit_event).
+}
+
+crowdy::register_module!(init: init, tick: tick, invoke: invoke, event: event);

package/templates/hub/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "hub"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+ckx-sdk = "0.0.0"
+serde = { version = "1", features = ["derive"] }

package/templates/hub/src/lib.rs

@@ -0,0 +1,73 @@
+//! A hub: state that one instance per key owns, changed by one handler at a time.
+//!
+//! Endpoints: `add` (players add to the total) and `get` (anyone reads it).
+
+use ckx_sdk::prelude::*;
+
+#[derive(Default, Serialize, Deserialize)]
+pub struct Counter {
+    pub total: i64,
+}
+
+impl Hub for Counter {
+    fn spawn(_ctx: &Ctx, _seed: &[u8]) -> Result<Self> {
+        Ok(Self::default())
+    }
+
+    fn load(_ctx: &Ctx, snapshot: &[u8], _from_version: u64) -> Result<Self> {
+        decode(snapshot)
+    }
+
+    fn persist(&mut self, _ctx: &Ctx) -> Result<Vec<u8>> {
+        encode(self)
+    }
+
+    fn handle(&mut self, _ctx: &Ctx, call: Call<'_>) -> Result<Vec<u8>> {
+        match call.method {
+            "add" => {
+                call.player()?;
+                self.total += call.decode::<i64>()?;
+                encode(&self.total)
+            }
+            "get" => encode(&self.total),
+            other => Err(Error::unknown_method(other)),
+        }
+    }
+}
+
+ckx_sdk::export_hub!(Counter);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ctx() -> Ctx {
+        Ctx { app: 1, instance: 1, epoch: 1, version: 1, kind: Kind::Hub, node_type: "counter".into(), key: "main".into() }
+    }
+
+    #[test]
+    fn players_add_and_anyone_reads() {
+        let ctx = ctx();
+        let mut hub = Counter::spawn(&ctx, &[]).unwrap();
+        let five = encode(&5i64).unwrap();
+        hub.handle(&ctx, Call { caller: Caller::Player(7), method: "add", payload: &five }).unwrap();
+        let total: i64 = decode(&hub.handle(&ctx, Call { caller: Caller::Instance(2), method: "get", payload: &[] }).unwrap()).unwrap();
+        assert_eq!(total, 5);
+    }
+
+    #[test]
+    fn only_players_add() {
+        let ctx = ctx();
+        let mut hub = Counter::spawn(&ctx, &[]).unwrap();
+        let one = encode(&1i64).unwrap();
+        assert!(hub.handle(&ctx, Call { caller: Caller::Instance(2), method: "add", payload: &one }).is_err());
+    }
+
+    #[test]
+    fn the_snapshot_restores_the_total() {
+        let ctx = ctx();
+        let mut hub = Counter { total: 42 };
+        let snapshot = hub.persist(&ctx).unwrap();
+        assert_eq!(Counter::load(&ctx, &snapshot, 1).unwrap().total, 42);
+    }
+}

package/templates/spoke/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "spoke"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+ckx-sdk = "0.0.0"
+serde = { version = "1", features = ["derive"] }

package/templates/spoke/src/lib.rs

@@ -0,0 +1,53 @@
+//! A spoke: stateless work that replicas run anywhere, changing hubs only through their
+//! endpoints.
+//!
+//! Endpoint: `damage { attack, defense }` answers the damage of one hit.
+
+use ckx_sdk::prelude::*;
+
+#[derive(Serialize, Deserialize)]
+pub struct Hit {
+    pub attack: u32,
+    pub defense: u32,
+}
+
+pub fn damage(hit: &Hit) -> u32 {
+    hit.attack.saturating_sub(hit.defense / 2).max(1)
+}
+
+pub struct Combat;
+
+impl Spoke for Combat {
+    fn start(_ctx: &Ctx) -> Result<Self> {
+        Ok(Self)
+    }
+
+    fn handle(&mut self, _ctx: &Ctx, call: Call<'_>) -> Result<Vec<u8>> {
+        match call.method {
+            "damage" => encode(&damage(&call.decode::<Hit>()?)),
+            other => Err(Error::unknown_method(other)),
+        }
+    }
+}
+
+ckx_sdk::export_spoke!(Combat);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_hit_does_at_least_one_damage() {
+        assert_eq!(damage(&Hit { attack: 10, defense: 4 }), 8);
+        assert_eq!(damage(&Hit { attack: 1, defense: 100 }), 1);
+    }
+
+    #[test]
+    fn the_endpoint_answers_in_messagepack() {
+        let ctx = Ctx { app: 1, instance: 1, epoch: 1, version: 1, kind: Kind::Spoke, node_type: "combat".into(), key: String::new() };
+        let mut spoke = Combat::start(&ctx).unwrap();
+        let hit = encode(&Hit { attack: 10, defense: 4 }).unwrap();
+        let reply = spoke.handle(&ctx, Call { caller: Caller::Instance(3), method: "damage", payload: &hit }).unwrap();
+        assert_eq!(decode::<u32>(&reply).unwrap(), 8);
+    }
+}

package/tools/instrument/Cargo.lock

@@ -0,0 +1,140 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anyhow"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "bitflags"
+version = "2.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
+[[package]]
+name = "instrument"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "radix-wasm-instrument",
+ "wasm-encoder",
+ "wasmparser 0.107.0",
+]
+
+[[package]]
+name = "leb128"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c83bff1d572d6b9aeef67ddfc8448e4a3737909cb28e81f97c791b9018703e52"
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "radix-wasm-instrument"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b5e1305200330d3dd5c9b16ca43eba268993036ba19a2b2cadadee1b9166ab4"
+dependencies = [
+ "anyhow",
+ "paste",
+ "wasm-encoder",
+ "wasmparser 0.107.0",
+ "wasmprinter",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18c41dbd92eaebf3612a39be316540b8377c871cb9bde6b064af962984912881"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.107.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29e3ac9b780c7dda0cac7a52a5d6d2d6707cc6e3451c9db209b6c758f40d7acb"
+dependencies = [
+ "indexmap 1.9.3",
+ "semver",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.121.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
+dependencies = [
+ "bitflags",
+ "indexmap 2.14.2",
+ "semver",
+]
+
+[[package]]
+name = "wasmprinter"
+version = "0.2.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60e73986a6b7fdfedb7c5bf9e7eb71135486507c8fbc4c0c42cffcb6532988b7"
+dependencies = [
+ "anyhow",
+ "wasmparser 0.121.2",
+]

package/tools/instrument/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "instrument"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+anyhow = "1.0.103"
+radix-wasm-instrument = "1.0.0"
+# Match radix-wasm-instrument's parser/encoder generation.
+wasmparser = "0.107"
+wasm-encoder = "0.29"