kobako 0.29.0 → 0.30.0

data/crates/kobako-wasmtime/src/invocation.rs

@@ -16,6 +16,7 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use kobako_runtime::dispatch::DispatchHandler;
+use kobako_runtime::endpoint::{Calls, MemoryCap, ABANDONED};
 
 use crate::exports::Exports;
 use crate::limiter::MemoryLimiter;
@@ -31,31 +32,39 @@ use crate::wasi::Wasi;
 /// the mutation surface stays narrow.
 pub(crate) struct Invocation {
     wasi: Wasi,
-    on_dispatch: Option<Arc<dyn DispatchHandler>>,
+    calls: Calls<wasmtime::Error>,
     deadline: Option<Instant>,
     limiter: MemoryLimiter,
     wall_entry: Option<Instant>,
     wall_time: Duration,
-    reentry_trap: Option<wasmtime::Error>,
     exports: Option<Exports>,
-    open_calls: u32,
+    hostcall_fuel: usize,
 }
 
 impl Invocation {
     pub(crate) fn new(memory_limit: Option<usize>, wasi: Wasi) -> Self {
         Self {
             wasi,
-            on_dispatch: None,
+            calls: Calls::default(),
             deadline: None,
-            limiter: MemoryLimiter::new(memory_limit),
+            limiter: MemoryLimiter(MemoryCap::new(memory_limit)),
             wall_entry: None,
             wall_time: Duration::ZERO,
-            reentry_trap: None,
             exports: None,
-            open_calls: 0,
+            hostcall_fuel: 0,
         }
     }
 
+    /// How much of the guest's memory the call under way may have the host
+    /// copy or walk, as wasmtime hands each host call.
+    pub(crate) fn hostcall_fuel(&self) -> usize {
+        self.hostcall_fuel
+    }
+
+    pub(crate) fn set_hostcall_fuel(&mut self, fuel: usize) {
+        self.hostcall_fuel = fuel;
+    }
+
     pub(crate) fn set_exports(&mut self, exports: Exports) {
         self.exports = Some(exports);
     }
@@ -66,49 +75,20 @@ impl Invocation {
         self.exports.clone()
     }
 
-    /// The first trap wins: the upcall import ends the invocation with it,
-    /// so the trap keeps its own kind.
-    pub(crate) fn record_reentry_trap(&mut self, trap: wasmtime::Error) {
-        self.reentry_trap.get_or_insert(trap);
-    }
-
-    /// Once a callback into the guest has trapped, the guest is past
-    /// resuming.
-    pub(crate) fn reentry_trapped(&self) -> bool {
-        self.reentry_trap.is_some()
-    }
-
-    pub(crate) fn take_reentry_trap(&mut self) -> Option<wasmtime::Error> {
-        self.reentry_trap.take()
-    }
-
-    /// Count a Call the host is about to answer and name its frame, as the
-    /// guest counts the Calls it has open.
-    pub(crate) fn open_call(&mut self) -> u32 {
-        self.open_calls += 1;
-        self.open_calls - 1
-    }
-
-    pub(crate) fn close_call(&mut self) {
-        self.open_calls -= 1;
+    /// The state of the Calls open on this instance.
+    pub(crate) fn calls_mut(&mut self) -> &mut Calls<wasmtime::Error> {
+        &mut self.calls
     }
 
     pub(crate) fn bind_on_dispatch(&mut self, handler: Arc<dyn DispatchHandler>) {
-        self.on_dispatch = Some(handler);
-    }
-
-    /// A clone, so the borrow on the `Caller` is released and the
-    /// dispatcher can re-borrow it to write the Reply.
-    pub(crate) fn on_dispatch(&self) -> Option<Arc<dyn DispatchHandler>> {
-        self.on_dispatch.clone()
+        self.calls.bind(handler);
     }
 
     /// The trap ending an invocation its host gave up on.
     pub(crate) fn abandonment(&self) -> Option<wasmtime::Error> {
-        self.on_dispatch
-            .as_ref()
-            .is_some_and(|handler| handler.abandoned())
-            .then(|| wasmtime::Error::msg("the host abandoned the invocation"))
+        self.calls
+            .abandoned()
+            .then(|| wasmtime::Error::msg(ABANDONED))
     }
 
     pub(crate) fn wasi(&self) -> &Wasi {
@@ -135,13 +115,13 @@ impl Invocation {
     /// image's initial allocation and the high-water mark of earlier
     /// invocations do not consume the budget.
     pub(crate) fn arm_memory_cap(&mut self, baseline: usize) {
-        self.limiter.activate(baseline);
+        self.limiter.0.activate(baseline);
     }
 
     /// Disarmed once the export returns, so post-run host bookkeeping such
     /// as reading the answer back is not charged to the script.
     pub(crate) fn disarm_memory_cap(&mut self) {
-        self.limiter.deactivate();
+        self.limiter.0.deactivate();
     }
 
     /// Stamped right before the guest export call, so the bracket matches
@@ -161,6 +141,6 @@ impl Invocation {
     }
 
     pub(crate) fn memory_peak(&self) -> usize {
-        self.limiter.peak()
+        self.limiter.0.peak()
     }
 }

data/crates/kobako-wasmtime/src/lib.rs

@@ -13,17 +13,14 @@
 mod abi;
 mod ambient;
 mod cache;
-mod capture;
 mod config;
 mod descriptors;
-mod dispatch;
 mod driver;
 mod exports;
-mod guest_mem;
+mod guest;
 mod imports;
 mod instance_pre;
 mod invocation;
-mod io;
 mod limiter;
 mod preview1;
 mod trap;

data/crates/kobako-wasmtime/src/limiter.rs

@@ -1,65 +1,11 @@
-//! The per-invocation memory cap: only the `memory.grow` delta past the
-//! linear-memory size captured at invocation entry is charged, so the
-//! image's initial allocation is outside the budget.
+//! Hands wasmtime's growth hook to the runtime's per-invocation memory cap.
 
+use kobako_runtime::endpoint::MemoryCap;
 use wasmtime::ResourceLimiter;
 
-/// Resource limiter that enforces the per-invocation `memory_limit`
-/// cap.
-///
-/// `max_memory` is the byte cap on per-invocation growth (`None` disables
-/// the cap). `baseline` is the linear-memory size captured at invocation
-/// entry by `MemoryLimiter::activate`; the limiter charges only the
-/// `memory.grow` delta past `baseline` against `max_memory`, so the
-/// mruby image's initial allocation and any high-water mark left by
-/// prior invocations on the same Sandbox do not consume the budget.
-/// `cap_active` gates whether the cap is enforced — wasmtime's
-/// `ResourceLimiter` also fires for the module's declared initial
-/// allocation at instantiation time, but the cap stays dormant until
-/// `MemoryLimiter::activate` flips the flag for one `Driver` invoke
-/// call. When `cap_active` is `false`, the limiter always allows
-/// growth.
-///
-/// When `memory.grow` would push the per-invocation delta past
-/// `max_memory`, the limiter returns `MemoryLimitTrap` from
-/// `memory_growing`; wasmtime turns that into the trap surfaced to the
-/// host as a guest invocation failure.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct MemoryLimiter {
-    max_memory: Option<usize>,
-    baseline: usize,
-    cap_active: bool,
-    peak: usize,
-}
-
-impl MemoryLimiter {
-    pub(crate) fn new(max_memory: Option<usize>) -> Self {
-        Self {
-            max_memory,
-            baseline: 0,
-            cap_active: false,
-            peak: 0,
-        }
-    }
-
-    /// The cap stays dormant until armed, because the module's declared
-    /// initial memory is allocated during instantiation and must pass.
-    pub(crate) fn activate(&mut self, baseline: usize) {
-        self.baseline = baseline;
-        self.cap_active = true;
-        self.peak = 0;
-    }
-
-    pub(crate) fn deactivate(&mut self) {
-        self.cap_active = false;
-    }
-
-    /// A grow the cap rejects never updates the peak, so the reported value
-    /// never exceeds `memory_limit`.
-    pub(crate) fn peak(&self) -> usize {
-        self.peak
-    }
-}
+/// wasmtime asks this as `memory.grow` runs; an `Err` becomes the trap
+/// surfaced to the host as a guest invocation failure.
+pub(crate) struct MemoryLimiter(pub(crate) MemoryCap);
 
 impl ResourceLimiter for MemoryLimiter {
     fn memory_growing(
@@ -68,18 +14,7 @@ impl ResourceLimiter for MemoryLimiter {
         desired: usize,
         _maximum: Option<usize>,
     ) -> wasmtime::Result<bool> {
-        if !self.cap_active {
-            return Ok(true);
-        }
-        let delta = desired.saturating_sub(self.baseline);
-        if let Some(limit) = self.max_memory {
-            if delta > limit {
-                return Err(wasmtime::Error::new(MemoryLimitTrap { desired, limit }));
-            }
-        }
-        if delta > self.peak {
-            self.peak = delta;
-        }
+        self.0.charge(desired).map_err(wasmtime::Error::new)?;
         Ok(true)
     }
 
@@ -92,162 +27,3 @@ impl ResourceLimiter for MemoryLimiter {
         Ok(true)
     }
 }
-
-/// Marker error returned from `MemoryLimiter::memory_growing` when the
-/// per-invocation memory cap is exceeded. Downcast from the wasmtime
-/// trap error to classify the failure as a memory-limit `Trap`. Callers
-/// use the `Display` impl below — no field is read directly — so the
-/// inner state stays private.
-#[derive(Debug)]
-pub(crate) struct MemoryLimitTrap {
-    desired: usize,
-    limit: usize,
-}
-
-impl MemoryLimitTrap {
-    #[cfg(test)]
-    pub(crate) fn new(desired: usize, limit: usize) -> Self {
-        Self { desired, limit }
-    }
-}
-
-impl std::fmt::Display for MemoryLimitTrap {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "memory usage exceeded memory_limit: \
-             requested={} bytes, limit={} bytes",
-            self.desired, self.limit
-        )
-    }
-}
-
-impl std::error::Error for MemoryLimitTrap {}
-
-#[cfg(test)]
-mod tests {
-    //! Unit tests for `MemoryLimiter` — the per-invocation memory
-    //! delta cap. The Ruby-facing E2E suite exercises the full path
-    //! through wasmtime; these tests pin the pure delta arithmetic so
-    //! a regression that breaks the baseline accounting (e.g. dropping
-    //! the `baseline` subtraction, or letting `activate` carry stale
-    //! state across invocations) is caught without spinning up a
-    //! Store.
-    use super::{MemoryLimitTrap, MemoryLimiter};
-    use wasmtime::ResourceLimiter;
-
-    fn assert_growing(limiter: &mut MemoryLimiter, desired: usize) {
-        assert!(
-            limiter.memory_growing(0, desired, None).unwrap(),
-            "expected memory_growing({desired}) to allow growth"
-        );
-    }
-
-    fn assert_trapping(limiter: &mut MemoryLimiter, desired: usize) {
-        let err = limiter
-            .memory_growing(0, desired, None)
-            .expect_err("expected memory_growing to trap");
-        assert!(
-            err.downcast_ref::<MemoryLimitTrap>().is_some(),
-            "expected MemoryLimitTrap, got {err:?}"
-        );
-    }
-
-    // @behavior S-113
-    #[test]
-    fn dormant_limiter_allows_any_growth() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        // Without `activate`, the cap is dormant — the module's
-        // declared initial allocation must pass through unconditionally.
-        assert_growing(&mut limiter, 100 << 20);
-    }
-
-    // @behavior S-114
-    #[test]
-    fn delta_below_cap_passes_after_activate() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        // baseline=2 MiB, desired=2.5 MiB → delta=0.5 MiB ≤ 1 MiB cap.
-        assert_growing(&mut limiter, (2 << 20) + (1 << 19));
-    }
-
-    // @behavior S-121
-    #[test]
-    fn delta_past_cap_traps_with_memory_limit_trap() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        // baseline=2 MiB, desired=4 MiB → delta=2 MiB > 1 MiB cap.
-        assert_trapping(&mut limiter, 4 << 20);
-    }
-
-    // @behavior S-008
-    #[test]
-    fn activate_resets_baseline_on_each_invocation() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        assert_growing(&mut limiter, (2 << 20) + (1 << 20));
-        // Second invocation: linear memory has grown to 3 MiB. Re-arming
-        // must re-anchor the baseline so the next 1 MiB of growth fits
-        // the per-invocation budget rather than being charged against
-        // the prior invocation's residue.
-        limiter.activate(3 << 20);
-        assert_growing(&mut limiter, (3 << 20) + (1 << 20));
-    }
-
-    // @behavior S-009
-    #[test]
-    fn disabled_cap_ignores_delta_size() {
-        let mut limiter = MemoryLimiter::new(None);
-        limiter.activate(0);
-        assert_growing(&mut limiter, 100 << 20);
-    }
-
-    // @behavior S-116
-    #[test]
-    fn peak_starts_at_zero_before_any_grow() {
-        let limiter = MemoryLimiter::new(Some(1 << 20));
-        assert_eq!(limiter.peak(), 0);
-    }
-
-    // @behavior S-115
-    #[test]
-    fn peak_tracks_high_water_of_delta_past_baseline() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        assert_growing(&mut limiter, (2 << 20) + (1 << 18)); // delta=256 KiB
-        assert_growing(&mut limiter, (2 << 20) + (1 << 19)); // delta=512 KiB (new peak)
-        assert_growing(&mut limiter, (2 << 20) + (1 << 17)); // delta=128 KiB (below peak)
-        assert_eq!(limiter.peak(), 1 << 19);
-    }
-
-    // @behavior S-062
-    #[test]
-    fn trap_does_not_update_peak() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        assert_growing(&mut limiter, (2 << 20) + (1 << 19)); // delta=512 KiB
-        assert_trapping(&mut limiter, (2 << 20) + (2 << 20)); // would be 2 MiB > 1 MiB cap
-                                                              // Peak reflects the last accepted grow, not the rejected desired.
-        assert_eq!(limiter.peak(), 1 << 19);
-    }
-
-    // @behavior S-117
-    #[test]
-    fn activate_resets_peak_for_new_invocation() {
-        let mut limiter = MemoryLimiter::new(Some(1 << 20));
-        limiter.activate(2 << 20);
-        assert_growing(&mut limiter, (2 << 20) + (1 << 19));
-        assert_eq!(limiter.peak(), 1 << 19);
-        limiter.activate(3 << 20);
-        assert_eq!(limiter.peak(), 0);
-    }
-
-    // @behavior S-118
-    #[test]
-    fn disabled_cap_still_tracks_peak() {
-        let mut limiter = MemoryLimiter::new(None);
-        limiter.activate(1 << 20);
-        assert_growing(&mut limiter, (1 << 20) + (4 << 20));
-        assert_eq!(limiter.peak(), 4 << 20);
-    }
-}

