host: add a shared writable /config world mount

PROTOCOL.md

@@ -59,27 +59,19 @@ it exits. After 5 seconds, it kills the instance.
 
 ## Filesystem
 
-The world folder is the foundation of every instance's filesystem:
+Each instance sees four folders:
 
 | Path | Access | Contents |
 | --- | --- | --- |
-| `/` | read-write by every actor | the whole world folder |
-| `/self` | read-write | alias for the actor's own folder (`public/`, `data/`, `source/`, etc.) |
-| `/data` | read-write | alias for the actor's state folder |
-| `/public` | read-write | alias for the actor's published files |
-| `/actor` | read-write by every actor | the `actor/` folder of the world |
+| `/data` | read-write by its actor; readable by every actor | the actor's state |
+| `/public` | read-write | the files that the actor publishes |
+| `/actor` | read-only | the `actor/` folder of the world |
+| `/config` | read-write by every actor | the world's shared `config/` folder; persists across restarts |
 
-Every actor can read and write every file in the world, including other actors'
-`/actor/<id>/data/` and `/actor/<id>/public/`. Nothing there is private.
-Creating a folder in the world makes it visible to running actors immediately:
-`/config`, `/docs`, `/www`, and `/skills` need no new mounts or host restart.
-New worlds include an empty `/config` for global configuration by convention;
-existing worlds can simply create it. Keep secrets out of global configuration.
+`/config` is the same world folder for every instance, including candidates;
+writers coordinate by convention, not permissions. Do not put secrets there.
 
-Candidate instances see the same writable world root. Their `/self` alias
-points to the scratch actor folder; `/public` and `/data` still point to its
-corresponding children, and network access remains off;
-absolute world paths are not isolated from the live world.
+An actor can write only its own `/data`, but can read every actor's `/data` through `/actor/<id>/data/`. `/data` is not private: any unprotected secret file there is readable by every actor.
 
 `/actor/<id>/` holds everything about an actor: `actor.wasm`, `actor.json`
 (installed version, running, subscriptions, tapped, watches), `source/`, `public/`, `data/`,
@@ -143,15 +135,12 @@ the request: the request's `type` in past tense (`spawned`, `upgraded`,
 | `remove` | `actor` | stop the actor (normal shutdown), then delete its whole folder `/actor/<id>/` (all versions, `data/`, `public/`, logs); answer `{"type": "removed", "actor"}`. Messages to it are then undeliverable, and the ID can be spawned again. An unknown actor or a native one (`broker`, `console`, `cargo`, `fs`) is an `error` |
 | `subscribe`, `unsubscribe` | `actor` | receive (or not) what `actor` publishes |
 | `tap`, `untap` | | receive (or not) a copy of every message the broker routes |
-| `watch`, `unwatch` | `path` | receive (or not) `fs_changed` for every change of `path` or anything under it; answer `{"type": "watching" \| "unwatched", "path"}` with the path as an absolute world path |
+| `watch`, `unwatch` | `path` | receive (or not) `fs_changed` for every change of `path` or anything under it; answer `{"type": "watching" \| "unwatched", "path"}` with the path as an `/actor/...` path |
 | `exit` | | answer `exiting`, stop every actor, and end the `sausage` process with exit code 75 (a wrapper like `nix run .#loop` starts it again, updated) |
 
 **Headless.** `sausage run --headless [dir]` (or `sausage --headless`, or `SAUSAGE_HEADLESS=1`) turns the console input off: the host does not read stdin, so end of input (`/dev/null`) does not stop the world. `nix run .#loop -- --headless <world>` passes it through the loop. It runs until SIGTERM or SIGINT (stops every actor, exit code 0) or a broker `exit` request (exit code 75, as above). Without the flag, EOF on stdin or `/quit` ends the host.
 
