kobako 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 890cacf8f9985d53603b280d11bcf5283da99c4bc5bf3eb0249ded25b9b8f4b5
-  data.tar.gz: e0303f7fe91a066a12e792094842325d1dc968f674ccc3bc9b05a82988adbbe8
+  metadata.gz: 3c3d1c75e0967f01b1284848372d66adda8cc65566b828bb1634f1624b1b4938
+  data.tar.gz: 223e0cc856970daf5c702775c1a3df2851d96beb72db1793e24c776747205a0c
 SHA512:
-  metadata.gz: c573074f4ef2cd26c8221f87a6fd3cb3ca50aa7738c28df7965ece8a8fc6953d29b5651acc97bfb10094ffb14dea6ad401f55a66205920e15af6e6dba9d3cdbd
-  data.tar.gz: 3d625d01a1fb1ca14213b20de469ffd095d49257553bfcf4b1960cd878675d5e48099dc058f723d77a6f0eb66363b15af690f7750896344d8e47c25b019490c4
+  metadata.gz: 4b6050756d4ed75616ea4aa82fe56febc11cc97c8b1cba165c607e70b6921dfad322c1594746b3e105338653fce93f5e208b4f2516c39f2f3cb4d9b85647b79b
+  data.tar.gz: 8c50704f755219097efdd41c5e47ba304fa98fe8843e5f39ee49df4c22cac7d7916cd8a96be472ffae3535d4f285422e0cca81917c722584b44165f262611212

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.19.0","wasm/kobako-core":"0.11.0","wasm/kobako-mruby":"0.11.0","wasm/kobako-io":"0.11.0","wasm/kobako-json":"0.11.0","wasm/kobako-regexp":"0.11.0","wasm/kobako-baker":"0.11.0","crates/kobako-codec":"0.11.0","crates/kobako-runtime":"0.11.0","crates/kobako-wasmtime":"0.11.0","crates/kobako":"0.11.0"}
+{".":"0.20.0","wasm/kobako-core":"0.12.0","wasm/kobako-mruby":"0.12.0","wasm/kobako-io":"0.12.0","wasm/kobako-json":"0.12.0","wasm/kobako-regexp":"0.12.0","wasm/kobako-baker":"0.12.0","crates/kobako-codec":"0.12.0","crates/kobako-runtime":"0.12.0","crates/kobako-wasmtime":"0.12.0","crates/kobako":"0.12.0"}

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.20.0](https://github.com/elct9620/kobako/compare/v0.19.0...v0.20.0) (2026-07-24)
+
+
+### Features
+
+* **bench:** mark a run in progress with a pid lock file ([3ca85fb](https://github.com/elct9620/kobako/commit/3ca85fbe9860ce32d58c1a5bf4ff85cbdc210780))
+* **execution:** tell a nil-value success from a failure with #failed? ([2f3d382](https://github.com/elct9620/kobako/commit/2f3d382b24d65fabda7771429cd3adfc90a8c7e8))
+* **extension:** declare a backend's kind by explicit keyword ([3f6c628](https://github.com/elct9620/kobako/commit/3f6c6283080ba4346ac8ef878e469dab8039e650))
+* **sandbox:** add the gvl: hold/release scheduling option ([ca2a884](https://github.com/elct9620/kobako/commit/ca2a884415b3271c44b20d131536b3fe7c5a3077))
+* **sandbox:** declare fillable Service paths defaulting to Kobako::Unresolved ([1d60f76](https://github.com/elct9620/kobako/commit/1d60f764ddff3b5b10206993e2b281c838ec0022))
+* **sandbox:** fill and override declared paths per invocation with ctx.bind ([629ef7d](https://github.com/elct9620/kobako/commit/629ef7dfa35273c952685fefb4c5793b11886aee))
+* **sandbox:** return a frozen Kobako::Invocation from #eval and #run ([e9f4634](https://github.com/elct9620/kobako/commit/e9f463403bea26fad32e52d560b979684f555ed1))
+* **tasks:** gate the wasmtime driver against a magnus dependency ([268c3f6](https://github.com/elct9620/kobako/commit/268c3f65f53d64b465458bca5c0c9b0d0467df44))
+
+
+### Bug Fixes
+
+* **context:** raise ArgumentError for a spent ctx.bind ([2783bba](https://github.com/elct9620/kobako/commit/2783bba20f139554178389d4c860e0c280cab550))
+* **extension:** re-assert dependencies after a failed seal ([72839ba](https://github.com/elct9620/kobako/commit/72839bac6186e81a1d4323bd3f1eb4f10abf3d64))
+
 ## [0.19.0](https://github.com/elct9620/kobako/compare/v0.18.0...v0.19.0) (2026-07-19)
 
 

data/Cargo.lock

@@ -43,9 +43,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.103"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
+checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
 
 [[package]]
 name = "arbitrary"
@@ -929,20 +929,21 @@ dependencies = [
 
 [[package]]
 name = "kobako"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "kobako-runtime",
  "kobako-wasmtime",
  "magnus",
+ "rb-sys",
 ]
 
 [[package]]
 name = "kobako-runtime"
-version = "0.11.0"
+version = "0.12.0"
 
 [[package]]
 name = "kobako-wasmtime"
-version = "0.11.0"
+version = "0.12.0"
 dependencies = [
  "kobako-runtime",
  "libc",

data/crates/kobako-runtime/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.12.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.11.0...kobako-runtime-v0.12.0) (2026-07-24)
+
+
+### Miscellaneous Chores
+
+* **kobako-runtime:** Synchronize kobako crates versions
+
 ## [0.11.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.10.2...kobako-runtime-v0.11.0) (2026-07-19)
 
 

data/crates/kobako-runtime/Cargo.toml

@@ -13,7 +13,7 @@
 
 [package]
 name = "kobako-runtime"
-version = "0.11.0"
+version = "0.12.0"
 edition = "2021"
 description = "Engine-neutral host runtime contract for embedding kobako Wasm guests."
 license = "Apache-2.0"

data/crates/kobako-runtime/README.md

@@ -26,7 +26,7 @@ map the neutral types onto their own language surface.
 
 ```toml
 [dependencies]
-kobako-runtime = "0.11.0" # x-release-please-version
+kobako-runtime = "0.12.0" # x-release-please-version
 ```
 
 ## License

data/crates/kobako-wasmtime/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.12.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.11.0...kobako-wasmtime-v0.12.0) (2026-07-24)
+
+
+### Miscellaneous Chores
+
+* **kobako-wasmtime:** Synchronize kobako crates versions
+
 ## [0.11.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.10.2...kobako-wasmtime-v0.11.0) (2026-07-19)
 
 

data/crates/kobako-wasmtime/Cargo.toml

@@ -15,7 +15,7 @@
 
 [package]
 name = "kobako-wasmtime"
-version = "0.11.0"
+version = "0.12.0"
 edition = "2021"
 description = "wasmtime implementation of the kobako host runtime contract."
 license = "Apache-2.0"
@@ -28,7 +28,7 @@ categories = ["wasm", "virtualization"]
 # The engine-neutral contract this crate implements. The version pin
 # rides the linked release group; the path keeps in-tree builds (and
 # the Ruby gem, which ships both crates) resolving locally.
-kobako-runtime = { version = "0.11.0", path = "../kobako-runtime" }
+kobako-runtime = { version = "0.12.0", path = "../kobako-runtime" }
 # wasmtime — host-side embedder for kobako.wasm. We disable default-features
 # and opt back in only what kobako needs: a Cranelift-backed runtime that can
 # compile a pre-built wasm32-wasip1 module on the host triple, plus the `wat`

data/crates/kobako-wasmtime/README.md

@@ -24,7 +24,7 @@ SDK consumes the same surface.
 
 ```toml
 [dependencies]
-kobako-wasmtime = "0.11.0" # x-release-please-version
+kobako-wasmtime = "0.12.0" # x-release-please-version
 ```
 
 ## License

data/ext/kobako/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kobako"
-version = "0.19.0"
+version = "0.20.0"
 edition = "2021"
 authors = ["Aotokitsuruya <contact@aotoki.me>"]
 license = "Apache-2.0"
@@ -10,7 +10,11 @@ publish = false
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.8.2" }
+magnus = { version = "0.8.2", features = ["rb-sys"] }
+# Raw Ruby FFI for the GVL release/re-acquire calls magnus does not wrap
+# (`rb_thread_call_without_gvl` / `rb_thread_call_with_gvl`). Pinned to the
+# rb-sys magnus resolves so both share one binding instance.
+rb-sys = { version = "0.9", default-features = false }
 # The engine-neutral host runtime contract plus its wasmtime driver —
 # the ext is a thin magnus shim over them. Pure path dependencies: both
 # crates ship inside the gem, so installs never resolve them against

data/ext/kobako/src/runtime/bridge.rs

@@ -104,11 +104,12 @@ impl GuestYielder {
     }
 }
 
-/// The Ruby-Proc bridge: a `DispatchHandler` backed by the host-side
-/// dispatch `Proc` registered through `Runtime#on_dispatch=`. This is the
-/// one place the dispatch seam touches `magnus`; the wasm runtime sees
-/// only the trait. The Proc is GC-rooted by `Runtime`'s `mark`; this
-/// struct holds an `Opaque` copy of the same handle.
+/// The Ruby-Proc bridge: a `DispatchHandler` backed by the per-invocation
+/// dispatch `Proc` handed to `Runtime#eval` / `#run` as a call argument.
+/// This is the one place the dispatch seam touches `magnus`; the wasm
+/// runtime sees only the trait. The Proc stays GC-rooted as a live argument
+/// on the Ruby stack for the synchronous call; this struct holds an
+/// `Opaque` copy of the same handle.
 pub(super) struct RubyDispatchHandler {
     on_dispatch: Opaque<Value>,
 }
@@ -127,24 +128,29 @@ impl DispatchHandler for RubyDispatchHandler {
     /// violation surfaced as `None` — the dispatcher then walks the
     /// 0-return wire-fault path.
     fn dispatch(&self, request: &[u8], yielder: &mut dyn Yielder) -> Option<Vec<u8>> {
-        // The wasmtime callback runs on the same Ruby thread that called
-        // the active Sandbox invocation (#eval or #run) — the invariant
-        // SPEC Implementation Standards Architecture pins for the host gem
-        // — so `Ruby::get()` is always available here. Panicking with
-        // `expect` localises the violation rather than letting a nonsense
-        // error propagate.
-        let ruby = Ruby::get().expect("Ruby handle unavailable in __kobako_dispatch");
-        let proc_value: Value = ruby.get_inner(self.on_dispatch);
-        let req_str = ruby.str_from_slice(request);
-        // Hand the Proc a frame-scoped yielder object as its second arg and
-        // invalidate it the instant the Proc returns, so a guest block that
-        // escapes the dispatch frame can never deref the freed stack
-        // pointer. `guest_yielder` holds no Ruby Value, so it needs no GC
-        // mark — the GC has nothing to trace through it.
-        let guest_yielder = ruby.obj_wrap(GuestYielder::new(yielder));
-        let resp: Result<RString, magnus::Error> =
-            proc_value.funcall("call", (req_str, guest_yielder));
-        guest_yielder.invalidate();
-        resp.ok().map(super::rstring_to_vec)
+        // The guest may be running GVL-free (`gvl: :release`); re-acquire the
+        // GVL for the whole callback before touching any Ruby VALUE. In hold
+        // mode `reenter` runs the body inline — the GVL is already held.
+        super::gvl::reenter(|| {
+            // The wasmtime callback runs on the same Ruby thread that called
+            // the active Sandbox invocation (#eval or #run) — the invariant
+            // SPEC Implementation Standards Architecture pins for the host gem
+            // — so `Ruby::get()` is available here once the GVL is held.
+            // Panicking with `expect` localises the violation rather than
+            // letting a nonsense error propagate.
+            let ruby = Ruby::get().expect("Ruby handle unavailable in __kobako_dispatch");
+            let proc_value: Value = ruby.get_inner(self.on_dispatch);
+            let req_str = ruby.str_from_slice(request);
+            // Hand the Proc a frame-scoped yielder object as its second arg and
+            // invalidate it the instant the Proc returns, so a guest block that
+            // escapes the dispatch frame can never deref the freed stack
+            // pointer. `guest_yielder` holds no Ruby Value, so it needs no GC
+            // mark — the GC has nothing to trace through it.
+            let guest_yielder = ruby.obj_wrap(GuestYielder::new(yielder));
+            let resp: Result<RString, magnus::Error> =
+                proc_value.funcall("call", (req_str, guest_yielder));
+            guest_yielder.invalidate();
+            resp.ok().map(super::rstring_to_vec)
+        })
     }
 }

data/ext/kobako/src/runtime/gvl.rs

@@ -0,0 +1,114 @@
+//! Releasing Ruby's GVL for the guest-execution span so distinct Sandboxes on
+//! distinct Threads run their guest code in parallel.
+//!
+//! `region` brackets one invocation's guest span, releasing the GVL when the
+//! Sandbox asks for it; `reenter` re-acquires the GVL for a guest→host dispatch
+//! callback, which is ordinary Ruby and must hold the lock. A thread-local flag
+//! stops a nested dispatch from re-acquiring a second time, and both directions
+//! run their closure through a `catch_unwind` trampoline because a panic must
+//! never cross the C frame of `rb_thread_call_without_gvl` /
+//! `rb_thread_call_with_gvl` (undefined behaviour). The flag is per-thread,
+//! matching the one-thread-one-Sandbox contract, and is restored through a drop
+//! guard so an unwinding panic cannot leave it corrupt for the next invocation.
+
+use std::cell::Cell;
+use std::os::raw::c_void;
+use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
+use std::ptr;
+
+thread_local! {
+    // True while this thread sits inside a region whose GVL we released and
+    // have not yet re-acquired. Drives `reenter`'s one-shot re-acquire.
+    static GVL_RELEASED: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Run `f` (one invocation's guest-execution span) and return its value,
+/// releasing the GVL for the span iff `release`. When holding, `f` runs inline.
+pub(crate) fn region<F, R>(release: bool, f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    if !release {
+        return f();
+    }
+    let _guard = ReleasedGuard::set(true);
+    call_via(f, |func, data| unsafe {
+        rb_sys::rb_thread_call_without_gvl(Some(func), data, None, ptr::null_mut())
+    })
+}
+
+/// Run `f` (a guest→host dispatch callback) under the GVL. Re-acquires the GVL
+/// when the enclosing region released it, and runs inline when the GVL is
+/// already held — hold mode, or a nested dispatch whose outer frame re-acquired
+/// it.
+pub(crate) fn reenter<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    if !GVL_RELEASED.with(|g| g.get()) {
+        return f();
+    }
+    let _guard = ReleasedGuard::set(false);
+    call_via(f, |func, data| unsafe {
+        rb_sys::rb_thread_call_with_gvl(Some(func), data)
+    })
+}
+
+/// Restores `GVL_RELEASED` to its prior value on drop, so an unwinding panic
+/// through a released region cannot leave the flag stuck.
+struct ReleasedGuard {
+    prev: bool,
+}
+
+impl ReleasedGuard {
+    fn set(value: bool) -> Self {
+        Self {
+            prev: GVL_RELEASED.with(|g| g.replace(value)),
+        }
+    }
+}
+
+impl Drop for ReleasedGuard {
+    fn drop(&mut self) {
+        GVL_RELEASED.with(|g| g.set(self.prev));
+    }
+}
+
+struct GvlCtx<F, R> {
+    f: Option<F>,
+    result: Option<std::thread::Result<R>>,
+}
+
+/// The `extern "C"` shim the `rb_thread_call_*` functions call: it runs the
+/// erased closure under `catch_unwind` so a panic is captured here rather than
+/// unwinding across the C frame, and stashes the outcome for `call_via`.
+unsafe extern "C" fn trampoline<F, R>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> R,
+{
+    let ctx = unsafe { &mut *data.cast::<GvlCtx<F, R>>() };
+    let f = ctx.f.take().expect("gvl trampoline runs its closure once");
+    ctx.result = Some(catch_unwind(AssertUnwindSafe(f)));
+    ptr::null_mut()
+}
+
+/// Drive `f` through one of the `rb_thread_call_*` entry points (`invoke`),
+/// erasing it to the C callback shape and re-raising on the caller's thread any
+/// panic the trampoline caught.
+fn call_via<F, R>(
+    f: F,
+    invoke: impl FnOnce(unsafe extern "C" fn(*mut c_void) -> *mut c_void, *mut c_void) -> *mut c_void,
+) -> R
+where
+    F: FnOnce() -> R,
+{
+    let mut ctx = GvlCtx::<F, R> {
+        f: Some(f),
+        result: None,
+    };
+    invoke(trampoline::<F, R>, ptr::addr_of_mut!(ctx).cast::<c_void>());
+    match ctx.result.take().expect("gvl trampoline stores a result") {
+        Ok(value) => value,
+        Err(payload) => resume_unwind(payload),
+    }
+}