data/crates/kobako-wasmtime/src/preview1/differential/mount.rs

@@ -1,37 +1,41 @@
 //! The differential probe beneath a Mount: each path call, made on the
-//! same host directory through kobako's `Directory` Mount and through
+//! same host directory through kobako's `Bind` Mount and through
 //! wasmtime-wasi's own preopen, must leave the same errno, the same
 //! descriptor, and the same directory behind. A listing of the Mount must
 //! answer the same errno.
 //!
-//! A Filesystem reports no timestamps or inode numbers, so of what a
-//! stat writes only the filetype is compared; the errno and the
-//! directory carry the rest of the decision.
+//! kobako's inode numbers are its own, and its times differ from the host's
+//! by when each call ran, so of what a stat writes only the filetype is
+//! compared; the errno and the directory carry the rest of the decision.
 //!
 //! Where POSIX lets each host choose, wasmtime-wasi passes on the host's
 //! own answer — unlinking a directory is `ISDIR` on Linux and `PERM` on
 //! macOS. kobako answers one way on every host, the way Linux does, so
 //! the probe holds where CI runs it.
+//!
+//! An open asking to sync, or for a directory it would truncate, is left out:
+//! wasmtime-wasi refuses both as invalid or unsupported, where kobako answers
+//! as Linux does, which `mount_view` holds to literal answers.
 
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, OnceLock};
 
