kobako 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07d141331817191a0170e65ecf98a70243bc07f35ad2606bca47d5d9fdfbb13a
-  data.tar.gz: 2a9db59d9a5059221c337347d00aef74c7f6df36a337fe062fe9d8061550875e
+  metadata.gz: 77815cccc84108dd3ece9b1571ecaa2b089867bf7b9ac395e561c940300c78fb
+  data.tar.gz: 49199331280ce4f7324039be281dd4cdfcedfaa03ece5141e56b70c24895f6de
 SHA512:
-  metadata.gz: 658707b733c3b9d57bf2fb7efd32f7d1ef268139427453e190bfacb9f7115005bf581ae90f22d9614d16d09c05312652d400f3b7b23be5258db1a32d583294d8
-  data.tar.gz: 4bec58f9d19fe547e597e3ae3d6cc3fb6b9fa478986d4072de4e1ee1ce458ab9aca534a841e2c9b1d7de2548b9b6c59a1c3eab823f61b10a5ba18132e0878561
+  metadata.gz: b812aea26a6c6196fcd5dbb54b38d20d38e23577b0374fb89c620c725281dc569c3ef9dd44e2383842afc37dd2db0614601b0ba8c08d423338c38f1c511966f0
+  data.tar.gz: a55933ff5d6e425b6f98be8d2d57adcf733097a74a3524fd086005f463ba4372e0a3ced4cf2ce783e4049b3e2f7a7364baa090d76d70781cba8857334e230963

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.8.0","wasm/kobako-core":"0.2.0"}
+{".":"0.9.0","wasm/kobako-core":"0.4.0","wasm/kobako":"0.4.0","wasm/kobako-io":"0.4.0","wasm/kobako-regexp":"0.4.0"}

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.9.0](https://github.com/elct9620/kobako/compare/v0.8.0...v0.9.0) (2026-06-10)
+
+
+### Features
+
+* **regexp:** add Kernel#=~ fallback returning nil ([d461781](https://github.com/elct9620/kobako/commit/d4617815b8e888a09a548c7f4664819cdddc34c8))
+* **regexp:** add regexp-aware String#[]= ([34807f5](https://github.com/elct9620/kobako/commit/34807f5ba5f6e17efff27af3c5c24ae42b0b651d))
+* **regexp:** add Regexp.last_match and last_match= ([03649e8](https://github.com/elct9620/kobako/commit/03649e81cfda0c43ac22777f70ea38a0ac4a93c7))
+* **regexp:** add Regexp#named_captures and #names ([7cf018d](https://github.com/elct9620/kobako/commit/7cf018d39529be1d1384297b1b38b9d1670523e7))
+* **regexp:** add String#slice! ([2857e0e](https://github.com/elct9620/kobako/commit/2857e0ee55df9f6295a25391ff76613b8dd5d555))
+* **regexp:** align Regexp#match position handling with MRI ([c448c94](https://github.com/elct9620/kobako/commit/c448c9402a5a78076b5a81be0e07b7e1c90b1014))
+* **regexp:** align Regexp#to_s flag rendering with MRI ([67d0414](https://github.com/elct9620/kobako/commit/67d04145f116a72a0f84d0ddf6674559e97046e8))
+* **regexp:** copy the compiled pattern on Regexp dup/clone ([be97ea1](https://github.com/elct9620/kobako/commit/be97ea1cbd9556196f06229cd17d0288c062f133))
+* **regexp:** copy the match snapshot on MatchData dup/clone ([0719d99](https://github.com/elct9620/kobako/commit/0719d99c41df9ddc8905580d61b32f0e6d88b6ba))
+* **regexp:** define RegexpError in the gem instead of borrowing it ([ca57ca6](https://github.com/elct9620/kobako/commit/ca57ca6effb93ad05a175f2641f4b15aa971e31c))
+* **regexp:** escape the source in Regexp#inspect ([9142d6c](https://github.com/elct9620/kobako/commit/9142d6cd32e08271639548af7801284e5d198892))
+* **regexp:** expand backreferences and Hash in gsub/sub replacements ([8a0bc2d](https://github.com/elct9620/kobako/commit/8a0bc2dda8fb46a91fb1a5ee1c7482d6da9dffee))
+* **regexp:** forbid MatchData.new ([5e2b3f5](https://github.com/elct9620/kobako/commit/5e2b3f527ff68dd118c370bb1b0bd01bf3dc4f8f))
+* **regexp:** honour MatchData#named_captures(symbolize_names:) ([2a754d3](https://github.com/elct9620/kobako/commit/2a754d3d2ca3d4159471c8f9d17cc71ac59e0543))
+* **regexp:** honour the position argument in String#index ([4dfbb41](https://github.com/elct9620/kobako/commit/4dfbb41086b302eada56efea4cbbfd6579adbdab))
+* **regexp:** memoize compiled patterns per invocation ([f764d66](https://github.com/elct9620/kobako/commit/f764d66a574da51b9e714db1ae6d917cce4cf611))
+* **regexp:** raise IndexError for out-of-range MatchData#begin/#end/#offset ([85fc8d6](https://github.com/elct9620/kobako/commit/85fc8d67d0fcc137a7f43695ead34317d557ec1a))
+* **regexp:** reproduce the C match-family operand handling ([9e30d2d](https://github.com/elct9620/kobako/commit/9e30d2d6d6ddd42c84d5e2fb55cc2c06076c4fd4))
+* **regexp:** set the $+ last-group match global ([b65a424](https://github.com/elct9620/kobako/commit/b65a42434b2edd5b01ed879b09895d17ff778888))
+* **regexp:** support length and Range forms of MatchData#[] ([7ac4dee](https://github.com/elct9620/kobako/commit/7ac4deec79a215b35fdc2786522145ce6d34263c))
+* **regexp:** yield the MatchData to a block in Regexp#match / String#match ([f5a6e53](https://github.com/elct9620/kobako/commit/f5a6e53ec5993237805c2360fa70684f84acf6b8))
+* **wasm:** split the Guest Binary into a pure default and regexp variants ([21695b1](https://github.com/elct9620/kobako/commit/21695b1cd527e334c68f9730f01f92fef057e52f))
+
+
+### Bug Fixes
+
+* **regexp:** align String#=~ with MRI semantics ([c8f3e70](https://github.com/elct9620/kobako/commit/c8f3e70c9f0797c614aab1639934d280fe20b90a))
+* **regexp:** bound backtracking, clamp match positions, harden engine errors ([0177f71](https://github.com/elct9620/kobako/commit/0177f71cccf61c140912aab3c2e639286fd768d0))
+* **regexp:** correct String#split group and zero-width handling ([c0150bc](https://github.com/elct9620/kobako/commit/c0150bc04c5dccdd430b173219c42c8f607112d1))
+* **regexp:** honour capturing groups and the limit arg in String#split ([66e7398](https://github.com/elct9620/kobako/commit/66e73984f8318b582cc7aa0db48deacfb10e8671))
+* **regexp:** make Regexp.last_match= refresh the numbered globals ([e47b257](https://github.com/elct9620/kobako/commit/e47b257715b73263ae5d1f9bae67442197330ee0))
+* **regexp:** name the pattern in match-time errors and snap String#index pos ([5835f42](https://github.com/elct9620/kobako/commit/5835f42ae6b27e2a2a0d0bc5bf8023024a20642a))
+* **regexp:** stop escaping the slash in Regexp.escape ([6c6f17a](https://github.com/elct9620/kobako/commit/6c6f17a63dbddf30ccdba19ddf3c9b7fbb7772cd))
+
 ## [0.8.0](https://github.com/elct9620/kobako/compare/v0.7.0...v0.8.0) (2026-06-05)
 
 

data/Cargo.lock

@@ -878,7 +878,7 @@ dependencies = [
 
 [[package]]
 name = "kobako"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "magnus",
  "wasmtime",

data/README.md

@@ -322,6 +322,8 @@ Order-of-magnitude figures on macOS arm64, Ruby 3.4.7, YJIT off. Absolute values
 
 Construct one Sandbox at boot so the ~600 ms JIT cost lands off the request hot path. `ext/` does not release the GVL during wasmtime execution, so wasm work is GVL-serialized: aggregate throughput stays around 7-8k `#eval`/s regardless of Thread count, though Ruby-side `#eval` setup still overlaps. A +10% regression on any of the six SPEC-mandated benchmarks blocks release.
 
+Regexp is an opt-in capability gem, excluded from the default binary and the gated set; its throughput is tracked in a separate non-gated characterization (`#10` in [`benchmark/README.md`](benchmark/README.md)). There `=~` (~5 µs/match) costs about 4× `match?` (~1.2 µs), because `=~` eagerly builds the `MatchData` and match globals — prefer `match?` for boolean tests.
+
 ```bash
 bundle exec rake bench  # six gated regression benchmarks (~5-8 min)
 ```
@@ -335,7 +337,7 @@ bin/setup         # install dependencies
 bundle exec rake  # default: compile + test + rubocop + steep
 ```
 
-Building from source requires a WASI-capable Rust toolchain in addition to the standard host toolchain; the first compile walks the full vendor / mruby / wasm chain. See [`CLAUDE.md`](CLAUDE.md) for the rake task map and pipeline layout. `bin/console` opens an IRB session with the gem preloaded; `bundle exec rake install` installs the local checkout as a gem.
+Building from source requires a WASI-capable Rust toolchain in addition to the standard host toolchain; the first compile walks the full chain — the [beni](https://github.com/elct9620/beni) gem vendors wasi-sdk + mruby and builds `libmruby.a` (`rake beni:build`), then `rake wasm:build` produces the Guest Binary. See [`CLAUDE.md`](CLAUDE.md) for the rake task map and pipeline layout. `bin/console` opens an IRB session with the gem preloaded; `bundle exec rake install` installs the local checkout as a gem.
 
 ## Contributing
 

data/ext/kobako/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kobako"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2021"
 authors = ["Aotokitsuruya <contact@aotoki.me>"]
 license = "Apache-2.0"
@@ -14,9 +14,7 @@ magnus = { version = "0.8.2" }
 # 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`
-# feature
-# so test fixtures can be expressed as text. WASI integration is layered on
-# later via `wasmtime-wasi` once stdin/stdout wiring is needed (item #16).
+# feature so test fixtures can be expressed as text.
 # `cache` / `parallel-compilation` / `pooling` / `component-model` / `async`
 # are intentionally off — kobako runs short-lived synchronous sandboxes.
 wasmtime = { version = "45.0.0", default-features = false, features = [

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

@@ -1,7 +1,7 @@
 //! Host-side dispatch for the `__kobako_dispatch` import.
 //!
 //! When the guest invokes the wasm import declared in
-//! `wasm/kobako-wasm/src/abi.rs`, wasmtime calls back into the host
+//! `wasm/kobako-core/src/abi.rs`, wasmtime calls back into the host
 //! through the closure built in `super::Runtime::build`.
 //! That closure delegates here. The dispatcher (docs/behavior.md B-12 / B-13):
 //!
@@ -180,9 +180,9 @@ fn try_handle(
     write_response(caller, &resp_bytes)
 }
 
-/// Invoke the Ruby-side dispatch +Proc+ with the request bytes and return
+/// Invoke the Ruby-side dispatch `Proc` with the request bytes and return
 /// the encoded Response bytes. The Proc is contracted to fold every
-/// dispatch failure into a +Response.err+ envelope (see
+/// dispatch failure into a `Response.err` envelope (see
 /// `Kobako::Transport::Dispatcher.dispatch`), so reaching the error
 /// branch is itself a wire-layer fault rather than a normal control path.
 fn invoke_on_dispatch(

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

@@ -127,7 +127,7 @@ pub(super) fn guest_buffer_range(
 
 /// Unpack the `(ptr, len)` u64 returned by `__kobako_take_outcome`:
 /// high 32 bits = ptr, low 32 bits = len. Mirrors the guest-side
-/// `crate::abi::unpack_u64` in `wasm/kobako-wasm/src/abi.rs`.
+/// `unpack_u64` in `wasm/kobako-core/src/abi.rs`.
 pub(super) fn unpack_outcome_packed(packed: u64) -> (usize, usize) {
     let ptr = (packed >> 32) as u32 as usize;
     let len = packed as u32 as usize;

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

@@ -82,7 +82,7 @@ impl Invocation {
         self.stderr_pipe = Some(stderr);
     }
 
-    /// Register the Ruby-side dispatch +Proc+. From this point on, every
+    /// Register the Ruby-side dispatch `Proc`. From this point on, every
     /// `__kobako_dispatch` host import invocation calls the Proc with the
     /// request bytes and expects encoded Response bytes back.
     pub(super) fn bind_on_dispatch(&mut self, proc_value: Opaque<Value>) {
@@ -325,9 +325,9 @@ pub(crate) struct MemoryLimitTrap {
 }
 
 impl MemoryLimitTrap {
-    /// Construct a trap with the given +desired+ / +limit+ pair. Used
+    /// Construct a trap with the given `desired` / `limit` pair. Used
     /// internally by `MemoryLimiter::memory_growing` in production and
-    /// by the sibling-module +classify_trap+ unit tests to materialise
+    /// by the sibling-module `classify_trap` unit tests to materialise
     /// a representative error for downcast routing.
     #[cfg(test)]
     pub(super) fn new(desired: usize, limit: usize) -> Self {

data/ext/kobako/src/runtime.rs

@@ -71,9 +71,9 @@ use self::invocation::{Invocation, StoreCell};
 /// the guest-side mirror is `kobako_core::abi::ABI_VERSION`.
 const ABI_VERSION: u32 = 1;
 
-/// Copy the bytes of +s+ into a fresh `Vec<u8>`. Single safe entry to
-/// what would otherwise be an inline +unsafe { rstring.as_slice() }
-/// .to_vec()+ duplicated at every host-↔-guest boundary. The borrow
+/// Copy the bytes of `s` into a fresh `Vec<u8>`. Single safe entry to
+/// what would otherwise be an inline `unsafe { rstring.as_slice() }
+/// .to_vec()` duplicated at every host-↔-guest boundary. The borrow
 /// does not outlive this call, so no Ruby allocation can move the
 /// underlying RString between the borrow and the copy — the safety
 /// invariant the inline form relied on is established once here.
@@ -92,12 +92,12 @@ pub(crate) fn rstring_to_vec(s: RString) -> Vec<u8> {
 // verb prefix and lets the subclass identity flow through unchanged.
 // ---------------------------------------------------------------------------
 
-/// Resolve `Kobako::<name>` as an +ExceptionClass+ — the shared body of
+/// Resolve `Kobako::<name>` as an `ExceptionClass` — the shared body of
 /// every error-class `Lazy` below, which differ only in the constant
 /// name. The constants are guaranteed present by the time any of these
 /// lazies first resolve (`lib/kobako/errors.rb` loads the hierarchy before
 /// the ext raises into it), so a missing constant is a build / wiring bug
-/// and the +unwrap+ is the correct fail-fast.
+/// and the `unwrap` is the correct fail-fast.
 fn kobako_error_class(ruby: &Ruby, name: &str) -> ExceptionClass {
     let kobako: RModule = ruby.class_object().const_get("Kobako").unwrap();
     kobako.const_get(name).unwrap()
@@ -121,8 +121,8 @@ pub(crate) static MEMORY_LIMIT_ERROR: Lazy<ExceptionClass> =
 pub(crate) static SANDBOX_ERROR: Lazy<ExceptionClass> =
     Lazy::new(|ruby| kobako_error_class(ruby, "SandboxError"));
 
-/// Build a +MagnusError+ in +class+ carrying +msg+ — the shared body of
-/// the named +*_err+ constructors below, which differ only in which
+/// Build a `MagnusError` in `class` carrying `msg` — the shared body of
+/// the named `*_err` constructors below, which differ only in which
 /// error-class `Lazy` they target.
 fn error_in(ruby: &Ruby, class: &Lazy<ExceptionClass>, msg: impl Into<String>) -> MagnusError {
     MagnusError::new(ruby.get_inner(class), msg.into())
@@ -414,9 +414,9 @@ impl Runtime {
         Ok(())
     }
 
-    /// Register the Ruby-side dispatch +Proc+ on the active Invocation.
-    /// Bound to Ruby as +Kobako::Runtime#on_dispatch=+. From this point on,
-    /// every +__kobako_dispatch+ host import invocation calls the Proc
+    /// Register the Ruby-side dispatch `Proc` on the active Invocation.
+    /// Bound to Ruby as `Kobako::Runtime#on_dispatch=`. From this point on,
+    /// every `__kobako_dispatch` host import invocation calls the Proc
     /// with the request bytes and writes the returned Response bytes back
     /// into guest memory (docs/behavior.md B-12).
     pub(crate) fn set_on_dispatch(&self, proc_value: Value) -> Result<(), MagnusError> {
@@ -440,14 +440,14 @@ impl Runtime {
     /// export with `args_bytes` as the yield-arguments payload, and
     /// return the YieldResponse bytes the guest produced (B-24).
     ///
-    /// Bound to Ruby as +Kobako::Runtime#yield_to_active_invocation+.
+    /// Bound to Ruby as `Kobako::Runtime#yield_to_active_invocation`.
     /// Recovers the dispatcher's `&mut Caller` from the per-thread
     /// Invocation slot (SPEC.md Single-Invocation Slot) — the host is
     /// already inside a `__kobako_dispatch` callback, so the Caller
     /// parked on the Rust stack is the same one the Sandbox-level
     /// `#eval` / `#run` is driving. Invoked from the host-side yield
     /// proxy that the dispatcher hands to Service methods (B-23 / B-24);
-    /// raises +Kobako::TrapError+ when called outside an active dispatch
+    /// raises `Kobako::TrapError` when called outside an active dispatch
     /// frame, or when any of the underlying allocation / write / call /
     /// read steps fails.
     pub(crate) fn yield_to_active_invocation(
@@ -482,8 +482,8 @@ impl Runtime {
     /// and return a `Snapshot` bundling every per-invocation observable.
     ///
     /// Rebuilds the WASI context with fresh stdin / stdout / stderr pipes
-    /// (the three-frame stdin protocol carries +preamble+, +source+, then
-    /// +snippets+ — docs/wire-codec.md § Invocation channels), then
+    /// (the three-frame stdin protocol carries `preamble`, `source`, then
+    /// `snippets` — docs/wire-codec.md § Invocation channels), then
     /// invokes `__kobako_eval`. Per-invocation caps (docs/behavior.md
     /// B-01) are primed here: the wall-clock deadline is stamped into
     /// `Invocation` and the epoch deadline is set to fire at the next
@@ -517,10 +517,10 @@ impl Runtime {
     ///
     /// Rebuilds the WASI context with the two-frame stdin protocol
     /// (preamble + snippets; no user source frame — docs/wire-codec.md
-    /// § Invocation channels), copies +envelope+ bytes into guest linear
+    /// § Invocation channels), copies `envelope` bytes into guest linear
     /// memory via `__kobako_alloc`, and calls `__kobako_run(env_ptr,
     /// env_len)`. Per-invocation cap semantics match `Runtime::eval`.
-    /// Raises +Kobako::TrapError+ ("alloc returned 0") when guest
+    /// Raises `Kobako::TrapError` ("alloc returned 0") when guest
     /// allocation fails (docs/behavior.md E-31).
     pub(crate) fn run(
         &self,
@@ -646,7 +646,7 @@ impl Runtime {
     /// The mruby image's declared initial allocation and the high-water
     /// mark left by prior invocations on the same Sandbox are folded
     /// into the baseline rather than the budget — only `memory.grow`
-    /// past +baseline+ counts against `memory_limit`.
+    /// past `baseline` counts against `memory_limit`.
     ///
     /// Also stamps the wall-clock entry instant for the
     /// docs/behavior.md B-35 `wall_time` measurement. The bracket
@@ -686,11 +686,11 @@ impl Runtime {
         store_ref.data_mut().disarm_memory_cap();
     }
 
-    /// Allocate a +len+-byte buffer in guest linear memory via
-    /// `__kobako_alloc`, copy +envelope+ into it, and return +(ptr, len)+
-    /// as +i32+ values matching the `__kobako_run(env_ptr, env_len)` ABI.
-    /// Raises +Kobako::TrapError+ when the allocation hook is missing or
-    /// itself traps, and +Kobako::SandboxError+ when the hook runs but
+    /// Allocate a `len`-byte buffer in guest linear memory via
+    /// `__kobako_alloc`, copy `envelope` into it, and return `(ptr, len)`
+    /// as `i32` values matching the `__kobako_run(env_ptr, env_len)` ABI.
+    /// Raises `Kobako::TrapError` when the allocation hook is missing or
+    /// itself traps, and `Kobako::SandboxError` when the hook runs but
     /// cannot reserve the buffer (`__kobako_alloc` returns 0,
     /// docs/behavior.md E-31) — an intact runtime, not an engine fault.
     fn write_envelope(&self, ruby: &Ruby, envelope: RString) -> Result<(i32, i32), MagnusError> {
@@ -726,10 +726,10 @@ impl Runtime {
     }
 
     /// Rebuild the WASI context with fresh stdin (carrying every frame in
-    /// +frames+, each prefixed by its 4-byte big-endian u32 length —
+    /// `frames`, each prefixed by its 4-byte big-endian u32 length —
     /// docs/wire-codec.md § Invocation channels) plus fresh stdout / stderr
-    /// pipes. Called at the top of every guest invocation: +#eval+ passes
-    /// three frames (preamble, source, snippets), +#run+ passes two
+    /// pipes. Called at the top of every guest invocation: `#eval` passes
+    /// three frames (preamble, source, snippets), `#run` passes two
     /// (preamble, snippets — the invocation envelope arrives via linear
     /// memory instead). Each output pipe is sized at `cap + 1` so
     /// `capture::clip_capture` can distinguish "wrote exactly cap
@@ -762,10 +762,10 @@ impl Runtime {
             .install_wasi(wasi, stdout_pipe, stderr_pipe);
     }
 
-    /// Invoke `__kobako_take_outcome`, decode the packed +(ptr<<32)|len+
+    /// Invoke `__kobako_take_outcome`, decode the packed `(ptr<<32)|len`
     /// u64, and copy the OUTCOME_BUFFER slice out of guest memory. Raises
-    /// `Kobako::TrapError` when the export is missing, +len+ exceeds the
-    /// 16 MiB single-dispatch cap, the +ptr+/+len+ arithmetic overflows,
+    /// `Kobako::TrapError` when the export is missing, `len` exceeds the
+    /// 16 MiB single-dispatch cap, the `ptr`/`len` arithmetic overflows,
     /// the slice falls outside live memory, or the `memory` export itself
     /// is absent.
     fn fetch_outcome_bytes(&self, ruby: &Ruby) -> Result<Vec<u8>, MagnusError> {
@@ -812,10 +812,10 @@ const SANDBOX_RUNTIME_MISSING_HOOKS: &str = "Sandbox runtime is missing required
 const SANDBOX_RUNTIME_NOT_KOBAKO: &str =
     "the loaded Wasm module is not a Kobako-compatible runtime";
 
-/// Return the cached +TypedFunc+ for an ABI export, or raise
-/// +Kobako::TrapError+ when the option is +None+. Both run-path
-/// methods (+#eval+, +#run+) plus the +build_snapshot+ readout that
-/// drains +OUTCOME_BUFFER+ share the same "missing export → Ruby
+/// Return the cached `TypedFunc` for an ABI export, or raise
+/// `Kobako::TrapError` when the option is `None`. Both run-path
+/// methods (`#eval`, `#run`) plus the `build_snapshot` readout that
+/// drains `OUTCOME_BUFFER` share the same "missing export → Ruby
 /// error" boilerplate; this helper collapses those sites onto one
 /// safe entry. The user-facing message is intentionally export-
 /// agnostic (see `SANDBOX_RUNTIME_MISSING_HOOKS`) — the ABI symbol

data/lib/kobako/catalog/namespaces.rb

@@ -28,7 +28,7 @@ module Kobako
     # installs ({docs/behavior.md B-12}[link:../../../docs/behavior.md]).
     # The registry holds an injected +Catalog::Handles+ reference so
     # dispatch target resolution and host→guest auto-wrap share the same
-    # Sandbox-owned allocator (docs/behavior.md B-19).
+    # Sandbox-owned allocator ({docs/behavior.md B-19}[link:../../../docs/behavior.md]).
     class Namespaces
       # Build a fresh registry. +handler+ is an internal seam that injects
       # a pre-configured +Catalog::Handles+; tests pass one whose +next_id+
@@ -40,7 +40,8 @@ module Kobako
         @sealed = false
       end
 
-      # Declare or retrieve the Namespace named +name+ (idempotent — docs/behavior.md B-10).
+      # Declare or retrieve the Namespace named +name+ (idempotent —
+      # {docs/behavior.md B-10}[link:../../../docs/behavior.md]).
       # +name+ is a constant-form name as a +Symbol+ or +String+ (must satisfy
       # +Namespace::NAME_PATTERN+). Returns the +Kobako::Namespace+ for that
       # name, creating it if it does not exist. Raises +ArgumentError+ when

data/lib/kobako/codec/factory.rb

@@ -77,9 +77,7 @@ module Kobako
         )
       end
 
-      # Symbol-to-name packer — extracted to a real method so Steep can
-      # resolve the proc shape without tripping on +lambda(&:name)+'s
-      # +Symbol#to_proc+ inference path.
+      # Symbol-to-name packer for the ext-0x00 registration.
       def pack_symbol(symbol)
         symbol.name
       end
@@ -148,8 +146,7 @@ module Kobako
       # method when a nested ext 0x02 appears inside +details+. The recursion
       # is bounded by msgpack nesting depth — identical to nested Array /
       # Hash payloads — so no extra guard is needed. Do not switch back to
-      # +factory.load+ to "simplify": that path bypasses UTF-8 validation
-      # and re-opens the Decoder's special case for Fault (removed in M5).
+      # +factory.load+ to "simplify": that path bypasses UTF-8 validation.
       def unpack_fault(payload)
         Decoder.decode(payload) do |map|
           raise InvalidType, "Fault payload must be a map" unless map.is_a?(Hash)

data/lib/kobako/codec/utils.rb

@@ -43,14 +43,12 @@ module Kobako
       # stays {Kobako::Codec::Error} and never leaks +ArgumentError+ from
       # the Ruby standard library.
       #
-      # Most construction sites no longer reach for this directly: a value
-      # object built inside a {Decoder.decode} block has its
-      # +ArgumentError+ mapped to {InvalidType} by the decoder's own
-      # rescue. The lone remaining caller is {Factory#unpack_handle}, which
-      # builds +Handle.restore+ from a raw 4-byte fixext payload without a
-      # {Decoder.decode} call. Do not use it for general-purpose validation
-      # outside the codec boundary — host-layer +ArgumentError+ values
-      # should propagate unchanged.
+      # Reach for this only where a value object is constructed outside a
+      # {Decoder.decode} block, whose rescue already performs the same
+      # mapping (worked example: {Factory#unpack_handle} building
+      # +Handle.restore+ from a raw fixext payload). Do not use it for
+      # general-purpose validation outside the codec boundary —
+      # host-layer +ArgumentError+ values should propagate unchanged.
       def with_boundary
         yield
       rescue ::ArgumentError => e
@@ -143,8 +141,7 @@ module Kobako
         end
       end
 
-      # Predicate split out of {representable?} for cyclomatic
-      # budget — the closed-set non-container branch. Returns +true+ for
+      # The non-container branch of {representable?}: returns +true+ for
       # the scalar leaves and an existing Handle. Not part of the
       # public surface; reach for {representable?} instead.
       def primitive_type?(value)
@@ -155,11 +152,10 @@ module Kobako
         end
       end
 
-      # Predicate split out of {representable?} for cyclomatic
-      # budget — the container branch. Recurses into Array elements and
-      # Hash key+value pairs through the public {representable?}.
-      # Not part of the public surface; reach for {representable?}
-      # instead.
+      # The container branch of {representable?}: recurses into Array
+      # elements and Hash key+value pairs through the public
+      # {representable?}. Not part of the public surface; reach for
+      # {representable?} instead.
       def container_representable?(value)
         case value
         when ::Array then value.all? { |element| Utils.representable?(element) }

data/lib/kobako/errors.rb

@@ -26,9 +26,9 @@ module Kobako
   #   * {SetupError}    — construction layer. Raised by `Kobako::Sandbox.new`
   #                       when the wasm runtime cannot be built from the
   #                       configured +wasm_path+ before any invocation runs
-  #                       (docs/behavior.md E-40 / E-41). Not an invocation
-  #                       outcome, so it never passes through the two-step
-  #                       attribution decision.
+  #                       ({docs/behavior.md E-40 / E-41}[link:../../docs/behavior.md]).
+  #                       Not an invocation outcome, so it never passes
+  #                       through the two-step attribution decision.
   #
   # Subclasses pinned by docs/behavior.md Error Classes:
   #

data/lib/kobako/fault.rb

@@ -22,10 +22,8 @@ module Kobako
   # exception class (RuntimeError, ArgumentError, Kobako::ServiceError, ...)
   # is the responsibility of the dispatch layer, not the codec.
   #
-  # Built on the +class X < Data.define(...)+ subclass form so the
-  # class body is fully Steep-visible; ruby/rbs upstream documents
-  # this as the Steep-friendly shape and the +Style/DataInheritance+
-  # cop is disabled on that basis (see +.rubocop.yml+).
+  # Built on the +class X < Data.define(...)+ subclass form (the
+  # Steep-friendly shape — see +lib/kobako/outcome/panic.rb+).
   class Fault < Data.define(:type, :message, :details)
     VALID_TYPES = %w[runtime argument undefined].freeze
 

data/lib/kobako/sandbox.rb

@@ -292,9 +292,9 @@ module Kobako
     #
     # The yielded block must return a +Kobako::Snapshot+ — i.e. the
     # value of +Runtime#eval+ / +#run+ (SPEC.md Internal Concepts →
-    # Snapshot). The success path unpacks every observable from the
-    # Snapshot in one go: +#stdout+ / +#stderr+ pack into +Capture+,
-    # +#usage+ packs into +Usage+, +#return_bytes+ feeds +Outcome.decode+.
+    # Snapshot). The success path unpacks +#stdout+ / +#stderr+ into
+    # +Capture+ and feeds +#return_bytes+ to +Outcome.decode+; usage is
+    # populated by the +ensure+ readout ({#read_usage!}) on every outcome.
     # The rescue chain is the single trap-translation boundary —
     # configured-cap paths
     # ({docs/behavior.md E-19 / E-20}[link:../../docs/behavior.md])

data/lib/kobako/transport/dispatcher.rb

@@ -117,7 +117,7 @@ module Kobako
         end
       end
 
-      # {docs/behavior.md B-16}[link:../../../docs/behavior.md] — An Kobako::Handle arriving as a positional or keyword
+      # {docs/behavior.md B-16}[link:../../../docs/behavior.md] — A Kobako::Handle arriving as a positional or keyword
       # argument identifies a host-side object previously allocated by a prior
       # transport call's Handle wrap (B-14). Resolve it back to the Ruby object before
       # the dispatch reaches +public_send+.

data/lib/kobako/usage.rb

@@ -28,10 +28,8 @@ module Kobako
   # consumed. Before the first invocation +Sandbox#usage+ returns the
   # pre-invocation sentinel +Kobako::Usage::EMPTY+.
   #
-  # Built on the +class X < Data.define(...)+ subclass form so the
-  # class body is fully Steep-visible; ruby/rbs upstream documents this
-  # as the Steep-friendly shape and the +Style/DataInheritance+ cop is
-  # disabled on that basis (see +.rubocop.yml+).
+  # Built on the +class X < Data.define(...)+ subclass form (the
+  # Steep-friendly shape — see +lib/kobako/outcome/panic.rb+).
   class Usage < Data.define(:wall_time, :memory_peak)
     # Pre-invocation sentinel ({docs/behavior.md B-35}[link:../../docs/behavior.md]).
     # Reused by +Sandbox+ before any invocation has run so callers do not

data/lib/kobako/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kobako
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/release-please-config.json

@@ -6,7 +6,8 @@
     ".": {
       "component": "kobako",
       "include-component-in-tag": false,
-      "release-type": "ruby"
+      "release-type": "ruby",
+      "exclude-paths": ["wasm"]
     },
     "wasm/kobako-core": {
       "component": "kobako-core",
@@ -16,10 +17,71 @@
           "type": "toml",
           "path": "/wasm/Cargo.lock",
           "jsonpath": "$.package[?(@.name=='kobako-core')].version"
+        },
+        {
+          "type": "generic",
+          "path": "/wasm/kobako-core/README.md"
+        }
+      ]
+    },
+    "wasm/kobako": {
+      "component": "kobako-rs",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/wasm/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako')].version"
+        },
+        {
+          "type": "toml",
+          "path": "/wasm/kobako/Cargo.toml",
+          "jsonpath": "$.dependencies['kobako-core'].version"
+        },
+        {
+          "type": "generic",
+          "path": "/wasm/kobako/README.md"
+        }
+      ]
+    },
+    "wasm/kobako-io": {
+      "component": "kobako-io",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/wasm/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-io')].version"
+        },
+        {
+          "type": "generic",
+          "path": "/wasm/kobako-io/README.md"
+        }
+      ]
+    },
+    "wasm/kobako-regexp": {
+      "component": "kobako-regexp",
+      "release-type": "rust",
+      "extra-files": [
+        {
+          "type": "toml",
+          "path": "/wasm/Cargo.lock",
+          "jsonpath": "$.package[?(@.name=='kobako-regexp')].version"
+        },
+        {
+          "type": "generic",
+          "path": "/wasm/kobako-regexp/README.md"
         }
       ]
     }
   },
+  "plugins": [
+    {
+      "type": "linked-versions",
+      "groupName": "kobako guest crates",
+      "components": ["kobako-core", "kobako-rs", "kobako-io", "kobako-regexp"]
+    }
+  ],
   "extra-files": [
     {
       "type": "toml",

data/rust-toolchain.toml

@@ -1,7 +1,8 @@
 # Pin the Rust toolchain so local builds and CI stay byte-identical.
 # The wasm32-wasip1 crt1-command.o references __wasi_init_tp from 1.96 onward;
 # vendored wasi-sdk 33's libc.a supplies that symbol, so the two move together.
-# Bump this in lockstep with WASI_SDK_VERSION in tasks/support/kobako_vendor.rb.
+# Bump this in lockstep with the wasi-sdk toolchain beni vendors
+# (`rake beni:build`, wired in the Rakefile's Beni::Tasks block).
 # This file is the single source of the channel; the CI workflows read it.
 [toolchain]
 channel = "1.96.0"

data/sig/kobako/codec.rbs

@@ -0,0 +1,4 @@
+module Kobako
+  module Codec
+  end
+end

data/sig/kobako/version.rbs

@@ -0,0 +1,3 @@
+module Kobako
+  VERSION: String
+end

data/sig/kobako.rbs

@@ -1,3 +1,2 @@
 module Kobako
-  VERSION: String
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kobako
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Aotokitsuruya
@@ -110,6 +110,7 @@ files:
 - sig/kobako/catalog/handles.rbs
 - sig/kobako/catalog/namespaces.rbs
 - sig/kobako/catalog/snippets.rbs
+- sig/kobako/codec.rbs
 - sig/kobako/codec/decoder.rbs
 - sig/kobako/codec/encoder.rbs
 - sig/kobako/codec/error.rbs
@@ -137,6 +138,7 @@ files:
 - sig/kobako/transport/yield.rbs
 - sig/kobako/transport/yielder.rbs
 - sig/kobako/usage.rbs
+- sig/kobako/version.rbs
 homepage: https://github.com/elct9620/kobako
 licenses:
 - Apache-2.0