kobako 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f89723d7b8cc8160176c299eaf28548ff9c7efda380ce545a7676d5d7f7cfdb6
-  data.tar.gz: 3494ee4ff50aef160504b53eb75b0192e9e9c7108d165db39b3903fb4e7343df
+  metadata.gz: 8298cb68a22a8100ea0ab330902a1d772049e990a35aa154b9233429f5c43b22
+  data.tar.gz: 9a1ae245d152dab877fc3104c157eab78a38fc15cbff3e94baf187eb955d4e35
 SHA512:
-  metadata.gz: 26c982a047b82e32dcd4017ce603d6c4094bb6d4cd34f38e1df6eacba253cdb9589a8092fe0558e0ddcb64f9acacb4ef191f51916c37dffebf4f1ee0bc52a4fb
-  data.tar.gz: b593374ee6c18e132535813aa046a7059aca5a9f0d16c6b32519f8154a6d76b2fc5e7b2b4791e5213e26b7828748f64f3ec61b00029a9bb6cf0cc6336a48fdf0
+  metadata.gz: 1aabea83fa046f0e5f9cc6ae3600e0f69cd045d38d3ecdcd91c6e71cbc19d29946ecd200ca44cc7941af329300d0f20a5733585a341e810ef19522fb083b4513
+  data.tar.gz: 23e5eccfa72eca1b6c39144c7d552a0eaf1a8467342fae504799744e8b4fee4036ad1d27a3e2311f0929cb300b74e04183ec9c8e3499043257860e9779c181ce

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.14.0","wasm/kobako-core":"0.8.0","wasm/kobako-mruby":"0.8.0","wasm/kobako-io":"0.8.0","wasm/kobako-json":"0.8.0","wasm/kobako-regexp":"0.8.0","wasm/kobako-baker":"0.8.0","crates/kobako-codec":"0.8.0","crates/kobako-runtime":"0.8.0","crates/kobako-wasmtime":"0.8.0","crates/kobako":"0.8.0"}
+{".":"0.16.0","wasm/kobako-core":"0.10.0","wasm/kobako-mruby":"0.10.0","wasm/kobako-io":"0.10.0","wasm/kobako-json":"0.10.0","wasm/kobako-regexp":"0.10.0","wasm/kobako-baker":"0.10.0","crates/kobako-codec":"0.10.0","crates/kobako-runtime":"0.10.0","crates/kobako-wasmtime":"0.10.0","crates/kobako":"0.10.0"}

data/CHANGELOG.md

@@ -1,5 +1,72 @@
 # Changelog
 