-use kobako_runtime::filesystem::Access;
-use kobako_runtime::filesystem::Directory;
+use kobako_runtime::filesystem::Bind;
+use kobako_runtime::filesystem::Filesystem;
 use kobako_runtime::grant::Grant;
-use kobako_runtime::mount::Mount;
+use kobako_runtime::mount::{Access, Mount};
 use kobako_runtime::profile::Profile;
+use kobako_runtime::vfs::PATH_MAX;
 use wasmtime::{Linker, Module, Store};
 use wasmtime_wasi::p1::{self, WasiP1Ctx};
 use wasmtime_wasi::{FsPerms, WasiCtxBuilder};
 
-use crate::cache::shared_engine;
+use crate::cache::load_engine;
 use crate::config::Config;
 use crate::imports;
 use crate::invocation::Invocation;
-use crate::preview1::beneath::PATH_MAX;
 use crate::trap::NO_TIMEOUT_EPOCH_DELTA;
 use crate::wasi::Wasi;
 
@@ -89,7 +93,6 @@ const OFLAGS_DIRECTORY: i32 = 1 << 1;
 const OFLAGS_EXCL: i32 = 1 << 2;
 const OFLAGS_TRUNC: i32 = 1 << 3;
 const FDFLAGS_NONBLOCK: i32 = 1 << 2;