-Paths are absolute world paths, or the sender's `/self/...`, `/public/...` or
-`/data/...` aliases. Native senders (such as the console) can also supply
-absolute host paths; apart from `/actor` and these aliases,
-these retain their host meaning.
+Paths are `/actor/...`, `/config/...`, or the sender's `/public/...` or `/data/...`.
 
 **Taps.** After `tap`, the sender gets a copy of every message that the
 broker routes (direct messages, replies, and publishes, between any actors,
@@ -191,7 +180,7 @@ change of `path` or a path under it (`/actor/a` covers `/actor/a/x`, not
 - Events come from `fs`. Like tap copies, they are not routed, a full
   mailbox drops them, and they never block the writer. Never answer them.
 - If the OS drops events, every watcher gets one
-  `{"type": "fs_changed", "path": "/", "op": "rescan"}`: anything may
+  `{"type": "fs_changed", "path": "/actor", "op": "rescan"}`: anything may
   have changed.
 - A watch is saved in `actor.json` (`"watches": [...]`) and survives
   restarts and upgrades. `unwatch` with the same path ends it.
@@ -265,11 +254,6 @@ The reply is `{"type": "built", "wasm": "/actor/cargo/public/builds/<n>/<name>.w
 or `{"type": "build_failed", "errors": "...", "tests": {...}}`. Pass
 `wasm`, `source`, and `built_by` on to `spawn` or `upgrade`.
 
-Build scripts can compile C for `wasm32-wasip2`: the host sets
-`CC_wasm32_wasip2` and `AR_wasm32_wasip2` to a WASI clang with wasi-libc, so
-the `cc` crate (for example `rusqlite` with `bundled`) works. Its headers are
-WASI 0.1: C code that needs sockets does not build.
-
 A Rust actor depends on the SDK with `sausage-actor = "0.1"`. `cargo` points
 that dependency at the SDK of the host, which it publishes at
 `/actor/cargo/public/sdk/`.

cli/src/broker.rs

@@ -70,6 +70,7 @@ pub struct Broker {
 
 impl Broker {
     pub fn new(world: World, runtime: Arc<Runtime>) -> Result<Arc<Self>> {
+        std::fs::create_dir_all(world.config_dir())?;
         let metas = world.actor_ids()?.into_iter().map(|id| (id.clone(), world.read_meta(&id))).collect();
         Ok(Arc::new_cyclic(|me| Self {
             world,
@@ -255,11 +256,10 @@ impl Broker {
         }
         InstanceConfig {
             mounts: vec![
-                Mount { guest: "/".into(), host: self.world.root.clone(), writable: true },
-                Mount { guest: "/actor".into(), host: self.world.actors_root(), writable: true },
-                Mount { guest: "/self".into(), host: own.clone(), writable: true },
+                Mount { guest: "/actor".into(), host: self.world.actors_root(), writable: false },
                 Mount { guest: "/public".into(), host: own.join("public"), writable: true },
                 Mount { guest: "/data".into(), host: own.join("data"), writable: true },
+                Mount { guest: "/config".into(), host: self.world.config_dir(), writable: true },
             ],
             network: scratch.is_none(),
             stderr_log: own.join("stderr.log"),
@@ -447,7 +447,7 @@ impl Broker {
         self.host_error("the file watcher dropped events; watchers get a rescan, actors a full pass");
         let watchers: Vec<String> =
             self.metas.lock().unwrap().iter().filter(|(_, m)| !m.watches.is_empty()).map(|(id, _)| id.clone()).collect();
-        self.inject(&watchers, vfs::ID, json!({"type": "fs_changed", "path": "/", "op": "rescan"}));
+        self.inject(&watchers, vfs::ID, json!({"type": "fs_changed", "path": "/actor", "op": "rescan"}));
         let report = self.scan().await;
         for change in &report {
             eprintln!("sausage: {change}");
@@ -601,9 +601,9 @@ impl Broker {
                 let on = ty == "watch";
                 let path_s = b["path"].as_str().ok_or_else(|| anyhow!("missing \"path\""))?;
                 let global = self.world.global_path(&self.world.resolve(&env.from, path_s)?);
-                let path = global.ok_or_else(|| anyhow!("{path_s} is not under the world root"))?;
+                let path = global.ok_or_else(|| anyhow!("{path_s} is not under /actor"))?;
                 let path = match path.trim_end_matches('/') {
-                    "" => "/".to_string(),
+                    "" => "/actor".to_string(),
                     p => p.to_string(),
                 };
                 self.update_meta(&env.from, |m| {
@@ -651,7 +651,7 @@ fn same_file(a: &Path, b: &Path) -> bool {
 
 /// Whether the namespace path `path` is `prefix` or inside it.
 fn under(path: &str, prefix: &str) -> bool {
-    prefix == "/" || path.strip_prefix(prefix).is_some_and(|rest| rest.is_empty() || rest.starts_with('/'))
+    path.strip_prefix(prefix).is_some_and(|rest| rest.is_empty() || rest.starts_with('/'))
 }
 
 pub fn truncate(s: &str, max: usize) -> String {

cli/src/cargo_actor.rs

@@ -8,9 +8,6 @@
 //! The broker knows nothing about Rust. This actor is one way to get a
 //! `.wasm` file. Other actors can add other languages.
 //!
-//! Build scripts compile C for WASI with the clang in `CC_wasm32_wasip2`
-//! and `AR_wasm32_wasip2`. The Nix package and the dev shell set both.
-//!
 //! Actors depend on the SDK with `sausage-actor = "0.1"`. The SDK is not
 //! published: this actor copies the SDK of this host to `public/sdk/` (so
 //! that every actor can read it), and points the dependency there in the

cli/src/vfs.rs

@@ -390,8 +390,8 @@ impl preopens::Host for VfsView<'_> {
     fn get_directories(&mut self) -> wasmtime::Result<Vec<(Resource<types::Descriptor>, String)>> {
         let dirs = preopens::Host::get_directories(&mut self.inner)?;
         for (fd, name) in &dirs {
-            if name == "/actor" || name == "/" {
-                self.state.dirs.insert(fd.rep(), name.clone());
+            if name == "/actor" {
+                self.state.dirs.insert(fd.rep(), "/actor".to_string());
             }
         }
         Ok(dirs)

cli/src/watch.rs

@@ -5,7 +5,7 @@
 //! Events are coalesced per path: once a path is quiet for `QUIET` (or has
 //! kept changing for `MAX_DELAY`), it becomes one change
 //! `{path, op: write | create | remove | rename, to?}` with a namespace path
-//! (relative to the world root, such as `/actor/...` or `/config/...`). Then the broker
+//! (`/actor/...`). Then the broker
 //!
 //! - sends `fs_changed` to the actors that watch the path (`watch` request),
 //! - starts or upgrades an actor whose `actor/<id>/actor.wasm` (or folder
@@ -75,7 +75,7 @@ impl Pending {
 }
 
 async fn run(broker: Arc<Broker>, mut events: mpsc::UnboundedReceiver<notify::Result<notify::Event>>) {
-    let root = broker.world.root.clone();
+    let root = broker.world.actors_root();
     let mut pending: HashMap<String, Pending> = HashMap::new();
     // Actor checks and full passes. Dropping the set (when the host stops) aborts them.
     let mut tasks = tokio::task::JoinSet::new();
@@ -122,11 +122,11 @@ async fn sleep_until(t: Option<Instant>) {
     }
 }
 
-/// The world namespace path of a host path, unless it is outside the
-/// world or a temporary file of the host.
+/// The namespace path (`/actor/...`) of a host path, unless it is outside
+/// `actor/` or a temporary file of the host.
 fn namespace(root: &Path, path: &Path) -> Option<String> {
     let rel = path.strip_prefix(root).ok()?;
-    let mut out = String::new();
+    let mut out = String::from("/actor");
     for part in rel.components() {
         let name = part.as_os_str().to_str()?;
         if name.starts_with(TMP_PREFIX) {
@@ -135,7 +135,7 @@ fn namespace(root: &Path, path: &Path) -> Option<String> {
         out.push('/');
         out.push_str(name);
     }
-    Some(if out.is_empty() { "/".to_string() } else { out })
+    Some(out)
 }
 
 /// One change: namespace path, op, and the new path of a rename.
@@ -219,7 +219,7 @@ mod tests {
 
     #[test]
     fn a_rename_is_one_change_and_temp_files_are_skipped() {
-        let root = Path::new("/w");
+        let root = Path::new("/w/actor");
         let now = Instant::now();
         let mut pending = HashMap::new();
         let ev = |kind, paths: &[&str]| {
@@ -236,8 +236,7 @@ mod tests {
             ev(name(RenameMode::Both), &["/w/actor/a/public/x", "/w/actor/a/public/y"]),
             ev(EventKind::Create(notify::event::CreateKind::File), &["/w/actor/a/.sausage-tmp-host-1-actor.json"]),
             ev(name(RenameMode::Both), &["/w/actor/a/.sausage-tmp-host-1-actor.json", "/w/actor/a/actor.json"]),
-            ev(EventKind::Create(notify::event::CreateKind::File), &["/outside/.lock"]),
-            ev(EventKind::Create(notify::event::CreateKind::File), &["/w/config/x"]),
+            ev(EventKind::Create(notify::event::CreateKind::File), &["/w/.lock"]),
         ] {
             for (path, op, to) in changes(root, &e) {
                 add(&mut pending, path, op, to, now);
@@ -251,7 +250,6 @@ mod tests {
             vec![
                 ("/actor/a/actor.json".to_string(), "write", None),
                 ("/actor/a/public/x".to_string(), "rename", Some("/actor/a/public/y".to_string())),
-                ("/config/x".to_string(), "create", None),
             ]
         );
     }

cli/src/world.rs

@@ -1,17 +1,16 @@
 //! On-disk layout of a Sausage world. The folder is the source of truth:
 //! `sausage run` boots every actor that it finds in `actor/`, and then
-//! watches the folder (`watch.rs`). `/self` aliases the running actor's folder;
-//! `/public` and `/data` remain aliases for its `public/` and `data/`.
+//! watches the folder (`watch.rs`).
 //!
 //! ```text
-//! <world>/              mounted at /, readable and writable by every actor
-//!   config/             global configuration by convention (no secrets)
+//! <world>/
+//!   config/              shared configuration, writable by every actor
 //!   actor/<id>/
 //!     actor.wasm        the current version
 //!     actor.json        version, running, subscriptions, tapped, watches (broker)
 //!     source/           source of the current version
-//!     public/           published files, readable and writable by everyone
-//!     data/             state, readable and writable by everyone
+//!     public/           written by the actor, read-only for others
+//!     data/             state, writable only by the actor
 //!     stderr.log        stderr of the actor and notes of the broker
 //!     versions/<n>/     every version that was installed: actor.wasm, source/, meta.json
 //! ```
@@ -91,6 +90,9 @@ impl World {
         Self { root: root.into() }
     }
 
+    pub fn config_dir(&self) -> PathBuf {
+        self.root.join("config")
+    }
     pub fn actors_root(&self) -> PathBuf {
         self.root.join("actor")
     }
@@ -133,7 +135,6 @@ impl World {
         for id in NATIVE {
             world.ensure_actor_dirs(id)?;
         }
-        std::fs::create_dir_all(world.root.join("config"))?;
         Ok(world)
     }
 
@@ -194,9 +195,8 @@ impl World {
 
     /// Map a path in an actor's namespace to a host path.
     ///
-    /// - Absolute paths are relative to the world root.
-    /// - `/self/...` aliases `sender`'s folder; `/public/...` and `/data/...`
-    ///   alias its corresponding children.
+    /// - `/actor/<id>/...` and `/config/...` are world paths.
+    /// - `/public/...` and `/data/...` belong to `sender`.
     /// - Native senders (the console) can also give absolute host paths.
     pub fn resolve(&self, sender: &str, path: &str) -> Result<PathBuf> {
         let under = |base: PathBuf, rest: &str| -> Result<PathBuf> {
@@ -216,8 +216,8 @@ impl World {
         if let Some(rest) = prefixed("/actor") {
             return under(self.actors_root(), rest);
         }
-        if let Some(rest) = prefixed("/self") {
-            return under(self.actor_dir(sender), rest);
+        if let Some(rest) = prefixed("/config") {
+            return under(self.config_dir(), rest);
         }
         if let Some(rest) = prefixed("/public") {
             return under(self.public_dir(sender), rest);
@@ -228,16 +228,13 @@ impl World {
         if NATIVE.contains(&sender) && Path::new(path).is_absolute() {
             return Ok(PathBuf::from(path));
         }
-        if Path::new(path).is_absolute() {
-            return under(self.root.clone(), path);
-        }
-        bail!("cannot resolve path {path} for {sender}: use an absolute world path")
+        bail!("cannot resolve path {path} for {sender}: use /actor/<id>/..., /config/..., /public/... or /data/...")
     }
 
     /// The path of a host file in the global filesystem, if it has one.
     pub fn global_path(&self, host: &Path) -> Option<String> {
-        let rel = host.strip_prefix(&self.root).ok()?;
-        Some(format!("/{}", rel.display()))
+        let rel = host.strip_prefix(self.actors_root()).ok()?;
+        Some(format!("/actor/{}", rel.display()))
     }
 }
 

cli/tests/crates/cargo-c/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "cargo-c"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-sausage-actor = "0.1"
-
-[build-dependencies]
-cc = "1"
-
-[workspace]

cli/tests/crates/cargo-c/build.rs

@@ -1,5 +0,0 @@
-// Compile C with the `cc` crate: natively for the unit test, and with the
-// WASI clang (`CC_wasm32_wasip2`) for the actor.
-fn main() {
-    cc::Build::new().file("src/add.c").compile("add");
-}

cli/tests/crates/cargo-c/src/add.c

@@ -1 +0,0 @@
-int c_add(int a, int b) { return a + b; }

cli/tests/crates/cargo-c/src/main.rs

@@ -1,25 +0,0 @@
-//! Adds two numbers with a C function: `{"type": "add", "a", "b"}` -> `{"type": "sum", "value"}`.
-use sausage_actor::{json, messages, reply};
-
-unsafe extern "C" {
-    fn c_add(a: i32, b: i32) -> i32;
-}
-
-fn add(a: i32, b: i32) -> i32 {
-    unsafe { c_add(a, b) }
-}
-
-fn main() {
-    for message in messages() {
-        let (a, b) = (message.body["a"].as_i64().unwrap_or(0), message.body["b"].as_i64().unwrap_or(0));
-        let _ = reply(&message, json!({"type": "sum", "value": add(a as i32, b as i32)}));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn c_code_runs_on_the_host_target() {
-        assert_eq!(super::add(2, 3), 5);
-    }
-}

cli/tests/host.rs

@@ -140,20 +140,20 @@ async fn exit_request_is_answered_and_signals_the_host() {
 }
 
 #[tokio::test]
-async fn filesystem_is_writable_and_public_aliases_share_files() {
+async fn filesystem_permissions_and_public_sharing() {
     let (_, host, mut mailbox) = filesystem_world("filesystem-permissions").await;
     for path in [
-        "/actor/reader/public/shared.txt",
-        "/actor/writer/public/shared.txt",
+        "/actor/reader/public/denied.txt",
+        "/actor/writer/public/denied.txt",
     ] {
-        let written = ask(
+        let denied = ask(
             &host,
             &mut mailbox,
             "writer",
-            json!({"type": "write", "path": path, "text": "shared"}),
+            json!({"type": "write", "path": path, "text": "denied"}),
         )
         .await;
-        assert_eq!(written.body["type"], "ok", "write to {path} failed");
+        assert_eq!(denied.body["type"], "error", "write to {path} succeeded");
     }
 
     let written = ask(
@@ -176,7 +176,43 @@ async fn filesystem_is_writable_and_public_aliases_share_files() {
 }
 
 #[tokio::test]
-async fn actors_can_read_and_write_other_actor_data() {
+async fn config_is_shared_writable_and_survives_host_restart() {
+    let (world, host, mut mailbox) = filesystem_world("world-config").await;
+    let path = "/config/global.json";
+    let first = r#"{"model":"first"}"#;
+    let second = r#"{"model":"second"}"#;
+    ask_type(
+        &host, &mut mailbox, "writer",
+        json!({"type": "write", "path": path, "text": first}), "ok",
+    ).await;
+    let read = ask_type(
+        &host, &mut mailbox, "reader",
+        json!({"type": "read", "path": path}), "content",
+    ).await;
+    assert_eq!(read.body["text"], first);
+    // The second actor can replace the same file too.
+    ask_type(
+        &host, &mut mailbox, "reader",
+        json!({"type": "write", "path": path, "text": second}), "ok",
+    ).await;
+    assert_eq!(std::fs::read_to_string(world.config_dir().join("global.json")).unwrap(), second);
+    assert_eq!(world.resolve("writer", path).unwrap(), world.config_dir().join("global.json"));
+    assert_eq!(world.resolve("console", path).unwrap(), world.config_dir().join("global.json"));
+    host.stop().await;
+
+    let (host, mut mailbox) = start(&world).await;
+    for actor in ["writer", "reader"] {
+        let read = ask_type(
+            &host, &mut mailbox, actor,
+            json!({"type": "read", "path": path}), "content",
+        ).await;
+        assert_eq!(read.body["text"], second);
+    }
+    host.stop().await;
+}
+
+#[tokio::test]
+async fn actors_can_read_but_not_write_other_actor_data() {
     let (_, host, mut mailbox) = filesystem_world("actor-data-sharing").await;
     ask_type(
         &host,
@@ -201,10 +237,10 @@ async fn actors_can_read_and_write_other_actor_data() {
         &mut mailbox,
         "reader",
         json!({"type": "write", "path": "/actor/writer/data/x", "text": "changed"}),
-        "ok",
+        "error",
     )
     .await;
-    let changed = ask_type(
+    let unchanged = ask_type(
         &host,
         &mut mailbox,
         "writer",
@@ -212,49 +248,7 @@ async fn actors_can_read_and_write_other_actor_data() {
         "content",
     )
     .await;
-    assert_eq!(changed.body["text"], "changed");
-    host.stop().await;
-}
-
-#[tokio::test]
-async fn world_root_is_shared_writable_and_survives_restart() {
-    let (world, host, mut mailbox) = filesystem_world("world-root").await;
-    assert!(world.root.join("config").is_dir());
-    ask_type(&host, &mut mailbox, "writer", json!({"type": "write", "path": "/self/data/x", "text": "self-alias"}), "ok").await;
-    assert_eq!(ask_type(&host, &mut mailbox, "writer", json!({"type": "read", "path": "/data/x"}), "content").await.body["text"], "self-alias");
-    let file = "/config/x";
-    ask_type(&host, &mut mailbox, "writer", json!({"type": "write", "path": file, "text": "first"}), "ok").await;
-    let read = json!({"type": "read", "path": file});
-    assert_eq!(ask_type(&host, &mut mailbox, "reader", read.clone(), "content").await.body["text"], "first");
-    ask_type(&host, &mut mailbox, "reader", json!({"type": "write", "path": file, "text": "second"}), "ok").await;
-    assert_eq!(std::fs::read_to_string(world.root.join("config/x")).unwrap(), "second");
-    for actor in ["writer", "reader"] {
-        assert_eq!(world.resolve(actor, file).unwrap(), world.root.join("config/x"));
-    }
-    assert_eq!(world.global_path(&world.root.join("config/x")).as_deref(), Some(file));
-
-    // Watches use the same world namespace, not only /actor paths.
-    let watching = request(&host, &mut mailbox, json!({"type": "watch", "path": world.root.join("config").display().to_string()})).await;
-    assert_eq!(watching.body, json!({"type": "watching", "path": "/config"}));
-    drain(&mut mailbox, Duration::from_millis(300)).await;
-    std::fs::write(world.root.join("config/event"), "watched").unwrap();
-    assert_eq!(fs_events(drain(&mut mailbox, Duration::from_millis(600)).await),
-        vec![json!({"type": "fs_changed", "path": "/config/event", "op": "create"})]);
-    request(&host, &mut mailbox, json!({"type": "unwatch", "path": world.root.join("config").display().to_string()})).await;
-
-    // A new top-level folder appears in already running instances, without a mount change.
-    std::fs::create_dir(world.root.join("docs")).unwrap();
-    std::fs::write(world.root.join("docs/new"), "host-created").unwrap();
-    let docs = json!({"type": "read", "path": "/docs/new"});
-    assert_eq!(ask_type(&host, &mut mailbox, "reader", docs, "content").await.body["text"], "host-created");
-    ask_type(&host, &mut mailbox, "reader", json!({"type": "write", "path": "/docs/new", "text": "actor-updated"}), "ok").await;
-    assert_eq!(std::fs::read_to_string(world.root.join("docs/new")).unwrap(), "actor-updated");
-    host.stop().await;
-
-    let (host, mut mailbox) = start(&world).await;
-    for actor in ["writer", "reader"] {
-        assert_eq!(ask_type(&host, &mut mailbox, actor, read.clone(), "content").await.body["text"], "second");
-    }
+    assert_eq!(unchanged.body["text"], "shared");
     host.stop().await;
 }
 
@@ -769,22 +763,6 @@ async fn cargo_actor_runs_unit_tests_by_default_and_can_skip_them() {
     host.stop().await;
 }
 
-#[tokio::test]
-async fn cargo_actor_compiles_c_code_for_wasi() {
-    let world = create_world("cargo-c");
-    let (host, mut mailbox) = start(&world).await;
-    let source = cargo_source("cargo-c");
-    let id = host.broker.send("console", Some("cargo"), None, None, json!({"type": "build", "source": source.display().to_string()}));
-    let built = receive_reply(&mut mailbox, &id, Duration::from_secs(300)).await;
-    assert_eq!(built.body["type"], "built", "{built:?}");
-    assert_eq!(built.body["tests"]["passed"], 1, "{built:?}");
-    let wasm = host.world.resolve("console", built.body["wasm"].as_str().unwrap()).unwrap();
-    spawn_type(&host, &mut mailbox, "c-add", &wasm, &source).await;
-    let sum = ask_type(&host, &mut mailbox, "c-add", json!({"type": "add", "a": 2, "b": 3}), "sum").await;
-    assert_eq!(sum.body["value"], 5);
-    host.stop().await;
-}
-
 #[tokio::test]
 async fn rejects_invalid_actor_ids() {
     let world = create_world("invalid-id");
@@ -1245,7 +1223,7 @@ async fn a_watcher_overflow_sends_one_rescan_and_runs_a_full_pass() {
     let report = host.broker.clone().overflowed().await;
     assert!(report.iter().any(|r| r["type"] == "spawned" && r["actor"] == "planted"), "{report:?}");
 
-    let rescan = json!({"type": "fs_changed", "path": "/", "op": "rescan"});
+    let rescan = json!({"type": "fs_changed", "path": "/actor", "op": "rescan"});
     assert_eq!(fs_events(drain(&mut mailbox, Duration::from_millis(600)).await), vec![rescan]);
     assert!(bystander.try_recv().is_err(), "an actor without watches got the rescan");
     host.stop().await;

flake.nix

@@ -26,14 +26,6 @@
         # PATH. Keep this same runtime path in the packaged host and exercise
         # the installed binary below with PATH deliberately empty.
         runtimePath = pkgs.lib.makeBinPath [ rust pkgs.stdenv.cc ];
-        # A WASI clang with wasi-libc, so that build scripts (the `cc` crate)
-        # can compile C for wasm32-wasip2. Its headers are WASI 0.1: C code
-        # that needs sockets does not build.
-        wasiCc = pkgs.pkgsCross.wasi32.stdenv.cc;
-        wasiCcEnv = {
-          CC_wasm32_wasip2 = "${wasiCc}/bin/${wasiCc.targetPrefix}cc";
-          AR_wasm32_wasip2 = "${wasiCc}/bin/${wasiCc.targetPrefix}ar";
-        };
         craneLib = (crane.mkLib pkgs).overrideToolchain rust;
         common = {
           pname = "sausage";
@@ -56,12 +48,9 @@
           cargoExtraArgs = "--locked -p sausage";
           doCheck = false;
           nativeBuildInputs = [ pkgs.makeWrapper ];
-          # The `cargo` actor runs cargo at runtime. Build scripts need a C linker,
-          # and C code for WASI needs the WASI clang.
+          # The `cargo` actor runs cargo at runtime. Build scripts need a C linker.
           postInstall = ''
-            wrapProgram $out/bin/sausage --prefix PATH : ${runtimePath} \
-              --set-default CC_wasm32_wasip2 ${wasiCcEnv.CC_wasm32_wasip2} \
-              --set-default AR_wasm32_wasip2 ${wasiCcEnv.AR_wasm32_wasip2}
+            wrapProgram $out/bin/sausage --prefix PATH : ${runtimePath}
           '';
           meta.mainProgram = "sausage";
         });
@@ -95,7 +84,7 @@
         # The binary the host loop runs (`nix run`), built from the same
         # cached dependencies as the tests.
         checks.package = sausage;
-        checks.tests = craneLib.cargoTest (common // wasiCcEnv // {
+        checks.tests = craneLib.cargoTest (common // {
           inherit cargoArtifacts;
           cargoExtraArgs = "--locked ${testPackages}";
           # Nothing builds on the test run's target folder: don't store it.
@@ -125,35 +114,7 @@
           version = "0.1.0"
           edition = "2024"
           TOML
-          # C code for WASI, compiled with the packaged WASI clang. The native
-          # test build has no C, so it needs no C compiler for the host.
-          printf 'int probe_add(int a, int b) { return a + b; }\n' > "$source/src/add.c"
-          cat > "$source/build.rs" <<'RUST'
-          use std::process::Command;
-          fn main() {
-              if std::env::var("TARGET").unwrap() != "wasm32-wasip2" {
-                  return;
-              }
-              let out = std::env::var("OUT_DIR").unwrap();
-              let cc = std::env::var("CC_wasm32_wasip2").expect("CC_wasm32_wasip2");
-              let ar = std::env::var("AR_wasm32_wasip2").expect("AR_wasm32_wasip2");
-              let object = format!("{out}/add.o");
-              assert!(Command::new(cc).args(["-c", "src/add.c", "-o", &object]).status().unwrap().success());
-              assert!(Command::new(ar).args(["crs", &format!("{out}/libadd.a"), &object]).status().unwrap().success());
-              println!("cargo:rustc-link-search=native={out}");
-              println!("cargo:rustc-link-lib=static=add");
-          }
-          RUST
-          cat > "$source/src/main.rs" <<'RUST'
-          #[cfg(target_os = "wasi")]
-          unsafe extern "C" {
-              fn probe_add(a: i32, b: i32) -> i32;
-          }
-          fn main() {
-              #[cfg(target_os = "wasi")]
-              assert_eq!(unsafe { probe_add(2, 3) }, 5);
-          }
-          RUST
+          printf 'fn main() {}\n' > "$source/src/main.rs"
           cat > "$source/tests/probe.rs" <<'RUST'
           #[test]
           fn native_test_harness_runs() {
@@ -200,11 +161,11 @@
         apps.default = { type = "app"; program = "${sausage}/bin/sausage"; };
         apps.loop = { type = "app"; program = "${loop}/bin/sausage-loop"; };
 
-        devShells.default = pkgs.mkShell (wasiCcEnv // {
+        devShells.default = pkgs.mkShell {
           packages = [ rust pkgs.wasmtime pkgs.wasm-tools ];
           shellHook = ''
             export CARGO_HOME="$PWD/.cargo-home"
           '';
-        });
+        };
       });
 }