+## [0.16.0](https://github.com/elct9620/kobako/compare/v0.15.0...v0.16.0) (2026-07-12)
+
+
+### Features
+
+* **sandbox:** add the Extension install mechanism ([ad8e4da](https://github.com/elct9620/kobako/commit/ad8e4da703e4ceee85959663d77bb1e26c26791a))
+* **sdk:** add the Extension install mechanism to the Rust host SDK ([4043f76](https://github.com/elct9620/kobako/commit/4043f764b7038619a30c16542ed38d566e4a72a9))
+* **tasks:** break each module down by language in stats:<slug> ([b496e3c](https://github.com/elct9620/kobako/commit/b496e3cb23150f8f073cc1b972978cfbebfbb1e6))
+* **tasks:** report code sizes per publishable module in stats:all ([f554930](https://github.com/elct9620/kobako/commit/f554930e669a82bed0c7305c5cbbab96c3ae79da))
+* **tasks:** split impl vs inline test per module in stats:all ([cefa38d](https://github.com/elct9620/kobako/commit/cefa38d96ff79509b947269ea5c361ead0610bfa))
+
+
+### Bug Fixes
+
+* **tasks:** count Rust inline tests in the stats code-to-test ratio ([134c970](https://github.com/elct9620/kobako/commit/134c9704a5a9bb6fb01c1aa7968f907d1436e5f2))
+
+## [0.15.0](https://github.com/elct9620/kobako/compare/v0.14.0...v0.15.0) (2026-07-11)
+
+
+### Features
+
+* **claude:** cover rake files in the post-edit rubocop hook ([416cd42](https://github.com/elct9620/kobako/commit/416cd42009e7888fb0662e91719f4d7d61713cf8))
+* **examples:** add plugin-rs, a Rust SDK narrative example ([8263096](https://github.com/elct9620/kobako/commit/8263096876900aa2c3ffeebbd24f7cca3571b893))
+* **examples:** add wire-rs, a low-level host without the SDK ([d9edea8](https://github.com/elct9620/kobako/commit/d9edea8ed025e4b7ffe58be8c376c7fb0a65ac04))
+* **sandbox:** flatten Service registration to path-valued bind ([0876006](https://github.com/elct9620/kobako/commit/0876006455544fd82eb7555ee80c149d98843719))
+* **tasks:** add grouped test:tasks / test:bench runs ([1153c43](https://github.com/elct9620/kobako/commit/1153c43416363d7cc03b696eb2762b7281a68e93))
+* **tasks:** compare the wire-symmetric peer inventories mechanically ([50d4fe5](https://github.com/elct9620/kobako/commit/50d4fe523bf85406931fa9611b6528c3de1a3f50))
+* **tasks:** flag stale ledger entries in the surface and symmetry instruments ([d18054f](https://github.com/elct9620/kobako/commit/d18054f5daa6ce277154c288d5c3085133f441b4))
+* **tasks:** hold the pub-surface crate map to the repo's crate roster ([4f65e79](https://github.com/elct9620/kobako/commit/4f65e79c3aa37ed1fc47a5002c8a567c3df8cc84))
+* **tasks:** hold the tier roster to the repo and share it across instruments ([9a75586](https://github.com/elct9620/kobako/commit/9a755866236c134ea7601006211338eefae0a348))
+* **tasks:** inventory exported macros in the pub-surface scan ([e4457ea](https://github.com/elct9620/kobako/commit/e4457eafecfa24eb5fc9aade086f2be9b0862818))
+* **tasks:** measure the tooling tiers in stats and hotspots ([8def9ff](https://github.com/elct9620/kobako/commit/8def9ff96d36c2020e04d7e9bb0d9cd3fdad3e43))
+* **tasks:** pin the tier roster to the repo from both sides ([3b7a154](https://github.com/elct9620/kobako/commit/3b7a154ebbfe8629392a81599df37d136a0eec99))
+* **tasks:** rank churn x size x fan-in hotspots since the last release ([73b3bc8](https://github.com/elct9620/kobako/commit/73b3bc8fdee19f8c09a91ccf96348688ea3ccd1c))
+* **tasks:** read the anchor citation profile back as an instrument ([47961cb](https://github.com/elct9620/kobako/commit/47961cb689d9c681f5c697af7e6bca52a4c7817f))
+* **tasks:** report pub items no in-repo downstream consumes ([3eb0481](https://github.com/elct9620/kobako/commit/3eb048199a0e2e41509513750bec4fcbc6b7cc69))
+* **tasks:** resolve the SPEC-local F/J/N families in the anchors gate ([33d3118](https://github.com/elct9620/kobako/commit/33d31181be3a800a4cc3d4eb32324d840473401f))
+* **tasks:** scan pub statics in the pub-surface instrument ([72cff5e](https://github.com/elct9620/kobako/commit/72cff5ef369a73c353ecdd25c1d4688ec8dd2f82))
+* **tasks:** score hotspots on impl-only lines for Rust files ([704b419](https://github.com/elct9620/kobako/commit/704b41971eac9e284b570bd0ac2fdd9af656bbca))
+* **tasks:** seat anchors:coverage and wire:symmetry in the release gate ([ab035bb](https://github.com/elct9620/kobako/commit/ab035bb3c4e049e6319d33cdaf1d715d4e83eedb))
+* **tasks:** widen the fan-in and ext-code scans to their whole tiers ([43d2bad](https://github.com/elct9620/kobako/commit/43d2badfea3c13cb062e67d5ded8410a339862d3))
+
+
+### Bug Fixes
+
+* **codec:** reject ext 0x02 anywhere in the Panic frame, not only details ([062e29d](https://github.com/elct9620/kobako/commit/062e29d6ee15264e1bd942502b751cfe7610acad))
+* **codec:** reject the Fault envelope in Rust host payload positions ([bdf2ed7](https://github.com/elct9620/kobako/commit/bdf2ed78fde2798bdc15f4e969bda228cf482f4b))
+* **codec:** reject the reserved Handle id 0 on the Rust wire tier ([5f7e482](https://github.com/elct9620/kobako/commit/5f7e4821680e553da355d5257b0619e4a1cdce72))
+* **tasks:** fail the anchors gate when no SPEC ceiling parses ([8d185f5](https://github.com/elct9620/kobako/commit/8d185f59afc28b5334d934f6916fd64e458e9359))
+* **tasks:** inventory every codec-bearing class per transport file ([e553ae1](https://github.com/elct9620/kobako/commit/e553ae1578245d9bfca63cf4e8429666857dbb92))
+* **tasks:** keep tooling-suite fixture tokens out of the anchor scans ([58a78b9](https://github.com/elct9620/kobako/commit/58a78b990684d4ad87d4db18b21eb8bd1c98713a))
+* **tasks:** mark unmeasured fan-in as '-' in the hotspot report ([a4959fe](https://github.com/elct9620/kobako/commit/a4959fe0c93546711dd16002e38d993e350bcb8f))
+* **tasks:** read pub fn qualifiers in the pub-surface scan ([ac0e7d3](https://github.com/elct9620/kobako/commit/ac0e7d3030729ad981b6a8de504c5837daf2038d))
+* **tasks:** read the codec-bearing class in the wire-symmetry inventory ([85ce937](https://github.com/elct9620/kobako/commit/85ce937fdb35953b26fee5fa4ee55f53988147ea))
+* **tasks:** scan the whole tier in every wire-symmetry inventory ([c2bba5c](https://github.com/elct9620/kobako/commit/c2bba5c02ca20dca14d061a03f8f4581d0995a66))
+* **tasks:** truncate the pub-surface scan only at the test module ([9c6dc05](https://github.com/elct9620/kobako/commit/9c6dc054bfa1fe79c3410fa794290a1ce5b85f4d))
+* **test:** flunk instead of skip when CI lacks a built guest prerequisite ([f7818f6](https://github.com/elct9620/kobako/commit/f7818f68c8114e5f9b0012a4dd4b069695bc3e32))
+* **transport:** refuse the Fault envelope outside its legal position (E-50) ([58c5069](https://github.com/elct9620/kobako/commit/58c50691d32e245f41c2f8041dfb7e92b05b80e9))
+
+
+### Performance Improvements
+
+* **bench:** re-bless the anchor onto the wasmtime 46 round ([9225702](https://github.com/elct9620/kobako/commit/9225702106c0c4caf90425ac08c11452b6388b55))
+* **dispatch:** skip the Handle walk when the request carried none ([cd63514](https://github.com/elct9620/kobako/commit/cd6351459c492084a401fd1b6a8e4293761de93f))
+* **sandbox:** skip the Handle walk when the invocation result carried none ([d2c4947](https://github.com/elct9620/kobako/commit/d2c494782d316df3bbf5fc223a8beaa1f04f5718))
+* **transport:** skip the Handle walk when the yield result carried none ([bca463b](https://github.com/elct9620/kobako/commit/bca463bce0b8913941b3e3ba11c31cb41b843545))
+
 ## [0.14.0](https://github.com/elct9620/kobako/compare/v0.13.0...v0.14.0) (2026-07-08)
 
 

data/Cargo.lock

@@ -929,7 +929,7 @@ dependencies = [
 
 [[package]]
 name = "kobako"
-version = "0.14.0"
+version = "0.16.0"
 dependencies = [
  "kobako-runtime",
  "kobako-wasmtime",
@@ -938,11 +938,11 @@ dependencies = [
 
 [[package]]
 name = "kobako-runtime"
-version = "0.8.0"
+version = "0.10.0"
 
 [[package]]
 name = "kobako-wasmtime"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "kobako-runtime",
  "libc",

data/README.md

@@ -2,9 +2,9 @@
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/elct9620/kobako)
 
-Kobako is a Ruby gem that embeds a Wasm-isolated mruby interpreter inside your application, so you can execute untrusted Ruby scripts (LLM-generated code, user formulas, student submissions, third-party plugins) in-process without giving them access to host memory, files, network, or credentials.
+Kobako is a Ruby gem that embeds a Wasm-isolated mruby interpreter inside your application, so you can execute untrusted Ruby scripts (LLM-generated code, user formulas, student submissions, third-party plugins) in-process without giving them access to host memory, files, network, or credentials. Its home is the Ruby ecosystem; a Rust SDK offers the same sandbox to hosts written in other languages.
 
-The host (`wasmtime`) runs a precompiled `kobako.wasm` guest containing mruby and a Transport proxy. The only way a guest script can reach the outside world is through Host App-declared **Services** — named Ruby objects you explicitly inject into the sandbox; the guest sees each one as a proxy that forwards calls back to the host over the Transport wire.
+The host (`wasmtime`) runs a precompiled `kobako.wasm` guest containing mruby and a Transport proxy. The only way a guest script can reach the outside world is through Host App-declared **Services** — named host objects you explicitly inject into the sandbox; the guest sees each one as a proxy that forwards calls back to the host over the Transport wire.
 
 ```
         Host process                       Wasm guest
@@ -39,27 +39,102 @@ gem install kobako
 
 ## Quick Start
 
+The same untrusted script runs identically from either host frontend. It executes inside the Wasm guest and cannot read your filesystem, open sockets, or touch your environment.
+
 ```ruby
 require "kobako"
 
 sandbox = Kobako::Sandbox.new
+sandbox.eval("1 + 2")  # => 3
+```
 
-result = sandbox.eval(<<~RUBY)
-  1 + 2
-RUBY
+```rust
+use kobako::{Options, Sandbox};
+
+// Options::default() is secure by default: no caps, hermetic isolation.
+let mut sandbox = Sandbox::new("kobako.wasm", Options::default())?;
+sandbox.eval("1 + 2")?;  // => Value::Int(3)
+```
+
+The gem bundles its Guest Binary; a Rust host loads one explicitly — see [Frontends & Guest Binaries](#frontends--guest-binaries) for the packages and the Guest Binary variants.
+
+## Frontends & Guest Binaries
+
+Embedding kobako is two independent choices: the **host frontend** you build against, and the **Guest Binary** it runs. They compose freely — any frontend loads any Guest Binary, so a Ruby host can run a JSON-enabled guest and a Rust host can run the pure default.
+
+### Host frontends
+
+The host embeds the sandbox and owns the SPEC wire codec. Choose by your host language and how much of the contract you want pre-assembled.
+
+| Frontend | Package | Add it | Best for |
+|----------|---------|--------|----------|
+| Ruby gem | `kobako` (RubyGems) | `gem install kobako` | A Ruby host — Services, Handles, snippets, and pooling out of the box |
+| Rust SDK | `kobako` (crates.io) | `kobako = "0.9"` | A Rust host — the same behavior contract behind an idiomatic Rust API |
+| Low-level crates | `kobako-wasmtime` + `kobako-runtime` + `kobako-codec` | Cargo deps | A custom host, or driving the wire directly in another language |
+
+The Rust crates are documented on [crates.io](https://crates.io/crates/kobako); the Ruby gem is this README. Two runnable Rust hosts show the choice: [`plugin-rs`](examples/plugin-rs) builds on the SDK, and [`wire-rs`](examples/wire-rs) assembles a host by hand on the low-level crates.
+
+### Pre-built Guest Binaries
+
+The gem bundles the pure `kobako.wasm`. Regexp and JSON are opt-in capabilities compiled into separate variants, each attached to every [GitHub Release](https://github.com/elct9620/kobako/releases). Download a variant and point your host at it — `Sandbox.new(wasm_path:)` in Ruby, `Sandbox::new(path, ...)` in Rust.
+
+| Variant | File | Adds | Distribution |
+|---------|------|------|--------------|
+| Pure (default) | `kobako.wasm` | mruby + IO | Bundled in the gem, and a Release asset |
+| +regexp | `kobako+regexp.wasm` | Regexp / MatchData (ASCII) | Release asset |
+| +regexp-unicode | `kobako+regexp-unicode.wasm` | Regexp / MatchData (Unicode) | Release asset |
+| +json | `kobako+json.wasm` | JSON | Release asset |
+| +full | `kobako+full.wasm` | JSON + Regexp (ASCII) | Release asset |
+
+```ruby
+sandbox = Kobako::Sandbox.new(wasm_path: "kobako+full.wasm")
+sandbox.eval('JSON.generate({ n: "42".to_i })')  # => "{\"n\":42}"
+```
+
+### Custom Guest Binaries
+
+When no pre-built variant matches your capability set, assemble a guest in Rust. `kobako-mruby` is the harness; its `init_gems` hook is where you install exactly the capability gems you want — the shipped `kobako-io` / `kobako-regexp` / `kobako-json`, or your own `beni::Gem`. `kobako-core`'s `export_guest!` emits the wasm ABI. `wasm/kobako-wasm/src/guest.rs` is the worked example.
+
+| Guest crate | Role |
+|-------------|------|
+| `kobako-mruby` | mruby guest harness — the `MrbGuest` trait and provided flows |
+| `kobako-core` | Guest ABI contract — the `Guest` trait and the `export_guest!` macro |
+| `kobako-io` | IO / Kernel capability gem |
+| `kobako-regexp` | Regexp / MatchData capability gem |
+| `kobako-json` | JSON capability gem |
+
+```rust
+use beni::{Error, Mrb};
+
+struct MyGuest;
+
+// Pick the capability gems the guest exposes.
+impl kobako_mruby::MrbGuest for MyGuest {
+    fn init_gems(mrb: &Mrb) -> Result<(), Error> {
+        mrb.init_gem::<kobako_io::KobakoIo>()?;
+        mrb.init_gem::<kobako_json::KobakoJson>()?;
+        Ok(())
+    }
+}
+
+// Forward the ABI contract to the harness flows.
+impl kobako_core::Guest for MyGuest {
+    fn eval() { <MyGuest as kobako_mruby::MrbGuest>::eval() }
+    fn run(env: &[u8]) { <MyGuest as kobako_mruby::MrbGuest>::run(env) }
+    fn yield_to_block(req: &[u8]) -> u64 { <MyGuest as kobako_mruby::MrbGuest>::yield_to_block(req) }
+}
 
-result # => 3
+kobako_core::export_guest!(MyGuest);
 ```
 
-The script executes inside the Wasm guest. It cannot read your filesystem, open sockets, or touch your `ENV`.
+Build the crate as a `cdylib` for `wasm32-wasip1`, then bake the canonical boot state into the artifact (see [`CLAUDE.md`](CLAUDE.md) § Build Pipeline).
 
 ## Glossary
 
 | Term | Meaning |
 |------|---------|
 | Sandbox | The runtime unit (`Kobako::Sandbox`) that runs guest code and returns a result or raises a typed error. |
-| Service | A host Ruby object injected under `<Namespace>::<Member>` — the guest's only path to host resources. |
-| Namespace / Member | A guest-visible Ruby module, and a named binding (a module constant) within it. |
+| Service | A host object bound at a constant-path name (`MyService::KV`) — the guest's only path to host resources. |
 | Invocation | One `#eval` or `#run`; capability state resets between invocations. |
 | Snippet | Named mruby code (source or bytecode) replayed into a fresh state before every invocation. |
 | Handle | An opaque token the guest holds for a host object the wire cannot transmit directly. |
@@ -69,7 +144,7 @@ The script executes inside the Wasm guest. It cannot read your filesystem, open
 
 ### Services
 
-Declare a Namespace, then `bind` any Ruby object as a Member; the guest reaches it as a `<Namespace>::<Member>` proxy and invokes its public methods through the Transport wire. See [`docs/behavior/registration.md`](docs/behavior/registration.md) B-07..B-12.
+`bind` any Ruby object as a Service at a constant-path name; the guest reaches it as a `MyService::KV` (or top-level `File`) proxy and invokes its public methods through the Transport wire. See [`docs/behavior/registration.md`](docs/behavior/registration.md) B-08..B-12.
 
 ```ruby
 class User
@@ -80,8 +155,8 @@ class User
   end
 end
 
-sandbox.define(:Project).bind(:User,   User.new(name: "alice"))
-sandbox.define(:KV)     .bind(:Lookup, ->(key) { redis.get(key) })
+sandbox.bind("Project::User", User.new(name: "alice"))
+sandbox.bind("KV::Lookup",     ->(key) { redis.get(key) })
 
 sandbox.eval(<<~RUBY)
   Project::User.name         # => "alice"
@@ -89,7 +164,7 @@ sandbox.eval(<<~RUBY)
 RUBY
 ```
 
-Names must match `/\A[A-Z]\w*\z/`. Symbol kwargs travel transparently to the host method's keyword arguments. The registry seals at the first invocation (see [Invocation Lifecycle](#invocation-lifecycle)); later `#define` raises `ArgumentError`.
+Each `::`-separated path segment must match `/\A[A-Z]\w*\z/`. Symbol kwargs travel transparently to the host method's keyword arguments. The registry seals at the first invocation (see [Invocation Lifecycle](#invocation-lifecycle)); later `#bind` raises `ArgumentError`.
 
 ### Output Capture
 
@@ -164,7 +239,7 @@ One Sandbox serves many invocations. Service bindings and preloaded snippets per
    ───────────── setup phase (mutable) ─────────────
 
      sandbox = Kobako::Sandbox.new
-     sandbox.define(:KV).bind(:Lookup, ...)
+     sandbox.bind("KV::Lookup", ...)
      sandbox.preload(code: ..., name: :Adder)
      sandbox.preload(code: ..., name: :Greeter)
 
@@ -173,7 +248,7 @@ One Sandbox serves many invocations. Service bindings and preloaded snippets per
 
    ═════════════════ seal point ═════════════════
    First #eval or #run freezes the Service registry
-   and snippet table. Further define / preload now
+   and snippet table. Further bind / preload now
    raise ArgumentError.
 
                           │
@@ -188,7 +263,7 @@ One Sandbox serves many invocations. Service bindings and preloaded snippets per
           :Adder     → defines Adder
           :Greeter   → defines Greeter
 
-     3. dispatch:  eval(source)  or  run(:Target, *args)
+     3. dispatch:  eval(source)  or  run(:Target, *args, **kwargs)
 
      4. return value to host
 
@@ -206,11 +281,11 @@ For workloads that must be isolated from each other (one Sandbox per tenant, per
 
 For hosts that serve many short invocations, `Kobako::Pool` keeps a bounded set of warm, identically set-up Sandboxes and hands each one to a single exclusive holder at a time ([`docs/behavior/runtime.md`](docs/behavior/runtime.md) B-46..B-48). Construction forwards every `Sandbox.new` keyword verbatim; the optional block is the per-Sandbox setup window and runs exactly once per constructed Sandbox.
 
-`Kobako::Pool` is experimental today and is best treated as a convenience for warm, pre-configured reuse rather than a throughput optimisation. B-49 bakes the shared boot state into the artifact and every dynamic script still compiles and runs per invocation, so all a pool actually saves is the ~30 µs host-side `Sandbox.new`. For the workload kobako is built for — many small, short-lived Sandboxes running dynamic scripts — that is not a significant gain (~4-5% in the [serverless example](examples/serverless/README.md), and proportionally less once the script itself does real work).
+`Kobako::Pool` is experimental today and is best treated as a convenience for warm, pre-configured reuse rather than a throughput optimisation. B-49 bakes the shared boot state into the artifact and every dynamic script still compiles and runs per invocation, so all a pool actually saves is the ~28 µs host-side `Sandbox.new`. For the workload kobako is built for — many small, short-lived Sandboxes running dynamic scripts — that is not a significant gain (~4-5% in the [serverless example](examples/serverless/README.md), and proportionally less once the script itself does real work).
 
 ```ruby
 pool = Kobako::Pool.new(slots: 4) do |sandbox|
-  sandbox.define(:KV).bind(:Lookup, ->(key) { redis.get(key) })
+  sandbox.bind("KV::Lookup", ->(key) { redis.get(key) })
 end
 
 pool.with { |sandbox| sandbox.eval(%(KV::Lookup.call("user_42"))) }
@@ -228,7 +303,7 @@ Sandboxes construct lazily on first demand. `#with` yields a Sandbox with empty
 A Service method can accept a guest-supplied block via `&blk` and `yield` into it. The block body runs inside the Wasm guest; `break` / `next` / exceptions follow normal Ruby semantics, scoped to the single dispatch. See [`docs/behavior/yield.md`](docs/behavior/yield.md) B-23..B-30.
 
 ```ruby
-sandbox.define(:Seq).bind(:Map, ->(items, &blk) { items.map(&blk) })
+sandbox.bind("Seq::Map", ->(items, &blk) { items.map(&blk) })
 
 sandbox.eval('Seq::Map.call([1, 2, 3]) { |x| x * 2 }')
 # => [2, 4, 6]
@@ -244,13 +319,13 @@ class Greeter
   def greet            = "hi, #{@name}"
 end
 
-sandbox.define(:Factory).bind(:Make, ->(name) { Greeter.new(name) })
+sandbox.bind("Factory::Make", ->(name) { Greeter.new(name) })
 
 sandbox.eval('Factory::Make.call("Bob").greet')  # => "hi, Bob"  (Handle round-trip inside guest)
 sandbox.eval('Factory::Make.call("Bob")')        # => #<Greeter @name="Bob">  (B-37 restoration)
 ```
 
-A `break` value from a guest block is the one exception: it unwinds back to the guest Member call rather than to host code, so a Handle in it stays a Handle — restoring would just re-wrap the same object into a new id on the return trip.
+A `break` value from a guest block is the one exception: it unwinds back to the guest Service call rather than to host code, so a Handle in it stays a Handle — restoring would just re-wrap the same object into a new id on the return trip.
 
 Each dispatch that hands back a non-wire-representable object allocates a *new* Handle — kobako never deduplicates by object identity (B-15, B-17). This is most visible with fluent / builder APIs. An `ActiveRecord::Relation` chain `spawn`s a fresh relation at each step, so every hop is an independent dispatch that binds its own Handle:
 
@@ -319,7 +394,7 @@ class ThemeReader          # only #color is reachable; AppConfig.secret_key is n
 end
 
 sandbox = Kobako::Sandbox.new
-sandbox.define(:Cfg).bind(:Settings, ThemeReader.new)  # not: bind(:Settings, AppConfig)
+sandbox.bind("Cfg::Settings", ThemeReader.new)  # not: bind("Cfg::Settings", AppConfig)
 
 sandbox.eval('Cfg::Settings.color')  # => "#3366ff"  — every other method raises NoMethodError
 ```
@@ -329,7 +404,7 @@ place: a private `respond_to_guest?(name)` answers, per method, whether the gues
 it. Returning `false` for every name makes the object opaque — a credential the guest
 forwards to another Service but never reads — while a named subset becomes an allow-list.
 
-Guest code can name any `<Namespace>::<Member>` path, but a forged name only resolves to
+Guest code can name any `MyService::KV` path, but a forged name only resolves to
 something you bound — the real authorization gate is this host-side allowlist. Give each
 trust context its own Sandbox, and see [`docs/security-model.md`](docs/security-model.md) for the rest
 as security-design concerns: validating untrusted input, default-deny external effects,
@@ -342,15 +417,15 @@ Order-of-magnitude figures on macOS arm64, Ruby 3.4.7, YJIT off. Absolute values
 | Phase                                                        | Cost                  |
 |--------------------------------------------------------------|-----------------------|
 | First `Sandbox.new` ever for a Guest Binary (Module JIT, then disk-cached) | ~500 ms once per machine |
-| First `Sandbox.new` in a fresh process (`.cwasm` cache warm) | ~5 ms one-time        |
-| Subsequent `Sandbox.new` (caches warm)                       | ~30 µs                |
-| Warm `#eval("nil")` on a reused Sandbox                      | ~73 µs                |
-| Warm `#run(:Entrypoint, ...)` dispatch                       | ~104 µs               |
+| First `Sandbox.new` in a fresh process (`.cwasm` cache warm) | ~3 ms one-time        |
+| Subsequent `Sandbox.new` (caches warm)                       | ~28 µs                |
+| Warm `#eval("nil")` on a reused Sandbox                      | ~71 µs                |
+| Warm `#run(:Entrypoint, ...)` dispatch                       | ~97 µs                |
 | Service call amortized inside one invocation                 | ~6.8 µs               |
-| Snippet replay per invocation                                | ~8 µs each            |
+| Snippet replay per invocation                                | ~7.6 µs each          |
 | Per additional idle Sandbox (RSS)                            | ~1 KB                 |
 
-The Cranelift JIT runs once per machine and gem version — the compiled artifact persists in a `.cwasm` disk cache, so later processes deserialize in milliseconds. An idle Sandbox holds no wasm instance (the canonical boot state is baked into the artifact and instantiated per invocation), which is why a thousand idle tenants cost ~32 MB total. `ext/` does not release the GVL during wasmtime execution, so wasm work is GVL-serialized: aggregate throughput stays around 16k `#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.
+The Cranelift JIT runs once per machine and gem version — the compiled artifact persists in a `.cwasm` disk cache, so later processes deserialize in milliseconds. An idle Sandbox holds no wasm instance (the canonical boot state is baked into the artifact and instantiated per invocation), which is why a thousand idle tenants cost ~33 MB total. `ext/` does not release the GVL during wasmtime execution, so wasm work is GVL-serialized: aggregate throughput stays around 17k `#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.
 

data/ROADMAP.md

@@ -3,15 +3,14 @@
 kobako is a Ruby gem providing an in-process Wasm sandbox for untrusted mruby
 code: a wasmtime host runs a precompiled `kobako.wasm` guest, with host↔guest
 Transport over a MessagePack wire. Features cover one-shot `#eval`, preload +
-`#run` dispatch, Service injection through Namespaces / Members, opaque
+`#run` dispatch, Service injection at constant-path names, opaque
 Capability Handles, block yield re-entry, three-class error attribution,
 output capture, and a warm Sandbox pool.
 
 | Feature | Entry Points | Notes |
 |---------|-------------|-------|
 | ✅ [F-01 Sandbox instantiation](docs/behavior/lifecycle.md) | [lib/kobako/sandbox.rb](lib/kobako/sandbox.rb) | B-22 (per-Thread isolation) is exercised only indirectly through the pool contention tests; no test cites it |
-| ✅ [F-02 Namespace declaration](docs/behavior/registration.md) | [lib/kobako/catalog/namespaces.rb](lib/kobako/catalog/namespaces.rb) | — |
-| ✅ [F-03 Member binding](docs/behavior/registration.md) | [lib/kobako/namespace.rb](lib/kobako/namespace.rb) | — |
+| ✅ [F-02 Service binding](docs/behavior/registration.md) | [lib/kobako/catalog/services.rb](lib/kobako/catalog/services.rb) | — |
 | ✅ [F-04 Synchronous mruby source execution (`#eval`)](docs/behavior/lifecycle.md) | [lib/kobako/sandbox.rb](lib/kobako/sandbox.rb) | — |
 | ✅ [F-05 Guest-initiated Transport dispatch](docs/behavior/dispatch.md) | [lib/kobako/transport/dispatcher.rb](lib/kobako/transport/dispatcher.rb) | — |
 | ✅ [F-06 Capability Handle encoding and referencing](docs/behavior/dispatch.md) | [lib/kobako/catalog/handles.rb](lib/kobako/catalog/handles.rb) | — |

data/SECURITY.md

@@ -25,7 +25,7 @@ ask to stay anonymous.
 
 In scope is anything that lets guest code cross the isolation boundary it should not:
 reaching host memory, the filesystem, the network, or `ENV`; obtaining ambient time or
-entropy the host froze; reaching a `Namespace::Member` you never bound; or a
+entropy the host froze; reaching a Service you never bound; or a
 memory-safety fault in the host codec or wasmtime driver.
 
 Out of scope is what a bound Service is *designed* to expose: if guest code reaches a

data/crates/kobako-runtime/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.9.0...kobako-runtime-v0.10.0) (2026-07-12)
+
+
+### Miscellaneous Chores
+
+* **kobako-runtime:** Synchronize kobako crates versions
+
+## [0.9.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.8.0...kobako-runtime-v0.9.0) (2026-07-11)
+
+
+### Miscellaneous Chores
+
+* **kobako-runtime:** Synchronize kobako crates versions
+
 ## [0.8.0](https://github.com/elct9620/kobako/compare/kobako-runtime-v0.7.0...kobako-runtime-v0.8.0) (2026-07-08)
 
 

data/crates/kobako-runtime/Cargo.toml

@@ -13,7 +13,7 @@
 
 [package]
 name = "kobako-runtime"
-version = "0.8.0"
+version = "0.10.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.8.0" # x-release-please-version
+kobako-runtime = "0.10.0" # x-release-please-version
 ```
 
 ## License

data/crates/kobako-runtime/src/snapshot.rs

@@ -9,7 +9,10 @@
 use crate::error::Trap;
 
 /// One captured output channel: the bytes the guest wrote (already clipped
-/// to the channel's cap) and whether the cap was reached.
+/// to the channel's cap) and whether the cap was reached. `Default` is the
+/// pre-invocation sentinel — no bytes, cap not reached — shared by every
+/// frontend's before-first-invocation readout.
+#[derive(Default)]
 pub struct Capture {
     pub bytes: Vec<u8>,
     pub truncated: bool,
@@ -27,8 +30,9 @@ pub enum Completion {
 /// Resource usage of one guest invocation, measured across the same
 /// bracket as the wall-clock / memory caps: `wall_time` is the seconds
 /// spent inside the guest export call; `memory_peak` is the high-water
-/// `memory.grow` delta in bytes past the entry-time baseline.
-#[derive(Clone, Copy)]
+/// `memory.grow` delta in bytes past the entry-time baseline. `Default`
+/// (all zeros) is the pre-invocation sentinel.
+#[derive(Clone, Copy, Default)]
 pub struct Usage {
     pub wall_time: f64,
     pub memory_peak: usize,

data/crates/kobako-wasmtime/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.10.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.9.0...kobako-wasmtime-v0.10.0) (2026-07-12)
+
+
+### Miscellaneous Chores
+
+* **kobako-wasmtime:** Synchronize kobako crates versions
+
+## [0.9.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.8.0...kobako-wasmtime-v0.9.0) (2026-07-11)
+
+
+### Miscellaneous Chores
+
+* **kobako-wasmtime:** Synchronize kobako crates versions
+
 ## [0.8.0](https://github.com/elct9620/kobako/compare/kobako-wasmtime-v0.7.0...kobako-wasmtime-v0.8.0) (2026-07-08)
 
 

data/crates/kobako-wasmtime/Cargo.toml

@@ -15,7 +15,7 @@
 
 [package]
 name = "kobako-wasmtime"
-version = "0.8.0"
+version = "0.10.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.8.0", path = "../kobako-runtime" }
+kobako-runtime = { version = "0.10.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.8.0" # x-release-please-version
+kobako-wasmtime = "0.10.0" # x-release-please-version
 ```
 
 ## License

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

@@ -18,15 +18,19 @@ pub(crate) fn pipe_capacity(cap: Option<usize>) -> usize {
     }
 }
 
-/// Pure slicing core shared by the snapshot readback: given the unclipped
-/// pipe snapshot and the configured cap, return the bytes Ruby should
-/// observe (clipped to `cap`) plus the truncation flag. `truncated` is
-/// `true` only when the snapshot strictly exceeded the cap — this is the
-/// "wrote `cap + 1` bytes into a `cap + 1`-sized pipe" case; "wrote
-/// exactly `cap` bytes" stays `false`.
-pub(crate) fn clip_capture(raw: &[u8], cap: Option<usize>) -> (&[u8], bool) {
+/// Pure clipping core shared by the snapshot readback: given the
+/// unclipped pipe snapshot (owned — truncated in place, so the readback
+/// costs one copy out of the pipe, not two), return the bytes Ruby
+/// should observe plus the truncation flag. `truncated` is `true` only
+/// when the snapshot strictly exceeded the cap — this is the "wrote
+/// `cap + 1` bytes into a `cap + 1`-sized pipe" case; "wrote exactly
+/// `cap` bytes" stays `false`.
+pub(crate) fn clip_capture(mut raw: Vec<u8>, cap: Option<usize>) -> (Vec<u8>, bool) {
     match cap {
-        Some(c) if raw.len() > c => (&raw[..c], true),
+        Some(c) if raw.len() > c => {
+            raw.truncate(c);
+            (raw, true)
+        }
         _ => (raw, false),
     }
 }
@@ -53,14 +57,14 @@ mod tests {
 
     #[test]
     fn clip_capture_returns_full_bytes_when_under_cap() {
-        let (bytes, truncated) = clip_capture(b"abc", Some(5));
+        let (bytes, truncated) = clip_capture(b"abc".to_vec(), Some(5));
         assert_eq!(bytes, b"abc");
         assert!(!truncated);
     }
 
     #[test]
     fn clip_capture_does_not_flag_truncation_at_exactly_cap_bytes() {
-        let (bytes, truncated) = clip_capture(b"abcde", Some(5));
+        let (bytes, truncated) = clip_capture(b"abcde".to_vec(), Some(5));
         assert_eq!(bytes, b"abcde");
         assert!(!truncated);
     }
@@ -70,21 +74,21 @@ mod tests {
         // The pipe is sized `cap + 1`, so the snapshot can be at most
         // 6 bytes when `cap == 5`; that surface is what triggers the
         // truncation flag.
-        let (bytes, truncated) = clip_capture(b"abcdef", Some(5));
+        let (bytes, truncated) = clip_capture(b"abcdef".to_vec(), Some(5));
         assert_eq!(bytes, b"abcde");
         assert!(truncated);
     }
 
     #[test]
     fn clip_capture_treats_none_as_uncapped() {
-        let (bytes, truncated) = clip_capture(b"abcdef", None);
+        let (bytes, truncated) = clip_capture(b"abcdef".to_vec(), None);
         assert_eq!(bytes, b"abcdef");
         assert!(!truncated);
     }
 
     #[test]
     fn clip_capture_handles_empty_input() {
-        let (bytes, truncated) = clip_capture(b"", Some(5));
+        let (bytes, truncated) = clip_capture(Vec::new(), Some(5));
         assert_eq!(bytes, b"");
         assert!(!truncated);
     }

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

@@ -203,19 +203,18 @@ impl Driver {
             wall_time: data.wall_time().as_secs_f64(),
             memory_peak: data.memory_peak(),
         };
-        let (stdout_raw, stderr_raw) = (data.stdout_bytes(), data.stderr_bytes());
-        let (stdout_visible, stdout_truncated) =
-            capture::clip_capture(&stdout_raw, self.config.stdout_limit_bytes);
-        let (stderr_visible, stderr_truncated) =
-            capture::clip_capture(&stderr_raw, self.config.stderr_limit_bytes);
+        let (stdout_bytes, stdout_truncated) =
+            capture::clip_capture(data.stdout_bytes(), self.config.stdout_limit_bytes);
+        let (stderr_bytes, stderr_truncated) =
+            capture::clip_capture(data.stderr_bytes(), self.config.stderr_limit_bytes);
         Snapshot {
             completion,
             stdout: Capture {
-                bytes: stdout_visible.to_vec(),
+                bytes: stdout_bytes,
                 truncated: stdout_truncated,
             },
             stderr: Capture {
-                bytes: stderr_visible.to_vec(),
+                bytes: stderr_bytes,
                 truncated: stderr_truncated,
             },
             usage,