-const FDFLAGS_SYNC: i32 = 1 << 4;
 const RIGHTS_FD_READ: i64 = 1 << 1;
 const RIGHTS_FD_WRITE: i64 = 1 << 6;
 
@@ -102,6 +105,7 @@ const PATHS: &[&str] = &[
     "",
     ".",
     "a/",
+    "g",
     "l/",
     "n/",
     "g/",
@@ -193,16 +197,6 @@ const CALLS: &[Call] = &[
         rights: RIGHTS_FD_READ,
         fdflags: 0,
     },
-    Call::Open {
-        oflags: OFLAGS_DIRECTORY | OFLAGS_TRUNC,
-        rights: RIGHTS_FD_READ,
-        fdflags: 0,
-    },
-    Call::Open {
-        oflags: 0,
-        rights: RIGHTS_FD_READ,
-        fdflags: FDFLAGS_SYNC,
-    },
     Call::Open {
         oflags: 0,
         rights: RIGHTS_FD_READ,
@@ -378,9 +372,9 @@ fn through_wasmtime_wasi(call: Call, path: &str) -> Observation {
     observe(store, &linker, call, path, &host)
 }
 
-/// `host` behind a kobako `Directory` Mount at `AT`.
+/// `host` behind a kobako `Bind` Mount at `AT`.
 fn kobako_preopen(host: &HostDir) -> (Store<Invocation>, Linker<Invocation>) {
-    let engine = shared_engine().expect("shared engine must be constructible");
+    let engine = load_engine().expect("shared engine must be constructible");
     let config = Config {
         timeout: None,
         setup_timeout: None,
@@ -389,12 +383,19 @@ fn kobako_preopen(host: &HostDir) -> (Store<Invocation>, Linker<Invocation>) {
         stderr_limit: None,
         open_file_limit: None,
         profile: Profile::Hermetic,
+        security: Vec::new(),
     };
-    let directory = Directory::new(&host.0).expect("the host directory must open");
+    let directory = Bind::new(&host.0).expect("the host directory must open");
     let grant = Grant::Mount(
-        Mount::new(AT, Arc::new(directory), Access::ReadWrite).expect("AT is a guest path"),
+        Mount::new(
+            AT,
+            Filesystem::new(Arc::new(directory)).expect("the instance must stand"),
+            Access::ReadWrite,
+        )
+        .expect("AT is a guest path"),
     );
-    let wasi = Wasi::for_invocation(&config, &[], &[grant]).expect("WASI context must build");
+    let wasi =
+        Wasi::for_invocation(&config, Vec::new(), &[grant]).expect("WASI context must build");
     let mut store = Store::new(engine, Invocation::new(None, wasi));
     store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
     let linker = imports::linker().expect("host imports must link");
@@ -403,7 +404,7 @@ fn kobako_preopen(host: &HostDir) -> (Store<Invocation>, Linker<Invocation>) {
 
 /// `host` behind wasmtime-wasi's own preopen at `AT`.
 fn wasmtime_wasi_preopen(host: &HostDir) -> (Store<WasiP1Ctx>, Linker<WasiP1Ctx>) {
-    let engine = shared_engine().expect("shared engine must be constructible");
+    let engine = load_engine().expect("shared engine must be constructible");
     let ctx = WasiCtxBuilder::new()
         .preopened_dir(&host.0, AT, FsPerms::ReadWrite)
         .expect("the host directory must preopen")
@@ -416,17 +417,17 @@ fn wasmtime_wasi_preopen(host: &HostDir) -> (Store<WasiP1Ctx>, Linker<WasiP1Ctx>
 }
 
 const ERRNO_BUSY: i32 = 10;
+const ERRNO_EXIST: i32 = 20;
 const ERRNO_INVAL: i32 = 28;
 const ERRNO_ISDIR: i32 = 31;
-const ERRNO_LOOP: i32 = 32;
 const ERRNO_NAMETOOLONG: i32 = 37;
 const ERRNO_NOENT: i32 = 44;
 const ERRNO_NOTDIR: i32 = 54;
+const ERRNO_NOTEMPTY: i32 = 55;
 const ERRNO_NOTSUP: i32 = 58;
 const ERRNO_PERM: i32 = 63;
 const ERRNO_NOTCAPABLE: i32 = 76;
 
-/// Whether `path` reaches above the root it is resolved beneath.
 /// Whether `path` takes a `..`, or ends in a `.`, right after one of the
 /// host directory's links.
 fn steps_out_of_a_link(path: &str) -> bool {
@@ -439,6 +440,17 @@ fn steps_out_of_a_link(path: &str) -> bool {
         }
 }
 
+/// Whether `call` acts on the last name of `path` rather than land on it, a
+/// `.` or `..` there taking the walk nowhere, as Linux's `LOOKUP_PARENT` leaves
+/// it.
+fn acts_on_a_dot(call: Call, path: &str) -> bool {
+    matches!(
+        call,
+        Call::Mkdir | Call::Rmdir | Call::Unlink | Call::RenameFrom | Call::RenameTo
+    ) && matches!(path.rsplit('/').next(), Some("." | ".."))
+}
+
+/// Whether `path` reaches above the root it is resolved beneath.
 fn escapes(path: &str) -> bool {
     let mut depth = 0usize;
     path.starts_with('/')
@@ -458,9 +470,8 @@ fn escapes(path: &str) -> bool {
         })
 }
 
-/// What kobako answers where it differs from wasmtime-wasi on purpose. An
-/// open asking not to block is `NOTSUP`, where wasmtime-wasi records the
-/// flag and blocks anyway. A path above the root is `NOTCAPABLE`, the code preview1 names for a
+/// What kobako answers where it differs from wasmtime-wasi on purpose. A path
+/// above the root is `NOTCAPABLE`, the code preview1 names for a
 /// capability the guest was never handed, where wasmtime-wasi passes on
 /// cap-std's refusal as `PERM`. A path past `PATH_MAX` is `NAMETOOLONG`
 /// as Linux answers the whole path, where cap-std resolves it one name
@@ -469,11 +480,13 @@ fn escapes(path: &str) -> bool {
 /// which follows a link there, where cap-std's shortcut for one name
 /// drops the `/` and finds the file or the link. A `rmdir` of a link
 /// named with a trailing `/` is `NOTDIR` as Linux answers it, where
-/// cap-std's split turns the `/` into `.` and answers `INVAL`. A `..` or
+/// cap-std's split turns the `/` into `.` and answers `INVAL`. A `rmdir`
+/// of a path ending in `..` is `NOTEMPTY` as Linux answers it, where
+/// cap-std answers `INVAL` as it does for a final `.`. A `..` or
 /// a final `.` after a link is `LOOP` and changes nothing, where cap-std
 /// steps out of where the link points; a call refused before its path
 /// resolves answers alike.
-fn expected(call: Call, path: &str, mut oracle: Observation) -> Observation {
+fn predict(call: Call, path: &str, mut oracle: Observation) -> Observation {
     let refused = |errno| Observation {
         errno: Some(errno),
         opened: [0; 4],
@@ -482,20 +495,24 @@ fn expected(call: Call, path: &str, mut oracle: Observation) -> Observation {
         filetype: 0,
         tree: HostDir::new().tree(),
     };
-    if matches!(call, Call::Open { fdflags, .. } if fdflags & FDFLAGS_NONBLOCK != 0) {
-        return refused(if path.len() >= PATH_MAX {
-            ERRNO_NAMETOOLONG
-        } else {
-            ERRNO_NOTSUP
-        });
-    }
     let refused_first = matches!(oracle.errno, Some(ERRNO_BUSY | ERRNO_INVAL | ERRNO_NOTSUP));
-    if steps_out_of_a_link(path) && !refused_first {
-        return refused(ERRNO_LOOP);
+    if steps_out_of_a_link(path) && acts_on_a_dot(call, path) {
+        match call {
+            Call::Mkdir => return refused(ERRNO_EXIST),
+            Call::Unlink => return refused(ERRNO_ISDIR),
+            _ => {}
+        }
     }
     if escapes(path) && oracle.errno == Some(ERRNO_PERM) {
         oracle.errno = Some(ERRNO_NOTCAPABLE);
     }
+    // A directory keeps the flags it opened with, as Linux's `F_GETFL`
+    // reports them, where wasmtime-wasi reports none on one.
+    if let Call::Open { fdflags, .. } = call {
+        if oracle.errno == Some(0) && oracle.fdstat[0] == FILETYPE_DIRECTORY {
+            oracle.fdstat[2] = fdflags as u8;
+        }
+    }
     // A trailing `/` makes Linux's `lstat` follow the link at the end,
     // where cap-std leaves it, so the host's own `lstat` answers.
     if matches!(call, Call::StatNoFollow) && path.ends_with('/') {
@@ -532,7 +549,13 @@ fn expected(call: Call, path: &str, mut oracle: Observation) -> Observation {
             _ => {}
         }
     }
-    if path.len() >= PATH_MAX {
+    if matches!(call, Call::Rmdir)
+        && path.trim_end_matches('/').ends_with("..")
+        && oracle.errno == Some(ERRNO_INVAL)
+    {
+        oracle.errno = Some(ERRNO_NOTEMPTY);
+    }
+    if path.len() >= PATH_MAX && !refused_first {
         oracle.errno = Some(ERRNO_NAMETOOLONG);
     }
     oracle
@@ -554,13 +577,13 @@ fn every_path_call_beneath_a_mount_answers_as_a_wasmtime_wasi_preopen() {
         .flat_map(|&call| paths.iter().map(move |path| (call, path.as_str())))
         .filter_map(|(call, path)| {
             let kobako = through_kobako(call, path);
-            let oracle = expected(call, path, through_wasmtime_wasi(call, path));
+            let oracle = predict(call, path, through_wasmtime_wasi(call, path));
             (kobako != oracle).then(|| format!("{call:?} {path:?}: {kobako:?} != {oracle:?}"))
         })
         .collect();
     assert!(
         differing.is_empty(),
-        "each path call on a host directory through a kobako Directory Mount must answer as \
+        "each path call on a host directory through a kobako Bind Mount must answer as \
          wasmtime-wasi's preopen of it does:\n{}",
         differing.join("\n")
     );
@@ -604,6 +627,6 @@ fn a_listing_holding_a_name_that_is_not_utf8_answers_as_a_wasmtime_wasi_preopen(
     assert_eq!(
         kobako, oracle,
         "fd_readdir on a host directory holding a name that is not UTF-8 through a kobako \
-         Directory Mount must answer as wasmtime-wasi's preopen of it does"
+         Bind Mount must answer as wasmtime-wasi's preopen of it does"
     );
 }